I have 10 data for b which I am reading from an excel file. I am trying to get 10 (3x3) rotation matrices by substituting in the matrix [1 0 0; 0 cos(a) -sin(a); 0 sin(a) cos(a)]. However, my code generates (30x3) matrices. Can I generate 10 3x3 matrices directly or is there a way to join the three consecutive rows together to make 10 3x3 matrices from (30x3) matrices?
syms a b
b = xlsread('C:\Desktop\Data.xlsx');
r = subs([1 0 0 0 cos(a) -sin(a) 0 sin(a) cos(a)], b)
rx = vec2mat(r,3)
Further developing the answer to get the final rotational matrix, the above structure is repeated thrice as shown below
syms a b c d rx ry rz rm
b = xlsread('C:\Desktop\Data.xlsx','A1:A10');
c = xlsread('C:\Desktop\Data.xlsx','B1:B10');
d = xlsread('C:\Desktop\Data.xlsx','C1:C10');
rx = reshape(vec2mat(subs([1 0 0 0 cosd(a) -sind(a) 0 sind(a) cosd(a)], b), 3).',3,3,numel(b));
ry = reshape(vec2mat(subs([cosd(a) 0 sind(a) 0 1 0 -sind(a) 0 cosd(a)], c), 3).',3,3,numel(b));
rz = reshape(vec2mat(subs([cosd(a) -sind(a) 0 sind(a) cosd(a) 0 0 0 1], d), 3).',3,3,numel(b));
rm = rx.*ry.*rz;
The answers given by the algorithm is right as follows for the angles (34, 0, 100) angles in degrees
[-cos((4*pi)/9), 0 , 0]
[0, -cos((4*pi)/9*cos((17*pi)/90), 0]
[0, 0, cos((17*pi)/90)]
instead of
rm =
0.8623 0 0
0 -0.7317 0
0 0 -0.8486
I am looking for a single matrix solution with decimal values (Not in terms of pi).
After your edit, I'm even more wondering, why you need symbolic variables and functions in the first place, if your desired result should be plain numerical.
So, avoiding symbolics: For each of your (single) rotation matrices as well as the combined rotation matrix, set up an anonymous function. Then, you can use arrayfun to generate the combined rotation matrix for each parameter set.
Here's some code:
% Parameters (from file, ...)
b = [34, 20, 30];
c = [0, 21, 31];
d = [100, 22, 32];
% Anonymous functions: (Single) rotation matrices
rot_x = #(alpha) [1 0 0; 0 cos(alpha) -sin(alpha); 0 sin(alpha) cos(alpha)];
rot_y = #(beta) [cos(beta) 0 sin(beta); 0 1 0; -sin(beta) 0 cos(beta)];
rot_z = #(gamma) [cos(gamma) -sin(gamma) 0; sin(gamma) cos(gamma) 0; 0 0 1];
% Anonymous function: Combined rotation matrix
rot_m = #(alpha, beta, gamma) rot_x(alpha) .* rot_y(beta) .* rot_z(gamma);
% Calculate combined rotation matrix for all parameter sets
rot_mats = arrayfun(rot_m, b, c, d, 'UniformOutput', false)
We get the following output:
rot_mats =
{
[1,1] =
0.86232 0.00000 0.00000
-0.00000 -0.73174 -0.00000
-0.00000 0.00000 -0.84857
[1,2] =
0.54771 0.00000 0.00000
-0.00000 -0.40807 -0.00000
-0.00000 0.00000 -0.22352
[1,3] =
0.76310 -0.00000 -0.00000
0.00000 0.12868 0.00000
0.00000 -0.00000 0.14110
}
As you can see, the first one is exactly your example – but, please pay attention: In your edit, you used sind and cosd, whereas the data from your example indicate, you were using sin and cos here!
Hope that helps!
Disclaimer: Tested with Octave 5.1.0, but also works with MATLAB Online.
I have a matrix with large rows and columns as follows:
A = 0 0 0 0
0 0 0 0
0 0 0 0
2000 11 16 -0.74
0 0 0 0
0 0 0 0
2000 12 26 -0.84
0 0 0 0
0 0 0 0
I need to remove all the zeros from the matrix to get output like,
B = 2000 11 16 -0.74
2000 12 26 -0.84
I have tried an available solution over here like,
B = A(A~=0)
It removes zeros but gives output like,
2000
2000
11
12
-0.74
-0.84
How to get the desired output?
assuming A is a two dimensional matrix
A(any(A,2),:)
will do.
Example:
>> A=[rand(2,3); zeros(3); rand(1,3)]
A =
0.13878 0.44315 0.25832
0.01879 0.93844 0.57537
0.00000 0.00000 0.00000
0.00000 0.00000 0.00000
0.00000 0.00000 0.00000
0.50581 0.37870 0.56563
>> A(any(A,2),:)
ans =
0.138776 0.443152 0.258325
0.018794 0.938439 0.575371
0.505809 0.378696 0.565632
I want to change the diagonal values if equal to 1.
is it possible to look for diagonals and change the values in this particular diagonal to another value.
For example:
X =
1 1 1 0
1 1 0 1
1 0 1 1
0 1 1 1
I want to change this diagonal :
1
0
1
to
2.2
0
2.2
I tried:
XX(logical(eye(size(XX)))) = 2
but this will change all the values not only ones.
Could you please explain how to do that for other diagonals?
The function diag is useful to manipulate diagonals. It only extracts a diagonal from a matrix, or forms a new matrix given a vector of diagonal elements. But with appropriate arithmetic this is sufficient:
X = [1 1 1 0
1 1 0 1
1 0 1 1
0 1 1 1];
k = 2; % which diagonal to change
d = diag(X,k); % the old diagonal
n = d;
n(n==1) = 2.2; % the new diagonal values
X = X - diag(d,k) + diag(n,k); % subtract old values from diagonal, add new ones
Output:
X =
1.00000 1.00000 2.20000 0.00000
1.00000 1.00000 0.00000 2.20000
1.00000 0.00000 1.00000 1.00000
0.00000 1.00000 1.00000 1.00000
Here comes a solution only using linear indexing. I wanted to avoid generating additional matrices. Nothing's wrong with Cris Luengo's answer, that was just for fun.
% Input.
X = [1 1 1 0
1 1 0 1
1 0 1 1
0 1 1 1]
% Which diagonal to change.
k = 2;
% Determine dimension.
dim = size(X, 1);
% Calculate indices of diagonal elements.
idx = (max(abs(k), k * dim) + 1):(dim + 1):numel(X);
idx = idx(1:end+min(k+1, 0));
% Replace diagonal elements with new value.
X(idx(X(idx) == 1)) = 2.2
Output:
X =
1.00000 1.00000 2.20000 0.00000
1.00000 1.00000 0.00000 2.20000
1.00000 0.00000 1.00000 1.00000
0.00000 1.00000 1.00000 1.00000
I have rotation matrix which is not orthogonal. Whats wrong. I can't get it.
Exterior=[-6.6861,12.6118,-8.0660,[-0.4467,-0.3168,0.2380]*pi/180];%# deg 2 rad
%#data
ax=Exterior(4);
by=Exterior(5);
cz=Exterior(6);
%#Rotation in X
Rx = [1 0 0
0 cos(ax) -sin(ax)
0 sin(ax) cos(ax)];
%#Rotation in Y
Ry = [cos(by) 0 sin(by)
0 1 0
-sin(by) 0 cos(by)];
%#Rotation in Z
Rz = [cos(cz) -sin(cz) 0
sin(cz) cos(cz) 0
0 0 1];
R=Rx*Ry*Rz;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
R =
0.99998 -0.0041538 -0.0055292
0.0041969 0.99996 0.0077962
0.0054966 -0.0078192 0.99995
Orthogonality check
Inv(R)-R'=
2.2204e-016 2.6021e-018 8.6736e-019
0 1.1102e-016 -1.7347e-018
-2.6021e-018 3.4694e-018 2.2204e-016
R*R'=
2.2204e-016 2.6021e-018 8.6736e-019
0 1.1102e-016 -1.7347e-018
-2.6021e-018 3.4694e-018 2.2204e-016
Why there is different signs.???????
Any mistake??
Looks like the numbers in your orthogonality check are just due to rounding errors... They're really quite tiny.
There is an error in the question, pointed out by #ChisA. The OP pasted the same matrix for inv(R)-R' and R*R'
If we reconstruct the input file:
Exterior = [-6.681,12.6118,-8.0660,[-0.4467,-03168,0.2380]*pi/180]
ax = Exterior(4)
by = Exterior(5)
cz = Exterior(6)
Rx = [1 0 0 ; 0 cos(ax) -sin(ax) ; 0 sin(ax) cos(ax)]
Ry = [cos(by) 0 sin(by) ; 0 1 0 ; -sin(by) 0 cos(by)]
Rz = [cos(cz) -sin(cz) 0 ; sin(cz) cos(cz) 0 ; 0 0 1]
R = Rx*Ry*Rz
inv(R)-R'
R*R'
And run in through Octave (I don't have MATLAB):
Exterior =
-6.6810e+00 1.2612e+01 -8.0660e+00 -7.7964e-03 -5.5292e+01 4.1539e-03
ax = -0.0077964
by = -55.292
cz = 0.0041539
Rx =
1.00000 0.00000 0.00000
0.00000 0.99997 0.00780
0.00000 -0.00780 0.99997
Ry =
0.30902 0.00000 0.95106
0.00000 1.00000 0.00000
-0.95106 0.00000 0.30902
Rz =
0.99999 -0.00415 0.00000
0.00415 0.99999 0.00000
0.00000 0.00000 1.00000
R =
0.3090143 -0.0012836 0.9510565
-0.0032609 0.9999918 0.0024092
-0.9510518 -0.0038458 0.3090076
ans =
-5.5511e-17 1.3010e-18 1.1102e-16
2.1684e-19 0.0000e+00 -4.3368e-19
-1.1102e-16 -4.3368e-19 -5.5511e-17
ans =
1.0000e+00 -1.9651e-19 -4.6621e-18
-1.9651e-19 1.0000e+00 8.4296e-19
-4.6621e-18 8.4296e-19 1.0000e+00
Notice the R*R' is very close to I and inv(R)-R' is very close to 0.
Notice also that I get different small values than the OP. Because I am using a different piece of software the rounding errors will be different. So you should never rely on an exact comparison between two floating point numbers. You always should include some tolerance.
I hope this makes things a little clearer. See the comment by #gnovice below for links to more detailed information about rounding errors.
I don't understand why R*R' should be nearly zero. It should be the 3x3 identity matrix.
You might have a copy and paste error on your original question.
This is the following part of the below:
2) Additional question:
After getting the average of the non-zero neighbors, I also want to test if the neighbor elements are equal, lesser, or greater than the average of the nonzeros. If it is greater or equal then '1' or else '0'.
Note: if the neighbors are with in the radius of the two or more centres, take the smallest centre average to test.
0 12 9
4 **9** 15
11 19 0
The '9' in the middle is within the radius of 12, 15, and 19 centres, so take the minimum average of those min[9.000, 9.000, 8.000]=8.000
For example, when radius = 1 m or 1 element away.
new_x =
0 0 0 0 0
0 0 **9.0000** 9.0000 0
0 4.0000 9.0000 **9.0000** 0
0 **8.3333** **8.0000** 0 0
0 2.0000 4.0000 8.0000 0
0 4.0000 5.0000 8.0000 0
0 0 0 0 0
Test_x =
0 0 0 0 0
0 0 **9.0000** 1 0
0 0 1 **9.0000** 0
0 **8.3333** **8.0000** 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
=================================================================================
1) Say if I have a matrix, shown as below,
X =
0 0 0 0 0
0 0 12 9 0
0 4 9 15 0
0 11 19 0 0
0 2 4 8 0
0 4 5 8 0
0 0 0 0 0
and I want to find the average of the surrounding non-zero elements that is greater than 10. The rest of the elements still remain the same i.e. elements < 10.
So I want my solution to look something like,
new_x =
0 0 0 0 0
0 0 9.0000 9.0000 0
0 4.0000 9.0000 9.0000 0
0 8.3333 8.0000 0 0
0 2.0000 4.0000 8.0000 0
0 4.0000 5.0000 8.0000 0
0 0 0 0 0
Not: that I am NOT only looking at the neighbors of the element thats greather than some value (i.e. 10 in this case).
Lets say any elements thats are greater than 10 are the 'centre' and we want to find the avearge of the non-zeros with the radius of say 1 m. where 1 metre = 1 element away from the centre.
Note: It might not always be 1 meter away in radius i.e. can be 2 or more. In this case it wont be just top, bottom, left and right of the centre.
****Also Be aware of the matrix boundary. For example, when radius = 2 or more, some of the average of nonzero neighbors are out side the boundary.**
For example,
For radius =1 m = 1 element away,
new_x = average of [(i+1,j) , (i-1,j) , (i,j+1) and (i,j-1)] - top, bottom, right, and left of the centre.
For radius =2 m = 2 elements away,
new_x = average of [(i+1,j), (i+2,j) , (i-1,j) , (i-2,j), (i,j+1), (i,j+2), (i,j-1), (i,j-2), (i+1,j+1), (i+1,j-1), (i-1,j-1), and (i-1,j+1)].
==================================================================
I have tried a few things before, however I am not familiar with the functions.
So please help me to solve the problem.
Thank you in advance.
EDIT:
Note this requires functions from the Image Processing Toolbox, namely: COLFILT and STREL
r = 1; %# radius
t = 10; %# threshold value
mid = round((2*r+1)^2/2); %# mid point
nhood = getnhood(strel('diamond', r));
nhood(mid) = false;
fcn = #(M)sum(M(nhood(:),:),1)./(sum(M(nhood(:),:)~=0)+all(M(nhood(:),:)==0)).*(M(mid,:)>=t)+M(mid,:).*(M(mid,:)<t);
new_x = colfilt(x, 2*[r r]+1, 'sliding',fcn)
For r=1:
new_x =
0 0 0 0 0
0 0 9 9 0
0 4 9 9 0
0 8.3333 8 0 0
0 2 4 8 0
0 4 5 8 0
0 0 0 0 0
For r=2:
new_x =
0 0 0 0 0
0 0 11.2 9 0
0 4 9 10.167 0
0 7 7.7778 0 0
0 2 4 8 0
0 4 5 8 0
0 0 0 0 0
In fact, it should work for any radius >= 1
Notice how the diamond shape structuring element represents the neighborhood:
nhood =
0 1 0
1 0 1
0 1 0
nhood =
0 0 1 0 0
0 1 1 1 0
1 1 0 1 1
0 1 1 1 0
0 0 1 0 0
and so on..
Explanation:
We use the COLFILT function which traverse the matrix using a sliding neighborhood of NxN, and places each block as a column in a temporary matrix.
We process each column of this temp matrix (blocks) using the function fcn, and the result will be placed in the correct location once finished (COLFILT uses IM2COL and COL2IM underneath).
We check for two cases depending of the value of the center of the block:
If its less than 10, it returns that value unchanged: M(mid,:)
if its >=10, we compute the mean of the non-zero elements of its neighborhood
sum(M(nhood(:),:),1) ./ (sum(M(nhood(:),:)~=0) + all(M(nhood(:),:)==0)).
The last term in there is necessary to avoid dividing by zero
Notice how the result of 1 & 2 above are combined using R1.*(M(mid,:)<t) + R2.*(M(mid,:)>=t) to emulate an if/else choice.
Here is the algorithm I think you are describing in your question. For each pixel:
If the pixel value is less than 10, do nothing.
If the pixel value is greater than or equal to 10, replace the pixel value by the average of the non-zero 4-connected nearest neighbors.
If this is correct (as it appears to be from the sample matrices you gave), then you could use the function NLFILTER from the Image Processing Toolbox (if you have access to it) to perform this operation:
fcn = #(x) [x(5) sum(x(2:2:8))/max(sum(x(2:2:8) > 0),1)]*[x(5) < 10; x(5) >= 10];
new_x = nlfilter(X,[3 3],fcn);
EDIT: If you don't have access to the Image Processing Toolbox, you can also do this using the built-in CONV2 function, like so:
kernel = [0 1 0; ... %# Convolution kernel
1 0 1; ...
0 1 0];
sumX = conv2(X,kernel,'same'); %# Compute the sum of neighbors
%# for each pixel
nX = conv2(double(X > 0),kernel,'same'); %# Compute the number of non-zero
%# neighbors for each pixel
index = (X >= 10); %# Find logical index of pixels >= 10
new_x = X; %# Initialize new_x
new_x(index) = sumX(index)./max(nX(index),1); %# Replace the pixels in index
%# with the average of their
%# non-zero neighbors
The above handles your radius = 1 case. To address your radius = 2 case, you just have to change the convolution kernel to the following and rerun the above code:
kernel = [0 0 1 0 0; ...
0 1 1 1 0; ...
1 1 0 1 1; ...
0 1 1 1 0; ...
0 0 1 0 0];
You could do something like this: (tested in Octave, should work in matlab)
octave-3.2.3:17> toohigh = (x>=10)
toohigh =
0 0 0 0 0
0 0 1 0 0
0 0 0 1 0
0 1 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
octave-3.2.3:18> nbr_avg = filter2(ones(3,3)/9,x)
nbr_avg =
0.00000 1.33333 2.33333 2.33333 1.00000
0.44444 2.77778 5.44444 5.00000 2.66667
1.66667 6.11111 8.77778 7.11111 2.66667
1.88889 5.44444 8.00000 6.11111 2.55556
1.88889 5.00000 6.77778 4.88889 1.77778
0.66667 1.66667 3.44444 2.77778 1.77778
0.44444 1.00000 1.88889 1.44444 0.88889
octave-3.2.3:19> y=x; y(toohigh) = nbr_avg(toohigh)
y =
0.00000 0.00000 0.00000 0.00000 0.00000
0.00000 0.00000 5.44444 9.00000 0.00000
0.00000 4.00000 9.00000 7.11111 0.00000
0.00000 5.44444 8.00000 0.00000 0.00000
0.00000 2.00000 4.00000 8.00000 0.00000
0.00000 4.00000 5.00000 8.00000 0.00000
0.00000 0.00000 0.00000 0.00000 0.00000
The filter2 function allows you to filter on neighbors (not sure what function you want...), and if you use a boolean index matrix (toohigh in this case) to select those members of the original matrix that are too high, you can replace them with the ones you want.
More specifically, filter2 allows you to convolve with an arbitrary matrix. The matrix of all ones does a spatial low pass filter.
note: my math doesn't match yours. I'm not quite sure why you want to average only the nonzero neighbors (that gives higher weight to nonzero neighbors when there are zeros), but if you wanted to do that, you could do filter2(ones(3,3),x) ./ M where M = filter2(ones(3,3),(x ~= 0)) is the count of nonzero neighbors.
EDIT: Here is a solution that does not require the Image Processing Toolbox. It does, however, use conv2nan.m which is part of the free NaN toolbox.
This approach relies on doing two different filtering/convolution operations: one that gets the sum of surrounders for each element, and one that gets the count of nonzero surrounders. Then, you are ready to combine them to get the average of nonzero surrounders only. Like this:
% set up starting point matrix with some zeros
X = magic(4);
X(X < 5) = 0;
X(X == 0) = NaN; % convert zeros to NaNs to work with conv2nan
countmat = double(X > 0);
cmat = [0 1 0;
1 0 1;
0 1 0]; % consider surrounding elements only
[m1,c] = conv2nan(X,cmat); % sum of surrounding elements
[m2,c] = conv2nan(countmat,cmat); % number of surrounding elements > 0
x_new = m1./m2; % compute average we want
x_new = x_new(2:end-1,2:end-1); % trim edges created by conv2
x_new(~countmat) = 0; % restore zero elements
x_new(X < 10) = X(X < 10) % restore < 10 elements
It does some extra work in that the convolutions are done for all elements and not just those that are >= 10. But it's more general than the manual looping approach.