Calculate a 2D homogeneous perspective transformation matrix from 4 points in MATLAB - matlab
I've got coordinates of 4 points in 2D that form a rectangle and their coordinates after a perspective transformation has been applied.
The perspective transformation is calculated in homogeneous coordinates and defined by a 3x3 matrix M. If the matrix is not known, how can I calculate it from the given points?
The calculation for one point would be:
| M11 M12 M13 | | P1.x | | w*P1'.x |
| M21 M22 M23 | * | P1.y | = | w*P1'.y |
| M31 M32 M33 | | 1 | | w*1 |
To calculate all points simultaneously I write them together in one matrix A and analogously for the transformed points in a matrix B:
| P1.x P2.x P3.x P4.x |
A = | P1.y P2.y P3.y P4.y |
| 1 1 1 1 |
So the equation is M*A=B and this can be solved for M in MATLAB by M = B/A or M = (A'\B')'.
But it's not that easy. I know the coordinates of the points after transformation, but I don't know the exact B, because there is the factor w and it's not necessary 1 after a homogeneous transformation. Cause in homogeneous coordinates every multiple of a vector is the same point and I don't know which multiple I'll get.
To take account of these unknown factors I write the equation as M*A=B*W
where W is a diagonal matrix with the factors w1...w4 for every point in B on the diagonal. So A and B are now completely known and I have to solve this equation for M and W.
If I could rearrange the equation into the form x*A=B or A*x=B where x would be something like M*W I could solve it and knowing the solution for M*W would maybe be enough already. However despite trying every possible rearrangement I didn't managed to do so. Until it hit me that encapsulating (M*W) would not be possible, since one is a 3x3 matrix and the other a 4x4 matrix. And here I'm stuck.
Also M*A=B*W does not have a single solution for M, because every multiple of M is the same transformation. Writing this as a system of linear equations one could simply fix one of the entries of M to get a single solution. Furthermore there might be inputs that have no solution for M at all, but let's not worry about this for now.
What I'm actually trying to achieve is some kind of vector graphics editing program where the user can drag the corners of a shape's bounding box to transform it, while internally the transformation matrix is calculated.
And actually I need this in JavaScript, but if I can't even solve this in MATLAB I'm completely stuck.
OpenCV has a neat function that does this called getPerspectiveTransform. The source code for this function is available on github with this description:
/* Calculates coefficients of perspective transformation
* which maps (xi,yi) to (ui,vi), (i=1,2,3,4):
*
* c00*xi + c01*yi + c02
* ui = ---------------------
* c20*xi + c21*yi + c22
*
* c10*xi + c11*yi + c12
* vi = ---------------------
* c20*xi + c21*yi + c22
*
* Coefficients are calculated by solving linear system:
* / x0 y0 1 0 0 0 -x0*u0 -y0*u0 \ /c00\ /u0\
* | x1 y1 1 0 0 0 -x1*u1 -y1*u1 | |c01| |u1|
* | x2 y2 1 0 0 0 -x2*u2 -y2*u2 | |c02| |u2|
* | x3 y3 1 0 0 0 -x3*u3 -y3*u3 |.|c10|=|u3|,
* | 0 0 0 x0 y0 1 -x0*v0 -y0*v0 | |c11| |v0|
* | 0 0 0 x1 y1 1 -x1*v1 -y1*v1 | |c12| |v1|
* | 0 0 0 x2 y2 1 -x2*v2 -y2*v2 | |c20| |v2|
* \ 0 0 0 x3 y3 1 -x3*v3 -y3*v3 / \c21/ \v3/
*
* where:
* cij - matrix coefficients, c22 = 1
*/
This system of equations is smaller as it avoids solving for W and M33 (called c22 by OpenCV). So how does it work? The linear system can be recreated by the following steps:
Start with the equation for one point:
| c00 c01 c02 | | xi | | w*ui |
| c10 c11 c12 | * | yi | = | w*vi |
| c20 c21 c22 | | 1 | | w*1 |
Convert this to a system of equations, solve ui and vi, and eliminate w. You get the formulas for projection transformation:
c00*xi + c01*yi + c02
ui = ---------------------
c20*xi + c21*yi + c22
c10*xi + c11*yi + c12
vi = ---------------------
c20*xi + c21*yi + c22
Multiply both sides with the denominator:
(c20*xi + c21*yi + c22) * ui = c00*xi + c01*yi + c02
(c20*xi + c21*yi + c22) * vi = c10*xi + c11*yi + c12
Distribute ui and vi:
c20*xi*ui + c21*yi*ui + c22*ui = c00*xi + c01*yi + c02
c20*xi*vi + c21*yi*vi + c22*vi = c10*xi + c11*yi + c12
Assume c22 = 1:
c20*xi*ui + c21*yi*ui + ui = c00*xi + c01*yi + c02
c20*xi*vi + c21*yi*vi + vi = c10*xi + c11*yi + c12
Collect all cij on the left hand side:
c00*xi + c01*yi + c02 - c20*xi*ui - c21*yi*ui = ui
c10*xi + c11*yi + c12 - c20*xi*vi - c21*yi*vi = vi
And finally convert to matrix form for four pairs of points:
/ x0 y0 1 0 0 0 -x0*u0 -y0*u0 \ /c00\ /u0\
| x1 y1 1 0 0 0 -x1*u1 -y1*u1 | |c01| |u1|
| x2 y2 1 0 0 0 -x2*u2 -y2*u2 | |c02| |u2|
| x3 y3 1 0 0 0 -x3*u3 -y3*u3 |.|c10|=|u3|
| 0 0 0 x0 y0 1 -x0*v0 -y0*v0 | |c11| |v0|
| 0 0 0 x1 y1 1 -x1*v1 -y1*v1 | |c12| |v1|
| 0 0 0 x2 y2 1 -x2*v2 -y2*v2 | |c20| |v2|
\ 0 0 0 x3 y3 1 -x3*v3 -y3*v3 / \c21/ \v3/
This is now in the form of Ax=b and the solution can be obtained with x = A\b. Remember that c22 = 1.
Should have been an easy question. So how do I get M*A=B*W into a solvable form? It's just matrix multiplications, so we can write this as a system of linear equations. You know like: M11*A11 + M12*A21 + M13*A31 = B11*W11 + B12*W21 + B13*W31 + B14*W41. And every system of linear equations can be written in the form Ax=b, or to avoid confusion with already used variables in my question: N*x=y. That's all.
An example according to my question: I generate some input data with a known M and W:
M = [
1 2 3;
4 5 6;
7 8 1
];
A = [
0 0 1 1;
0 1 0 1;
1 1 1 1
];
W = [
4 0 0 0;
0 3 0 0;
0 0 2 0;
0 0 0 1
];
B = M*A*(W^-1);
Then I forget about M and W. Meaning I now have 13 variables I'm looking to solve. I rewrite M*A=B*W into a system of linear equations, and from there into the form N*x=y. In N every column has the factors for one variable:
N = [
A(1,1) A(2,1) A(3,1) 0 0 0 0 0 0 -B(1,1) 0 0 0;
0 0 0 A(1,1) A(2,1) A(3,1) 0 0 0 -B(2,1) 0 0 0;
0 0 0 0 0 0 A(1,1) A(2,1) A(3,1) -B(3,1) 0 0 0;
A(1,2) A(2,2) A(3,2) 0 0 0 0 0 0 0 -B(1,2) 0 0;
0 0 0 A(1,2) A(2,2) A(3,2) 0 0 0 0 -B(2,2) 0 0;
0 0 0 0 0 0 A(1,2) A(2,2) A(3,2) 0 -B(3,2) 0 0;
A(1,3) A(2,3) A(3,3) 0 0 0 0 0 0 0 0 -B(1,3) 0;
0 0 0 A(1,3) A(2,3) A(3,3) 0 0 0 0 0 -B(2,3) 0;
0 0 0 0 0 0 A(1,3) A(2,3) A(3,3) 0 0 -B(3,3) 0;
A(1,4) A(2,4) A(3,4) 0 0 0 0 0 0 0 0 0 -B(1,4);
0 0 0 A(1,4) A(2,4) A(3,4) 0 0 0 0 0 0 -B(2,4);
0 0 0 0 0 0 A(1,4) A(2,4) A(3,4) 0 0 0 -B(3,4);
0 0 0 0 0 0 0 0 1 0 0 0 0
];
And y is:
y = [ 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1 ];
Notice the equation described by the last row in N whose solution is 1 according to y. That's what I mentioned in my question, you have to fix one of the entries of M to get a single solution. (We can do this because every multiple of M is the same transformation.) And with this equation I'm saying M33 should be 1.
We solve this for x:
x = N\y
and get:
x = [ 1.00000; 2.00000; 3.00000; 4.00000; 5.00000; 6.00000; 7.00000; 8.00000; 1.00000; 4.00000; 3.00000; 2.00000; 1.00000 ]
which are the solutions for [ M11, M12, M13, M21, M22, M23, M31, M32, M33, w1, w2, w3, w4 ]
W is not needed after M has been calculated. For a generic point (x, y), the corresponding w is calculated while solving x' and y'.
| M11 M12 M13 | | x | | w * x' |
| M21 M22 M23 | * | y | = | w * y' |
| M31 M32 M33 | | 1 | | w * 1 |
When solving this in JavaScript I could use the Numeric JavaScript library which has the needed function solve to solve Ax=b.
Related
Different result for same value in sigmoid function [MATLAB]
I am trying to find out the result of the sigmoid function. When I tried to compute it without loop. I did not get the expected result. On the other hand, using for loop getting an actual result.
The question is, Why I am getting different results?
%This is a hypothesis of AND operation
x1 = randi([0,1],[1,4]);
x2 = randi([0,1],[1,4]);
features = [x1;x2]';
theta = [-30 20 20];
x = [ones(length(features),1) features]
z = x * theta';
pred = zeros(length(z),1);
pred = 1 / (1 + exp(-z))
y1 = (pred >= 0.5)
fprintf('Using loop\n')
for i= 1:length(z)
pred(i) = 1 / (1 + exp(-z(i)));
end
pred
y1 = (pred >= 0.5)
Output:
x =
1 1 1
1 0 1
1 0 0
1 0 1
pred =
1.0e-13 *
0 0 0.9358 0
y1 =
0 0 0 0
Using loop
pred =
1.0000 0.0000 0.0000 0.0000
y1 =
1 0 0 0
How to write a varying matrix in matlab?
I have this equation system a set of 1 ≤ n ≤ 30 −(2 + α)x1 + x2 = b1, xj−1 − (2 + α)xj + xj+1 = bj , for 2 ≤ j ≤ 29, x29 − (2 + α)x30 = b30. α = 1 We assume that the membrane is held at the end points (i.e x0 = 0 and x31 = 0). There is no weight on the membrane so all bj = 0 for j = 1 . . . 30 except for j = 6 where a load is applied: b6 = 2. I want to calculate LU factorization of the system . I do not know how to implement the left side of the system in matlab. The right side I made it like this : b=[0 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]'; How to do the left side? Thanks
It's unclear why you have included the entire linear system if you are only interested in the LU factorization of A? Regardless, here is some code which generates your A matrix as described above, and solves the linear system and shows the LU factorization. % equation A*X = b b = zeros(30,1); b(6) = 2; alpha = 1; A = zeros(30, 30); A(1, 1) = -(2 + alpha); A(1, 2) = 1; for i = 2:29 A(i, i-1) = 1; A(i, i) = -(2 + alpha); A(i, i+1) = 1; end A(30, 29) = 1; A(30, 30) = -(2 + alpha); You can then get the LU factorization using lu(A) or solve the linear system of equations using linsolve(A,b).
Writing an adjacency matrix for a graph [duplicate]
Consider a set of points arranged on a grid of size N-by-M. I am trying to build the adjacency matrix such that neighboring points are connected. For example, in a 3x3 grid with a graph: 1-2-3 | | | 4-5-6 | | | 7-8-9 We should have the corresponding adjacency matrix: +---+------------------------------------------------------+ | | 1 2 3 4 5 6 7 8 9 | +---+------------------------------------------------------+ | 1 | 0 1 0 1 0 0 0 0 0 | | 2 | 1 0 1 0 1 0 0 0 0 | | 3 | 0 1 0 0 0 1 0 0 0 | | 4 | 1 0 0 0 1 0 1 0 0 | | 5 | 0 1 0 1 0 1 0 1 0 | | 6 | 0 0 1 0 1 0 0 0 1 | | 7 | 0 0 0 1 0 0 0 1 0 | | 8 | 0 0 0 0 1 0 1 0 1 | | 9 | 0 0 0 0 0 1 0 1 0 | +---+------------------------------------------------------+ As a bonus, the solution should work for both 4- and 8-connected neighboring points, that is: o o o o o X o vs. o X o o o o o This the code that I have so far: N = 3; M = 3; adj = zeros(N*M); for i=1:N for j=1:M k = sub2ind([N M],i,j); if i>1 ii=i-1; jj=j; adj(k,sub2ind([N M],ii,jj)) = 1; end if i<N ii=i+1; jj=j; adj(k,sub2ind([N M],ii,jj)) = 1; end if j>1 ii=i; jj=j-1; adj(k,sub2ind([N M],ii,jj)) = 1; end if j<M ii=i; jj=j+1; adj(k,sub2ind([N M],ii,jj)) = 1; end end end How can this improved to avoid all the looping?
If you notice, there is a distinct pattern to the adjacency matrices you are creating. Specifically, they are symmetric and banded. You can take advantage of this fact to easily create your matrices using the diag function (or the spdiags function if you want to make a sparse matrix). Here is how you can create the adjacency matrix for each case, using your sample matrix above as an example: 4-connected neighbors: mat = [1 2 3; 4 5 6; 7 8 9]; % Sample matrix [r, c] = size(mat); % Get the matrix size diagVec1 = repmat([ones(c-1, 1); 0], r, 1); % Make the first diagonal vector % (for horizontal connections) diagVec1 = diagVec1(1:end-1); % Remove the last value diagVec2 = ones(c*(r-1), 1); % Make the second diagonal vector % (for vertical connections) adj = diag(diagVec1, 1)+diag(diagVec2, c); % Add the diagonals to a zero matrix adj = adj+adj.'; % Add the matrix to a transposed copy of % itself to make it symmetric And you'll get the following matrix: adj = 0 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1 0 1 0 8-connected neighbors: mat = [1 2 3; 4 5 6; 7 8 9]; % Sample matrix [r, c] = size(mat); % Get the matrix size diagVec1 = repmat([ones(c-1, 1); 0], r, 1); % Make the first diagonal vector % (for horizontal connections) diagVec1 = diagVec1(1:end-1); % Remove the last value diagVec2 = [0; diagVec1(1:(c*(r-1)))]; % Make the second diagonal vector % (for anti-diagonal connections) diagVec3 = ones(c*(r-1), 1); % Make the third diagonal vector % (for vertical connections) diagVec4 = diagVec2(2:end-1); % Make the fourth diagonal vector % (for diagonal connections) adj = diag(diagVec1, 1)+... % Add the diagonals to a zero matrix diag(diagVec2, c-1)+... diag(diagVec3, c)+... diag(diagVec4, c+1); adj = adj+adj.'; % Add the matrix to a transposed copy of % itself to make it symmetric And you'll get the following matrix: adj = 0 1 0 1 1 0 0 0 0 1 0 1 1 1 1 0 0 0 0 1 0 0 1 1 0 0 0 1 1 0 0 1 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 0 1 0 0 1 1 0 0 0 1 1 0 0 1 0 0 0 0 1 1 1 1 0 1 0 0 0 0 1 1 0 1 0
Just for fun, here's a solution to construct the adjacency matrix by computing the distance between all pairs of points on the grid (not the most efficient way obviously) N = 3; M = 3; %# grid size CONNECTED = 8; %# 4-/8- connected points %# which distance function if CONNECTED == 4, distFunc = 'cityblock'; elseif CONNECTED == 8, distFunc = 'chebychev'; end %# compute adjacency matrix [X Y] = meshgrid(1:N,1:M); X = X(:); Y = Y(:); adj = squareform( pdist([X Y], distFunc) == 1 ); And here's some code to visualize the adjacency matrix and the graph of connected points: %# plot adjacency matrix subplot(121), spy(adj) %# plot connected points on grid [xx yy] = gplot(adj, [X Y]); subplot(122), plot(xx, yy, 'ks-', 'MarkerFaceColor','r') axis([0 N+1 0 M+1]) %# add labels [X Y] = meshgrid(1:N,1:M); X = reshape(X',[],1) + 0.1; Y = reshape(Y',[],1) + 0.1; text(X, Y(end:-1:1), cellstr(num2str((1:N*M)')) )
I just found this question when searching for the same problem. However, none of the provided solutions worked for me because of the problem size which required the use of sparse matrix types. Here is my solution which works on large scale instances: function W = getAdjacencyMatrix(I) [m, n] = size(I); I_size = m*n; % 1-off diagonal elements V = repmat([ones(m-1,1); 0],n, 1); V = V(1:end-1); % remove last zero % n-off diagonal elements U = ones(m*(n-1), 1); % get the upper triangular part of the matrix W = sparse(1:(I_size-1), 2:I_size, V, I_size, I_size)... + sparse(1:(I_size-m),(m+1):I_size, U, I_size, I_size); % finally make W symmetric W = W + W';
Just came across this question. I have a nice working m-function (link: sparse_adj_matrix.m) that is quite general. It can handle 4-connect grid (radius 1 according to L1 norm), 8-connect grid (radius 1 according to L_infty norm). It can also support 3D (and arbitrarily higher domensional grids). The function can also connect nodes further than radius = 1. Here's the signiture of the function: % Construct sparse adjacency matrix (provides ii and jj indices into the % matrix) % % Usage: % [ii jj] = sparse_adj_matrix(sz, r, p) % % inputs: % sz - grid size (determine the number of variables n=prod(sz), and the % geometry/dimensionality) % r - the radius around each point for which edges are formed % p - in what p-norm to measure the r-ball, can be 1,2 or 'inf' % % outputs % ii, jj - linear indices into adjacency matrix (for each pair (m,n) % there is also the pair (n,m)) % % How to construct the adjacency matrix? % >> A = sparse(ii, jj, ones(1,numel(ii)), prod(sz), prod(sz)); % % % Example: % >> [ii jj] = sparse_adj_matrix([10 20], 1, inf); % construct indices for 200x200 adjacency matrix for 8-connect graph over a % grid of 10x20 nodes. % To visualize the graph: % >> [r c]=ndgrid(1:10,1:20); % >> A = sparse(ii, jj, 1, 200, 200);; % >> gplot(A, [r(:) c(:)]);
Your current code doesn't seem so bad. One way or another you need to iterate over all neighbor pairs. If you really need to optimize the code, I would suggest: loop over node indices i, where 1 <= i <= (N*M) don't use sub2ind() for efficiency, the neighbors of node i are simpy [i-M, i+1, i+M, i-1] in clockwise order Notice that to get all neighbor pairs of nodes: you only have to compute the "right" neighbors (i.e. horizontal edges) for nodes i % M != 0 (since Matlab isn't 0-based but 1-based) you only have to compute "above" neighbors (i.e. vertical edges) for nodes i > M there is a similar rule for diagonal edges This would leed to a single loop (but same number of N*M iterations), doesn't call sub2ind(), and has only two if statements in the loop.
For each node in the graph add a connection to the right and one downwards. Check that you don't overreach your grid. Consider the following function that builds the adjacency matrix. function adj = AdjMatrixLattice4( N, M ) % Size of adjacency matrix MN = M*N; adj = zeros(MN,MN); % number nodes as such % [1]---[2]-- .. --[M] % | | | % [M+1]-[M+2]- .. -[2*M] % : : : % [] [] .. [M*N] for i=1:N for j=1:N A = M*(i-1)+j; %Node # for (i,j) node if(j<N) B = M*(i-1)+j+1; %Node # for node to the right adj(A,B) = 1; adj(B,A) = 1; end if(i<M) B = M*i+j; %Node # for node below adj(A,B) = 1; adj(B,A) = 1; end end end end Example as above AdjMatrixLattice4(3,3)= 0 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1 0 1 0
Indexing of 2D array in matlab
I have a 6X4 matrix M1 containing only zeros. I also have two 1D arrays Y1 and Y2 each with length 4.The two arrays contain the desired index values. Now, I want to set(convert to 1) the elements of matrix M1 such that M1(Y1:Y2) is equal to 1 for ex: Y1=[1 2 2 1] and Y2=[3 4 5 3] then, M1 should be 1 0 0 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 1 0 0 0 0 0 I can do this using for loop. But is there any optimised way to do it? (I intend to use much bigger matrices)
use cumsum! >> szM = size(M1); >> M1( sub2ind( szM, Y1, 1:szM(2) ) ) = 1 M1 = 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 >> M1( sub2ind( szM, Y2+1, 1:szM(2) ) ) = -1 M1 = 1 0 0 1 0 1 1 0 0 0 0 0 -1 0 0 -1 0 -1 0 0 0 0 -1 0 >> M = cumsum(M,1) M = 1 0 0 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 1 0 0 0 0 0 A pitfall: If any of Y2 equals 6 than setting Y2+1 to -1 will exceed matrix dimension. To fix this you can add two lines before setting to -1 the elements of M: >> cols = 1:szM(2); >> sel = Y2 < szM(1); >> M1( sub2ind( szM, Y2(sel)+1, cols(sel) ) ) = -1 A spin-off for Pavan Yalamanchili's answer using bsxfun: (hover to see:) using bsxfun without offsets: M1 = bsxfun( #ge, (1:size(M1,1))', Y1 ) & bsxfun( #le, (1:size(M1,1))', Y2 );
There may be other techniques, but this uses element wise operations which are insanely parallel. A very simple solution. Thanks #Shai >> [rows, cols] = size(M); >> Y1=[1 2 2 1]; Y2=[3 4 5 3]; >> M = bsxfun(#ge, (1:rows)', Y1) & bsxfun(#le, (1:rows)', Y2) M = 1 0 0 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 1 0 0 0 0 0 Unnecessarily complicated code [rows, cols] = size(M); offsets = ((1 : cols) - 1) * rows Y1 = offsets + Y1; Y2 = offsets + Y2; M = reshape(1:numel(M), rows, cols); M = bsxfun(#ge, M, Y1) & bsxfun(#le, M, Y2);
Matlab, linear programming
I want to solve this linear programming (simplex) problem using MATLAB 7, but it returns Exiting: the problem is unbounded. This function f = 2(15 s0 + 8s1 + 2576s2 + 744s3 + 427s4 + 8s5) Should be minimized in such a way that two constraints for each observation are satisfied 0.1s0 + 0.1s1 + 14.5s2 + 4s3 + 2.4s4 – a0 − a1 − 145a2 − 40a3 − 24a4 ≥ −2.2 0.1s0 + 0.1s1 + 14.5s2 + 4s3 + 2.4s4 + a0 + a1 + 145a2 + 40a3 + 24a4 ≥ 2.2 S5 and a5 are 0. I used f = [15 8 2576 744 427 8 15 8 2576 744 427 8]; b = [-2.2; 2.2]; a = [0.1 0.1 14.5 0.4 2.4 0 -1 -1 -145 -40 -24 0 ; 0.1 0.1 14.5 4 2.4 0 1 1 145 40 24 0]; [x, fval, exitflag, output, lambda] = linprog(f, a, b) What is the right way to solve this problem?
You didn't constrain your s5 and a5 to actually be zero, since you set the corresponding coefficients in the a matrix to zero. Thus, they can take on any value, and the LP is unbounded. To fix, add an equality constraint: beq = [0; 0]; aeq = [0 0 0 0 0 1 0 0 0 0 0 0; 0 0 0 0 0 0 0 0 0 0 0 1]; [x,fval,exitflag,output,lambda] = linprog(f,a,b,aeq,beq) Or, just drop s5 and a5 from the LP since they don't contribute at all.