Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
RotatableMatrix	32	64	22	0.00%	Show methods
RotatableMatrix.Axis	58	0	0	-1.0 -	Show methods

Class RotatableMatrix

Class RotatableMatrix	Line # 32	Total Statements 64	Complexity 22	TOTAL Coverage 0.00%
<clinit>, line 41()   <clinit>, line 41()	4141	9.09	2.02	0.0 0.00%
RotatableMatrix()   RotatableMatrix()	6969	3.03	2.02	0.0 0.00%
setValue(int,int,float) : void   setValue(int,int,float) : void	8585	1.01	1.01	0.0 0.00%
getValue(int,int) : float   getValue(int,int) : float	9797	1.01	1.01	0.0 0.00%
print(PrintStream) : void   print(PrintStream) : void	105105	3.03	1.01	0.0 0.00%
rotate(float,Axis) : void   rotate(float,Axis) : void	119119	2.02	1.01	0.0 0.00%
getRotation(float,Axis) : float[][]   getRotation(float,Axis) : float[][]	135135	29.029	5.05	0.0 0.00%
vectorMultiply(float[]) : float[]   vectorMultiply(float[]) : float[]	188188	4.04	2.02	0.0 0.00%
preMultiply(float[][]) : void   preMultiply(float[][]) : void	208208	5.05	3.03	0.0 0.00%
postMultiply(float[][]) : void   postMultiply(float[][]) : void	231231	5.05	3.03	0.0 0.00%
vectorMultiply(Point) : Point   vectorMultiply(Point) : Point	254254	2.02	1.01	0.0 0.00%

 

Class RotatableMatrix.Axis

Class RotatableMatrix.Axis	Line # 58	Total Statements 0	Complexity 0	TOTAL Coverage -1.0 -

 

Contributing tests

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.math;
22
23		import jalview.datamodel.Point;
24
25		import java.io.PrintStream;
26		import java.util.HashMap;
27		import java.util.Map;
28
29		/**
30		* Model for a 3x3 matrix which provides methods for rotation in 3-D space
31		*/
		0% Uncovered Elements: 91 (91) Complexity: 22 Complexity Density: 0.34
32		public class RotatableMatrix
33		{
34		private static final int DIMS = 3;
35
36		/*
37		* cache the most used rotations: +/- 1, 2, 3, 4 degrees around x or y axis
38		*/
39		private static Map<Axis, Map<Float, float[][]>> cachedRotations;
40
		0% Uncovered Elements: 11 (11) Complexity: 2 Complexity Density: 0.22
41	0	static...
42		{
43	0	cachedRotations = new HashMap<>();
44	0	for (Axis axis : Axis.values())
45		{
46	0	HashMap<Float, float[][]> map = new HashMap<>();
47	0	cachedRotations.put(axis, map);
48	0	for (int deg = 1; deg < 5; deg++)
49		{
50	0	float[][] rotation = getRotation(deg, axis);
51	0	map.put(Float.valueOf(deg), rotation);
52	0	rotation = getRotation(-deg, axis);
53	0	map.put(Float.valueOf(-deg), rotation);
54		}
55		}
56		}
57
		- Uncovered Elements: 0 (0) Complexity: 0 Complexity Density: -
58		public enum Axis
59		{
60		X, Y, Z
61		}
62
63		float[][] matrix;
64
65		/**
66		* Constructor creates a new identity matrix (all values zero except for 1 on
67		* the diagonal)
68		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
69	0	public RotatableMatrix()...
70		{
71	0	matrix = new float[DIMS][DIMS];
72	0	for (int j = 0; j < DIMS; j++)
73		{
74	0	matrix[j][j] = 1f;
75		}
76		}
77
78		/**
79		* Sets the value at position (i, j) of the matrix
80		*
81		* @param i
82		* @param j
83		* @param value
84		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
85	0	public void setValue(int i, int j, float value)...
86		{
87	0	matrix[i][j] = value;
88		}
89
90		/**
91		* Answers the value at position (i, j) of the matrix
92		*
93		* @param i
94		* @param j
95		* @return
96		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
97	0	public float getValue(int i, int j)...
98		{
99	0	return matrix[i][j];
100		}
101
102		/**
103		* Prints the matrix in rows of space-delimited values
104		*/
		0% Uncovered Elements: 3 (3) Complexity: 1 Complexity Density: 0.33
105	0	public void print(PrintStream ps)...
106		{
107	0	ps.println(matrix[0][0] + " " + matrix[0][1] + " " + matrix[0][2]);
108	0	ps.println(matrix[1][0] + " " + matrix[1][1] + " " + matrix[1][2]);
109	0	ps.println(matrix[2][0] + " " + matrix[2][1] + " " + matrix[2][2]);
110		}
111
112		/**
113		* Rotates the matrix through the specified number of degrees around the
114		* specified axis
115		*
116		* @param degrees
117		* @param axis
118		*/
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
119	0	public void rotate(float degrees, Axis axis)...
120		{
121	0	float[][] rot = getRotation(degrees, axis);
122
123	0	preMultiply(rot);
124		}
125
126		/**
127		* Answers a matrix which, when it pre-multiplies another matrix, applies a
128		* rotation of the specified number of degrees around the specified axis
129		*
130		* @param degrees
131		* @param axis
132		* @return
133		* @see https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
134		*/
		0% Uncovered Elements: 31 (31) Complexity: 5 Complexity Density: 0.17
135	0	protected static float[][] getRotation(float degrees, Axis axis)...
136		{
137	0	Float floatValue = Float.valueOf(degrees);
138	0	if (cachedRotations.get(axis).containsKey(floatValue))
139		{
140		// jalview.bin.Console.outPrintln("getRotation from cache: " + (int)
141		// degrees);
142	0	return cachedRotations.get(axis).get(floatValue);
143		}
144
145	0	float costheta = (float) Math.cos(degrees * Math.PI / 180f);
146
147	0	float sintheta = (float) Math.sin(degrees * Math.PI / 180f);
148
149	0	float[][] rot = new float[DIMS][DIMS];
150
151	0	switch (axis)
152		{
153	0	case X:
154	0	rot[0][0] = 1f;
155	0	rot[1][1] = costheta;
156	0	rot[1][2] = sintheta;
157	0	rot[2][1] = -sintheta;
158	0	rot[2][2] = costheta;
159	0	break;
160	0	case Y:
161	0	rot[0][0] = costheta;
162	0	rot[0][2] = -sintheta;
163	0	rot[1][1] = 1f;
164	0	rot[2][0] = sintheta;
165	0	rot[2][2] = costheta;
166	0	break;
167	0	case Z:
168	0	rot[0][0] = costheta;
169	0	rot[0][1] = -sintheta;
170	0	rot[1][0] = sintheta;
171	0	rot[1][1] = costheta;
172	0	rot[2][2] = 1f;
173	0	break;
174		}
175	0	return rot;
176		}
177
178		/**
179		* Answers a new array of float values which is the result of pre-multiplying
180		* this matrix by the given vector. Each value of the result is the dot
181		* product of the vector with one column of this matrix. The matrix and input
182		* vector are not modified.
183		*
184		* @param vect
185		*
186		* @return
187		*/
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
188	0	public float[] vectorMultiply(float[] vect)...
189		{
190	0	float[] result = new float[DIMS];
191
192	0	for (int i = 0; i < DIMS; i++)
193		{
194	0	result[i] = (matrix[i][0] * vect[0]) + (matrix[i][1] * vect[1])
195		+ (matrix[i][2] * vect[2]);
196		}
197
198	0	return result;
199		}
200
201		/**
202		* Performs pre-multiplication of this matrix by the given one. Value (i, j)
203		* of the result is the dot product of the i'th row of <code>mat</code> with
204		* the j'th column of this matrix.
205		*
206		* @param mat
207		*/
		0% Uncovered Elements: 9 (9) Complexity: 3 Complexity Density: 0.6
208	0	public void preMultiply(float[][] mat)...
209		{
210	0	float[][] tmp = new float[DIMS][DIMS];
211
212	0	for (int i = 0; i < DIMS; i++)
213		{
214	0	for (int j = 0; j < DIMS; j++)
215		{
216	0	tmp[i][j] = (mat[i][0] * matrix[0][j]) + (mat[i][1] * matrix[1][j])
217		+ (mat[i][2] * matrix[2][j]);
218		}
219		}
220
221	0	matrix = tmp;
222		}
223
224		/**
225		* Performs post-multiplication of this matrix by the given one. Value (i, j)
226		* of the result is the dot product of the i'th row of this matrix with the
227		* j'th column of <code>mat</code>.
228		*
229		* @param mat
230		*/
		0% Uncovered Elements: 9 (9) Complexity: 3 Complexity Density: 0.6
231	0	public void postMultiply(float[][] mat)...
232		{
233	0	float[][] tmp = new float[DIMS][DIMS];
234
235	0	for (int i = 0; i < DIMS; i++)
236		{
237	0	for (int j = 0; j < DIMS; j++)
238		{
239	0	tmp[i][j] = (matrix[i][0] * mat[0][j]) + (matrix[i][1] * mat[1][j])
240		+ (matrix[i][2] * mat[2][j]);
241		}
242		}
243
244	0	matrix = tmp;
245		}
246
247		/**
248		* Performs a vector multiplication whose result is the Point representing the
249		* input point's value vector post-multiplied by this matrix.
250		*
251		* @param coord
252		* @return
253		*/
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
254	0	public Point vectorMultiply(Point coord)...
255		{
256	0	float[] v = vectorMultiply(new float[] { coord.x, coord.y, coord.z });
257	0	return new Point(v[0], v[1], v[2]);
258		}
259		}