Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / M34.java
1 package javajs.util;
2
3 /**
4  * A base class for both M3 and M4 to conserve code size.
5  * 
6  * @author Kenji hiranabe
7  * 
8  *         additions by Bob Hanson hansonr@stolaf.edu 9/30/2012 for unique
9  *         constructor and method names for the optimization of compiled
10  *         JavaScript using Java2Script and for subclassing to M3 and M4
11  * 
12  */
13 public abstract class M34 {
14
15   /**
16    * The first element of the first row
17    */
18   public float m00;
19
20   /**
21    * The second element of the first row.
22    */
23   public float m01;
24
25   /**
26    * third element of the first row.
27    */
28   public float m02;
29
30   /**
31    * The first element of the second row.
32    */
33   public float m10;
34
35   /**
36    * The second element of the second row.
37    */
38   public float m11;
39
40   /**
41    * The third element of the second row.
42    */
43   public float m12;
44
45   /**
46    * The first element of the third row.
47    */
48   public float m20;
49
50   /**
51    * The second element of the third row.
52    */
53   public float m21;
54
55   /**
56    * The third element of the third row.
57    */
58   public float m22;
59
60   protected void setAA33(A4 a) {
61     double x = a.x;
62     double y = a.y;
63     double z = a.z;
64     double angle = a.angle;
65     // Taken from Rick's which is taken from Wertz. pg. 412
66     // Bug Fixed and changed into right-handed by hiranabe
67     double n = Math.sqrt(x * x + y * y + z * z);
68     // zero-div may occur
69     n = 1 / n;
70     x *= n;
71     y *= n;
72     z *= n;
73     double c = Math.cos(angle);
74     double s = Math.sin(angle);
75     double omc = 1.0 - c;
76     m00 = (float) (c + x * x * omc);
77     m11 = (float) (c + y * y * omc);
78     m22 = (float) (c + z * z * omc);
79
80     double tmp1 = x * y * omc;
81     double tmp2 = z * s;
82     m01 = (float) (tmp1 - tmp2);
83     m10 = (float) (tmp1 + tmp2);
84
85     tmp1 = x * z * omc;
86     tmp2 = y * s;
87     m02 = (float) (tmp1 + tmp2);
88     m20 = (float) (tmp1 - tmp2);
89
90     tmp1 = y * z * omc;
91     tmp2 = x * s;
92     m12 = (float) (tmp1 - tmp2);
93     m21 = (float) (tmp1 + tmp2);
94   }
95
96   public void rotate(T3 t) {
97     // alias-safe
98     rotate2(t, t);
99   }
100
101   /**
102    * Transform the vector vec using this Matrix3f and place the result into
103    * vecOut.
104    * 
105    * @param t
106    *        the single precision vector to be transformed
107    * @param result
108    *        the vector into which the transformed values are placed
109    */
110   public void rotate2(T3 t, T3 result) {
111     // alias-safe
112     result.set(m00 * t.x + m01 * t.y + m02 * t.z, m10 * t.x + m11 * t.y + m12
113         * t.z, m20 * t.x + m21 * t.y + m22 * t.z);
114   }
115
116
117   /**
118    * Sets the value of this matrix to the double value of the Matrix3f argument.
119    * 
120    * @param m1
121    *        the matrix3f
122    */
123   protected void setM33(M34 m1) {
124     m00 = m1.m00;
125     m01 = m1.m01;
126     m02 = m1.m02;
127     m10 = m1.m10;
128     m11 = m1.m11;
129     m12 = m1.m12;
130     m20 = m1.m20;
131     m21 = m1.m21;
132     m22 = m1.m22;
133   }
134
135   protected void clear33() {
136     m00 = m01 = m02 = m10 = m11 = m12 = m20 = m21 = m22 = 0.0f;
137   }
138
139   protected void set33(int row, int col, float v) {
140     switch (row) {
141     case 0:
142       switch (col) {
143       case 0:
144         m00 = v;
145         return;
146       case 1:
147         m01 = v;
148         return;
149       case 2: 
150         m02 = v;
151         return;
152       }
153       break;
154     case 1:
155       switch (col) {
156       case 0:
157         m10 = v;
158         return;
159       case 1:
160         m11 = v;
161         return;
162       case 2: 
163         m12 = v;
164         return;
165       }
166       break;
167     case 2: 
168       switch (col) {
169       case 0:
170         m20 = v;
171         return;
172       case 1:
173         m21 = v;
174         return;
175       case 2: 
176         m22 = v;
177         return;
178       }
179       break;
180     }
181     err();
182   }
183
184   protected float get33(int row, int col) {
185     switch (row) {
186     case 0:
187       switch (col) {
188       case 0:
189         return m00;
190       case 1:
191         return m01;
192       case 2:
193         return m02;
194       }
195       break;
196     case 1:
197       switch (col) {
198       case 0:
199         return m10;
200       case 1:
201         return m11;
202       case 2:
203         return m12;
204       }
205       break;
206     case 2:
207       switch (col) {
208       case 0:
209         return m20;
210       case 1:
211         return m21;
212       case 2:
213         return m22;
214       }
215       break;
216     }
217     err();
218     return 0;
219   }
220
221   protected void setRow33(int row, float v[]) {
222     switch (row) {
223     case 0:
224       m00 = v[0];
225       m01 = v[1];
226       m02 = v[2];
227       return;
228     case 1:
229       m10 = v[0];
230       m11 = v[1];
231       m12 = v[2];
232       return;
233     case 2:
234       m20 = v[0];
235       m21 = v[1];
236       m22 = v[2];
237       return;
238     default:
239       err();
240     }
241   }
242   
243   public abstract void getRow(int row, float v[]);
244
245   protected void getRow33(int row, float v[]) {
246     switch (row) {
247     case 0:
248       v[0] = m00;
249       v[1] = m01;
250       v[2] = m02;
251       return;
252     case 1:
253       v[0] = m10;
254       v[1] = m11;
255       v[2] = m12;
256       return;
257     case 2:
258       v[0] = m20;
259       v[1] = m21;
260       v[2] = m22;
261       return;
262     }
263     err();
264   }
265
266   protected void setColumn33(int column, float v[]) {
267     switch(column) {
268     case 0:
269       m00 = v[0];
270       m10 = v[1];
271       m20 = v[2];
272       break;
273     case 1:
274       m01 = v[0];
275       m11 = v[1];
276       m21 = v[2];
277       break;
278     case 2:
279       m02 = v[0];
280       m12 = v[1];
281       m22 = v[2];
282       break;
283      default:
284       err();
285     }
286   }
287
288   protected void getColumn33(int column, float v[]) {
289     switch(column) {
290     case 0:
291       v[0] = m00;
292       v[1] = m10;
293       v[2] = m20;
294       break;
295     case 1:
296       v[0] = m01;
297       v[1] = m11;
298       v[2] = m21;
299       break;
300     case 2:
301       v[0] = m02;
302       v[1] = m12;
303       v[2] = m22;
304       break;
305     default:
306       err();
307     }
308   }
309
310   protected void add33(M34 m1) {
311     m00 += m1.m00;
312     m01 += m1.m01;
313     m02 += m1.m02;
314     m10 += m1.m10;
315     m11 += m1.m11;
316     m12 += m1.m12;
317     m20 += m1.m20;
318     m21 += m1.m21;
319     m22 += m1.m22;
320   }
321
322   protected void sub33(M34 m1) {
323     m00 -= m1.m00;
324     m01 -= m1.m01;
325     m02 -= m1.m02;
326     m10 -= m1.m10;
327     m11 -= m1.m11;
328     m12 -= m1.m12;
329     m20 -= m1.m20;
330     m21 -= m1.m21;
331     m22 -= m1.m22;
332   }
333
334   protected void mul33(float x) {
335     m00 *= x;
336     m01 *= x;
337     m02 *= x;
338     m10 *= x;
339     m11 *= x;
340     m12 *= x;
341     m20 *= x;
342     m21 *= x;
343     m22 *= x;
344   }
345
346   protected void transpose33() {
347     float tmp = m01;
348     m01 = m10;
349     m10 = tmp;
350
351     tmp = m02;
352     m02 = m20;
353     m20 = tmp;
354
355     tmp = m12;
356     m12 = m21;
357     m21 = tmp;
358   }
359
360   protected void setXRot(float angle) {
361     double c = Math.cos(angle);
362     double s = Math.sin(angle);
363     m00 = 1.0f;
364     m01 = 0.0f;
365     m02 = 0.0f;
366     m10 = 0.0f;
367     m11 = (float) c;
368     m12 = (float) -s;
369     m20 = 0.0f;
370     m21 = (float) s;
371     m22 = (float) c;
372   }
373
374   protected void setYRot(float angle) {
375     double c = Math.cos(angle);
376     double s = Math.sin(angle);
377     m00 = (float) c;
378     m01 = 0.0f;
379     m02 = (float) s;
380     m10 = 0.0f;
381     m11 = 1.0f;
382     m12 = 0.0f;
383     m20 = (float) -s;
384     m21 = 0.0f;
385     m22 = (float) c;
386   }
387   
388   protected void setZRot(float angle) {
389     double c = Math.cos(angle);
390     double s = Math.sin(angle);
391     m00 = (float) c;
392     m01 = (float) -s;
393     m02 = 0.0f;
394     m10 = (float) s;
395     m11 = (float) c;
396     m12 = 0.0f;
397     m20 = 0.0f;
398     m21 = 0.0f;
399     m22 = 1.0f;
400   }
401   
402   /**
403    * @return 3x3 determinant
404    */
405   public float determinant3() {
406     return m00 * (m11 * m22 - m21 * m12) - m01 * (m10 * m22 - m20 * m12) + m02
407         * (m10 * m21 - m20 * m11);
408   }
409   
410   protected void err() {
411     throw new ArrayIndexOutOfBoundsException(
412         "matrix column/row out of bounds");
413   }
414
415
416 }