Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / M3.java
1 /*
2    Copyright (C) 1997,1998,1999
3    Kenji Hiranabe, Eiwa System Management, Inc.
4
5    This program is free software.
6    Implemented by Kenji Hiranabe(hiranabe@esm.co.jp),
7    conforming to the Java(TM) 3D API specification by Sun Microsystems.
8
9    Permission to use, copy, modify, distribute and sell this software
10    and its documentation for any purpose is hereby granted without fee,
11    provided that the above copyright notice appear in all copies and
12    that both that copyright notice and this permission notice appear
13    in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
14    makes no representations about the suitability of this software for any
15    purpose.  It is provided "AS IS" with NO WARRANTY.
16 */
17 package javajs.util;
18
19 import java.io.Serializable;
20
21
22
23 /**
24  * A single precision floating point 3 by 3 matrix.
25  * 
26  * @author Kenji hiranabe
27  * 
28  *         additions by Bob Hanson hansonr@stolaf.edu 9/30/2012 for unique
29  *         constructor and method names for the optimization of compiled
30  *         JavaScript using Java2Script
31  *         
32  *         
33  */
34 public class M3 extends M34 implements Serializable {
35
36   /**
37    * Constructs and initializes a Matrix3f to all zeros.
38    */
39   public M3() {
40   }
41
42   /**
43    * Constructs and initializes a Matrix3f from the specified 9 element array.
44    * this.m00 =v[0], this.m01=v[1], etc.
45    * 
46    * @param v
47    *        the array of length 9 containing in order
48    * @return m
49    */
50   public static M3 newA9(float[] v) {
51     M3 m = new M3();
52     m.setA(v);
53     return m;
54   }
55   
56   /**
57    * Constructs a new matrix with the same values as the Matrix3f parameter.
58    * 
59    * @param m1
60    *        The source matrix.
61    * @return m
62    */
63   public static M3 newM3(M3 m1) {
64     M3 m = new M3();
65     if (m1 == null) {
66       m.setScale(1);
67       return m;
68     }
69     m.m00 = m1.m00;
70     m.m01 = m1.m01;
71     m.m02 = m1.m02;
72
73     m.m10 = m1.m10;
74     m.m11 = m1.m11;
75     m.m12 = m1.m12;
76
77     m.m20 = m1.m20;
78     m.m21 = m1.m21;
79     m.m22 = m1.m22;
80     return m;
81   }
82
83   /**
84    * Sets this Matrix3f to a scalar * Identity.
85    * @param scale 
86    */
87   public void setScale(float scale) {
88     clear33();
89     m00 = m11 = m22 = scale;
90   }
91
92   /**
93    * Sets the value of this matrix to the double value of the Matrix3f argument.
94    * 
95    * @param m1
96    *        the matrix3f
97    */
98   public void setM3(M34 m1) {
99     setM33(m1);
100   }
101   /**
102    * Sets the values in this Matrix3f equal to the row-major array parameter
103    * (ie, the first four elements of the array will be copied into the first row
104    * of this matrix, etc.).
105    * 
106    * @param m
107    */
108   public void setA(float m[]) {
109     m00 = m[0];
110     m01 = m[1];
111     m02 = m[2];
112     m10 = m[3];
113     m11 = m[4];
114     m12 = m[5];
115     m20 = m[6];
116     m21 = m[7];
117     m22 = m[8];
118   }
119
120   /**
121    * Sets the specified element of this matrix3d to the value provided.
122    * 
123    * @param row
124    *        the row number to be modified (zero indexed)
125    * @param col
126    *        the column number to be modified (zero indexed)
127    * @param v
128    *        the new value
129    */
130   public void setElement(int row, int col, float v) {
131     set33(row, col, v);
132   }
133
134   /**
135    * Retrieves the value at the specified row and column of this matrix.
136    * 
137    * @param row
138    *        the row number to be retrieved (zero indexed)
139    * @param col
140    *        the column number to be retrieved (zero indexed)
141    * @return the value at the indexed element
142    */
143   public float getElement(int row, int col) {
144     return get33(row, col);
145   }
146
147   /**
148    * Sets the specified row of this matrix3d to the three values provided.
149    * 
150    * @param row
151    *        the row number to be modified (zero indexed)
152    * @param x
153    *        the first column element
154    * @param y
155    *        the second column element
156    * @param z
157    *        the third column element
158    */
159   public void setRow(int row, float x, float y, float z) {
160     switch (row) {
161     case 0:
162       m00 = x;
163       m01 = y;
164       m02 = z;
165       return;
166     case 1:
167       m10 = x;
168       m11 = y;
169       m12 = z;
170       return;
171     case 2:
172       m20 = x;
173       m21 = y;
174       m22 = z;
175       return;
176     default:
177       err();
178     }
179   }
180
181   /**
182    * Sets the specified row of this matrix3d to the Vector provided.
183    * 
184    * @param row
185    *        the row number to be modified (zero indexed)
186    * @param v
187    *        the replacement row
188    */
189   public void setRowV(int row, T3 v) {
190     switch (row) {
191     case 0:
192       m00 = v.x;
193       m01 = v.y;
194       m02 = v.z;
195       return;
196     case 1:
197       m10 = v.x;
198       m11 = v.y;
199       m12 = v.z;
200       return;
201     case 2:
202       m20 = v.x;
203       m21 = v.y;
204       m22 = v.z;
205       return;
206     default:
207       err();
208     }
209   }
210
211   /**
212    * Sets the specified row of this matrix3d to the four values provided.
213    * 
214    * @param row
215    *        the row number to be modified (zero indexed)
216    * @param v
217    *        the replacement row
218    */
219   public void setRowA(int row, float v[]) {
220     setRow33(row, v);
221   }
222
223   /**
224    * Copies the matrix values in the specified row into the array parameter.
225    * 
226    * @param row
227    *        the matrix row
228    * @param v
229    *        The array into which the matrix row values will be copied
230    */
231   @Override
232   public void getRow(int row, float v[]) {
233     getRow33(row, v);
234   }
235
236   /**
237    * Sets the specified column of this matrix3d to the three values provided.
238    * 
239    * @param column
240    *        the column number to be modified (zero indexed)
241    * @param x
242    *        the first row element
243    * @param y
244    *        the second row element
245    * @param z
246    *        the third row element
247    */
248   public void setColumn3(int column, float x, float y, float z) {
249     switch (column) {
250     case 0:
251       m00 = x;
252       m10 = y;
253       m20 = z;
254       break;
255     case 1:
256       m01 = x;
257       m11 = y;
258       m21 = z;
259       break;
260     case 2:
261       m02 = x;
262       m12 = y;
263       m22 = z;
264       break;
265     default:
266       err();
267     }
268   }
269
270   /**
271    * Sets the specified column of this matrix3d to the vector provided.
272    * 
273    * @param column
274    *        the column number to be modified (zero indexed)
275    * @param v
276    *        the replacement column
277    */
278   public void setColumnV(int column, T3 v) {
279     switch (column) {
280     case 0:
281       m00 = v.x;
282       m10 = v.y;
283       m20 = v.z;
284       break;
285     case 1:
286       m01 = v.x;
287       m11 = v.y;
288       m21 = v.z;
289       break;
290     case 2:
291       m02 = v.x;
292       m12 = v.y;
293       m22 = v.z;
294       break;
295     default:
296       err();
297     }
298   }
299
300   /**
301    * Copies the matrix values in the specified column into the vector parameter.
302    * 
303    * @param column
304    *        the matrix column
305    * @param v
306    *        The vector into which the matrix row values will be copied
307    */
308   public void getColumnV(int column, T3 v) {
309     switch (column) {
310     case 0:
311       v.x = m00;
312       v.y = m10;
313       v.z = m20;
314       break;
315     case 1:
316       v.x = m01;
317       v.y = m11;
318       v.z = m21;
319       break;
320     case 2:
321       v.x = m02;
322       v.y = m12;
323       v.z = m22;
324       break;
325     default:
326       err();
327     }
328   }
329
330   /**
331    * Sets the specified column of this matrix3d to the four values provided.
332    * 
333    * @param column
334    *        the column number to be modified (zero indexed)
335    * @param v
336    *        the replacement column
337    */
338   public void setColumnA(int column, float v[]) {
339     setColumn33(column, v);
340   }
341
342   /**
343    * Copies the matrix values in the specified column into the array parameter.
344    * 
345    * @param column
346    *        the matrix column
347    * @param v
348    *        The array into which the matrix row values will be copied
349    */
350   public void getColumn(int column, float v[]) {
351     getColumn33(column, v);
352   }
353
354   /**
355    * Sets the value of this matrix to sum of itself and matrix m1.
356    * 
357    * @param m1
358    *        the other matrix
359    */
360   public void add(M3 m1) {
361     add33(m1);
362   }
363
364   /**
365    * Sets the value of this matrix to the matrix difference of itself and matrix
366    * m1 (this = this - m1).
367    * 
368    * @param m1
369    *        the other matrix
370    */
371   public void sub(M3 m1) {
372     sub33(m1);
373   }
374
375   /**
376    * Sets the value of this matrix to its transpose.
377    */
378   public void transpose() {
379     transpose33();
380   }
381
382   /**
383    * Sets the value of this matrix to the transpose of the argument matrix
384    * 
385    * @param m1
386    *        the matrix to be transposed
387    */
388   public void transposeM(M3 m1) {
389     // alias-safe
390     setM33(m1);
391     transpose33();
392   }
393
394   /**
395    * Sets the value of this matrix to the matrix inverse of the passed matrix
396    * m1.
397    * 
398    * @param m1
399    *        the matrix to be inverted
400    */
401   public void invertM(M3 m1) {
402     setM33(m1);
403     invert();
404   }
405
406   /**
407    * Sets the value of this matrix to its inverse.
408    */
409   public void invert() {
410     double s = determinant3();
411     if (s == 0.0)
412       return;
413     s = 1 / s;
414     // alias-safe way.
415     set9(m11 * m22 - m12 * m21, m02 * m21 - m01 * m22, m01 * m12 - m02 * m11,
416         m12 * m20 - m10 * m22, m00 * m22 - m02 * m20, m02 * m10 - m00 * m12,
417         m10 * m21 - m11 * m20, m01 * m20 - m00 * m21, m00 * m11 - m01 * m10);
418     scale((float) s);
419   }
420
421   /**
422    * Sets the value of this matrix to a rotation matrix about the x axis by the
423    * passed angle.
424    * 
425    * @param angle
426    *        the angle to rotate about the X axis in radians
427    * @return this
428    */
429   public M3 setAsXRotation(float angle) {
430     setXRot(angle);
431     return this;
432   }
433   
434   /**
435    * Sets the value of this matrix to a rotation matrix about the y axis by the
436    * passed angle.
437    * 
438    * @param angle
439    *        the angle to rotate about the Y axis in radians
440    * @return this
441    */
442   public M3 setAsYRotation(float angle) {
443     setYRot(angle);
444     return this;
445   }
446
447   /**
448    * Sets the value of this matrix to a rotation matrix about the z axis by the
449    * passed angle.
450    * 
451    * @param angle
452    *        the angle to rotate about the Z axis in radians
453    * @return this
454    */
455   public M3 setAsZRotation(float angle) {
456     setZRot(angle);
457     return this;
458   }
459
460   /**
461    * Multiplies each element of this matrix by a scalar.
462    * 
463    * @param scalar
464    *        The scalar multiplier.
465    */
466   public void scale(float scalar) {
467     mul33(scalar);
468   }
469
470   /**
471    * Sets the value of this matrix to the result of multiplying itself with
472    * matrix m1.
473    * 
474    * @param m1
475    *        the other matrix
476    */
477   public void mul(M3 m1) {
478     mul2(this, m1);
479   }
480
481   /**
482    * Sets the value of this matrix to the result of multiplying the two argument
483    * matrices together.
484    * 
485    * @param m1
486    *        the first matrix
487    * @param m2
488    *        the second matrix
489    */
490   public void mul2(M3 m1, M3 m2) {
491     // alias-safe way.
492     set9(m1.m00 * m2.m00 + m1.m01 * m2.m10 + m1.m02 * m2.m20, m1.m00 * m2.m01
493         + m1.m01 * m2.m11 + m1.m02 * m2.m21, m1.m00 * m2.m02 + m1.m01 * m2.m12
494         + m1.m02 * m2.m22,
495
496     m1.m10 * m2.m00 + m1.m11 * m2.m10 + m1.m12 * m2.m20, m1.m10 * m2.m01
497         + m1.m11 * m2.m11 + m1.m12 * m2.m21, m1.m10 * m2.m02 + m1.m11 * m2.m12
498         + m1.m12 * m2.m22,
499
500     m1.m20 * m2.m00 + m1.m21 * m2.m10 + m1.m22 * m2.m20, m1.m20 * m2.m01
501         + m1.m21 * m2.m11 + m1.m22 * m2.m21, m1.m20 * m2.m02 + m1.m21 * m2.m12
502         + m1.m22 * m2.m22);
503   }
504
505   /**
506    * Returns true if the Object o is of type Matrix3f and all of the data
507    * members of t1 are equal to the corresponding data members in this Matrix3f.
508    * 
509    * @param o
510    *        the object with which the comparison is made.
511    */
512   @Override
513   public boolean equals(Object o) {
514     if (!(o instanceof M3))
515       return false;
516     M3 m = (M3) o;
517     return m00 == m.m00 && m01 == m.m01 && m02 == m.m02 && m10 == m.m10
518         && m11 == m.m11 && m12 == m.m12 && m20 == m.m20 && m21 == m.m21
519         && m22 == m.m22;
520   }
521
522   /**
523    * Returns a hash number based on the data values in this object. Two
524    * different Matrix3f objects with identical data values (ie, returns true for
525    * equals(Matrix3f) ) will return the same hash number. Two objects with
526    * different data members may return the same hash value, although this is not
527    * likely.
528    * 
529    * @return the integer hash value
530    */
531   @Override
532   public int hashCode() {
533     return T3.floatToIntBits(m00) ^ T3.floatToIntBits(m01)
534         ^ T3.floatToIntBits(m02) ^ T3.floatToIntBits(m10)
535         ^ T3.floatToIntBits(m11) ^ T3.floatToIntBits(m12)
536         ^ T3.floatToIntBits(m20) ^ T3.floatToIntBits(m21)
537         ^ T3.floatToIntBits(m22);
538   }
539
540   /**
541    * Sets this matrix to all zeros.
542    */
543   public void setZero() {
544     clear33();
545   }
546
547   /**
548    * Sets 9 values
549    * 
550    * @param m00
551    * @param m01
552    * @param m02
553    * @param m10
554    * @param m11
555    * @param m12
556    * @param m20
557    * @param m21
558    * @param m22
559    */
560   private void set9(float m00, float m01, float m02, float m10, float m11,
561                    float m12, float m20, float m21, float m22) {
562     this.m00 = m00;
563     this.m01 = m01;
564     this.m02 = m02;
565     this.m10 = m10;
566     this.m11 = m11;
567     this.m12 = m12;
568     this.m20 = m20;
569     this.m21 = m21;
570     this.m22 = m22;
571   }
572
573   /**
574    * Returns a string that contains the values of this Matrix3f.
575    * 
576    * @return the String representation
577    */
578   @Override
579   public String toString() {
580     return "[\n  [" + m00 + "\t" + m01 + "\t" + m02 + "]" + "\n  [" + m10
581         + "\t" + m11 + "\t" + m12 + "]" + "\n  [" + m20 + "\t" + m21 + "\t"
582         + m22 + "] ]";
583   }
584
585   /**
586    * Sets the value of this matrix to the matrix conversion of the single
587    * precision axis and angle argument.
588    * 
589    * @param a
590    *        the axis and angle to be converted
591    * @return this
592    */
593   public M3 setAA(A4 a) {
594     setAA33(a);
595     return this;
596   }
597
598   /**
599    * 3D ball rotation from dx dy in-plane mouse motion
600    * adapted from Andrew Hanson
601    * Computer Graphics beyond the Third Dimension:
602    * Geometry, Orientation Control, and Rendering for
603    * Graphics in Dimensions Greater than Three
604    * Course Notes for SIGGRAPH ’98
605    * http://www.cse.ohio-state.edu/~hwshen/888_su02/hanson_note.pdf
606    * 
607    * @param responseFactor Jmol uses 0.02 here
608    * @param dx
609    * @param dy
610    * @return true if successful; false if not;
611    */
612   public boolean setAsBallRotation(float responseFactor, float dx, float dy) {
613     float r = (float) Math.sqrt(dx * dx + dy * dy);
614     float th =  r * responseFactor;
615     if (th == 0) {
616       setScale(1);
617       return false;
618     }
619     float c = (float) Math.cos(th);
620     float s = (float) Math.sin(th);
621     float nx = -dy / r;
622     float ny = dx / r;
623     float c1 = c - 1;
624     m00 = 1 + c1 * nx * nx;
625     m01 = m10 = c1 * nx * ny;
626     m20 = -(m02 = s * nx);
627     m11 = 1 + c1 * ny * ny;
628     m21 = -(m12 = s * ny);
629     m22 = c;
630     return true;
631   }
632
633   public boolean isRotation() {
634     return (Math.abs(determinant3() - 1) < 0.001f);
635   }
636
637 }