Maths - Matrix Code - Java

related classes

/*Title:      mjbWorld
Copyright (c) 1998-2007 Martin John BakerThis program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.For information about the GNU General Public License see http://www.gnu.org/To discuss this program http://sourceforge.net/forum/forum.php?forum_id=122133
   also see website https://www.euclideanspace.com/
   */package mjbModel;
   import java.lang.ref.*;
   import java.util.*; // for StringTokenizer/** a class to hold a 4x4 matrix and to allow various transforms on it. */
   public class sftransform extends property {/** element 0,0 of matrix */
   public double m00;
   /** element 0,1 of matrix */
   public double m01;
   /** element 0,2 of matrix */
   public double m02;
   /** element 0,3 of matrix */
   public double m03;
   /** element 1,0 of matrix */
   public double m10;
   /**element 1,1 of matrix */
   public double m11;
   /** element 1,2 of matrix */
   public double m12;
   /** element 1,3 of matrix */
   public double m13;
   /** element 2,0 of matrix */
   public double m20;
   /** element 2,1 of matrix */
   public double m21;
   /** element 2,2 of matrix */
   public double m22;
   /** element 2,3 of matrix */
   public double m23;
   /** element 3,0 of matrix */
   public double m30;
   /** element 3,1 of matrix */
   public double m31;
   /** element 3,2 of matrix */
   public double m32;
   /** element 3,3 of matrix */
   public double m33;/** constructor for initialy zero matrix */
   public sftransform() {
   m00 = 0.0;
   m01 = 0.0;
   m02 = 0.0;
   m03 = 0.0;
   m10 = 0.0;
   m11 = 0.0;
   m12 = 0.0;
   m13 = 0.0;
   m20 = 0.0;
   m21 = 0.0;
   m22 = 0.0;
   m23 = 0.0;
   m30 = 0.0;
   m31 = 0.0;
   m32 = 0.0;
   m33 = 0.0;
   }/** copy constructor
   * @param a class to copy
   * */
   public sftransform(sftransform a) {
   m00 = a.m00;
   m01 = a.m01;
   m02 = a.m02;
   m03 = a.m03;
   m10 = a.m10;
   m11 = a.m11;
   m12 = a.m12;
   m13 = a.m13;
   m20 = a.m20;
   m21 = a.m21;
   m22 = a.m22;
   m23 = a.m23;
   m30 = a.m30;
   m31 = a.m31;
   m32 = a.m32;
   m33 = a.m33;
   }/** constructor set to value of a times b
   * @param a first matrix
   * @param b second matrix
   */
   public sftransform(sftransform a,sftransform b) {
   combine(a,b);
   }/** a static class to return the VRML name of this property
   * @return the VRML name of this property
   */
   public static String vrmlType_s(){
   return "SFTransform";
   }/** gets the VRML name of this property, we need a non static class so that    it can be overriden
   * @return the VRML name of this property
   */
   public String vrmlType(){
   return "SFTransform";
   }/** returns the type of a class which can edit this transform
   * @return type of a class which can edit this transform
   */
   static public Class getEditClass(){
   return sftransformEditor.class;
   }/** sets this transform to the identity matrix, multiplying by the
   * identity matrix does not alter the other matrix.
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * */
   public void setIdentity(){
   m00 = 1.0;
   m01 = 0.0;
   m02 = 0.0;
   m03 = 0.0;
   m10 = 0.0;
   m11 = 1.0;
   m12 = 0.0;
   m13 = 0.0;
   m20 = 0.0;
   m21 = 0.0;
   m22 = 1.0;
   m23 = 0.0;
   m30 = 0.0;
   m31 = 0.0;
   m32 = 0.0;
   m33 = 1.0;
   }/** overrides the clone method for this class
   * @return new instance with same values as this
   */
   public Object clone() {
   return new sftransform(this);
   }/** sets the value of this transform to a copy of the transform supplied to    it
   * @param input instance to copy
   * */
   public void copy(sftransform input){
   m00 = input.m00;
   m01 = input.m01;
   m02 = input.m02;
   m03 = input.m03;
   m10 = input.m10;
   m11 = input.m11;
   m12 = input.m12;
   m13 = input.m13;
   m20 = input.m20;
   m21 = input.m21;
   m22 = input.m22;
   m23 = input.m23;
   m30 = input.m30;
   m31 = input.m31;
   m32 = input.m32;
   m33 = input.m33;
   }/** create an array of the appropriate type
   * with a size given by the parameter
   * @param size size of array
   * @return the array of transforms created
   */
   public property[] createArray(int size){
   return new sftransform[size];
   }/** create an array of doubles with the values of this matrix
   *
   */
   public double[] toArray(){
   double[] matrix = new double[16];
   matrix[0] = m00;
   matrix[1] = m01;
   matrix[2] = m02;
   matrix[3] = m03;
   matrix[4] = m10;
   matrix[5] = m11;
   matrix[6] = m12;
   matrix[7] = m13;
   matrix[8] = m20;
   matrix[9] = m21;
   matrix[10] = m22;
   matrix[11] = m23;
   matrix[12] = m30;
   matrix[13] = m31;
   matrix[14] = m32;
   matrix[15] = m33;
   return matrix;
   }/** sets this transform to the value calculated form a VRML tranform parameter
   * which are: translation,rotation,center,sc and scaleOrientation
   * for theory see:
   * https://www.euclideanspace.com/maths/geometry/rotations/rotationAndTranslation/nonMatrix/index.htm
   * @param translation inier offset
   * @param rotation rotation
   * @param center centre of rotation
   * @param sc scale factor in x,y and z dimensions
   * @param scaleOrientation orientation of scale factor
   */
   public void calcTransform(sfvec3f translation,
   sfrotation rotation,
   sfvec3f center,
   sfvec3f sc,
   sfrotation scaleOrientation){
   setIdentity();
   if (translation!=null) translate(translation);
   if (rotation!=null) rotate(rotation,center);
   if (scaleOrientation!=null) rotate(scaleOrientation,center);
   if (sc!=null) { // if scale is (0,0,0), such as when scale first
   // enabled this will generate a non-afine error
   // so do following check
   if ((sc.x != 0) & (sc.y != 0) & (sc.z != 0))
   scale(sc);
   }
   if (scaleOrientation!=null) rotate(scaleOrientation.getMinus(),center);
   }/** multiply this matrix with the matrix supplied (m1)
   ** for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * @param m1 matrix to multiply by
   * */
   public void combine(sftransform m1) {
   sftransform tmp = new sftransform(this);
   combine(tmp,m1);
   }/** multiply the matrix supplied (m1) with this matrix. This is different
   * from the combine because the order of multipication is significant
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * @param m1 matrix which we multiply this by
   * */
   public void combineInverse(sftransform m1) {
   sftransform tmp = new sftransform(this);
   combine(m1,tmp);
   }/** sets the value of this to m1 * m2
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * @param m1 martix 1
   * @param m2 matrix 2
   * */
   public void combine(sftransform m1,sftransform m2) {
   m00 = m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20 + m1.m03*m2.m30;
   m01 = m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21 + m1.m03*m2.m31;
   m02 = m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22 + m1.m03*m2.m32;
   m03 = m1.m00*m2.m03 + m1.m01*m2.m13 + m1.m02*m2.m23 + m1.m03*m2.m33; m10 = m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20 + m1.m13*m2.m30;
   m11 = m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21 + m1.m13*m2.m31;
   m12 = m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22 + m1.m13*m2.m32;
   m13 = m1.m10*m2.m03 + m1.m11*m2.m13 + m1.m12*m2.m23 + m1.m13*m2.m33; m20 = m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20 + m1.m23*m2.m30;
   m21 = m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21 + m1.m23*m2.m31;
   m22 = m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22 + m1.m23*m2.m32;
   m23 = m1.m20*m2.m03 + m1.m21*m2.m13 + m1.m22*m2.m23 + m1.m23*m2.m33; m30 = m1.m30*m2.m00 + m1.m31*m2.m10 + m1.m32*m2.m20 + m1.m33*m2.m30;
   m31 = m1.m30*m2.m01 + m1.m31*m2.m11 + m1.m32*m2.m21 + m1.m33*m2.m31;
   m32 = m1.m30*m2.m02 + m1.m31*m2.m12 + m1.m32*m2.m22 + m1.m33*m2.m32;
   m33 = m1.m30*m2.m03 + m1.m31*m2.m13 + m1.m32*m2.m23 + m1.m33*m2.m33;
   }/** transform the vector supplied using this transform
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/transforms/index.htm
   * @param v vector to be transformed
   * */
   public void transform(sfvec3f v){
   if (v==null) {
   System.out.println("sftransform.transform v==null");
   return;
   }
   sfvec3f temp = new sfvec3f(v);
   v.x = m00 * temp.x + m01 * temp.y + m02 * temp.z + m03;
   v.y = m10 * temp.x + m11 * temp.y + m12 * temp.z + m13;
   v.z = m20 * temp.x + m21 * temp.y + m22 * temp.z + m23;
   }/** linear translation, ie add the vector supplied to the translation part    of this matrix
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/transforms/index.htm
   * @param v ammount of translation
   * */
   public void translate(sfvec3f v){
   if (v==null) {
   System.out.println("sftransform.translate v==null");
   return;
   }
   m03 += v.x;
   m13 += v.y;
   m23 += v.z;
   m33 = 1.0;
   }/** scale this transform,
   * for theory see:
   * https://www.euclideanspace.com/maths/geometry/rotations/rotationAndTranslation/nonMatrix/index.htm
   * @param v scale factor in x,y and z dimensions
   */
   public void scale(sfvec3f v){
   m00 *= v.x;
   m01 *= v.x;
   m02 *= v.x;
   m10 *= v.y;
   m11 *= v.y;
   m12 *= v.y;
   m20 *= v.z;
   m21 *= v.z;
   m22 *= v.z;
   m33 = 1.0;
   }/** scale equally in all dimensions
   * https://www.euclideanspace.com/maths/geometry/rotations/rotationAndTranslation/nonMatrix/index.htm
   * @param scale the scale factor for the matrix
   * */
   public void scale(double scale) {
   m00 *= scale;
   m01 *= scale;
   m02 *= scale;
   m03 *= scale;
   m10 *= scale;
   m11 *= scale;
   m12 *= scale;
   m13 *= scale;
   m20 *= scale;
   m21 *= scale;
   m22 *= scale;
   m23 *= scale;
   m30 *= scale;
   m31 *= scale;
   m32 *= scale;
   m33 *= scale;
   }/** set this translation to rotate around a point
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/orthogonal/rotation/index.htm
   * @param rot ammount of rotation
   * @param centre centre of rotation
   * */
   public void rotate(sfrotation rot,sfvec3f centre) {
   sftransform t1 = new sftransform(this);
   sftransform t2 = new sftransform();
   t2.setRotate(rot,centre);
   combine(t1,t2);
   }/** rotate around a point
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/orthogonal/rotation/index.htm
   * @param rot
   * @param centre
   * */
   public void setRotate(sfrotation rot,sfvec3f centre) {
   if (rot.coding == sfrotation.CODING_AXISANGLE |
   rot.coding == sfrotation.CODING_AXISANGLE_SAVEASQUAT) {
   double c = Math.cos(rot.angle);
   double s = Math.sin(rot.angle);
   double t = 1.0 - c;
   m00 = c + rot.x*rot.x*t;
   m11 = c + rot.y*rot.y*t;
   m22 = c + rot.z*rot.z*t; double tmp1 = rot.x*rot.y*t;
   double tmp2 = rot.z*s;
   m10 = tmp1 + tmp2;
   m01 = tmp1 - tmp2;
   tmp1 = rot.x*rot.z*t;
   tmp2 = rot.y*s;
   m20 = tmp1 - tmp2;
   m02 = tmp1 + tmp2; tmp1 = rot.y*rot.z*t;
   tmp2 = rot.x*s;
   m21 = tmp1 + tmp2;
   m12 = tmp1 - tmp2;
   } else {
   double sqw = rot.angle*rot.angle;
   double sqx = rot.x*rot.x;
   double sqy = rot.y*rot.y;
   double sqz = rot.z*rot.z;
   m00 = sqx - sqy - sqz + sqw; // since sqw + sqx + sqy + sqz =1
   m11 = -sqx + sqy - sqz + sqw;
   m22 = -sqx - sqy + sqz + sqw; double tmp1 = rot.x*rot.y;
   double tmp2 = rot.z*rot.angle;
   m10 = 2.0 * (tmp1 + tmp2);
   m01 = 2.0 * (tmp1 - tmp2); tmp1 = rot.x*rot.z;
   tmp2 = rot.y*rot.angle;
   m20 = 2.0 * (tmp1 - tmp2);
   m02 = 2.0 * (tmp1 + tmp2);
   tmp1 = rot.y*rot.z;
   tmp2 = rot.x*rot.angle;
   m21 = 2.0 * (tmp1 + tmp2);
   m12 = 2.0 * (tmp1 - tmp2);
   }
   double a1,a2,a3;
   if (centre == null) {
   a1=a2=a3=0;
   } else {
   a1 = centre.x; a2 = centre.y; a3 = centre.z;
   } m03 = a1 - a1 * m00 - a2 * m01 - a3 * m02;
   m13 = a2 - a1 * m10 - a2 * m11 - a3 * m12;
   m23 = a3 - a1 * m20 - a2 * m21 - a3 * m22;
   m30 = m31 = m32 = 0.0;
   m33 = 1.0;
   }/** rotate about a point, rotation given by euler angles
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/orthogonal/rotation/index.htm
   * @param centre">point to rotate around
   * @param theta">angle in radians
   * @param phi">angle in radians
   * @param alpha">angle in radians
   */
   public void setRotate(sfvec3f centre, double theta,double phi,double alpha)    {
   double cosAlpha, sinAlpha, cosPhi, sinPhi,
   cosTheta, sinTheta, cosPhi2, sinPhi2,
   cosTheta2, sinTheta2, c, a1,a2,a3;
   if (centre==null) {
   a1=a2=a3=0;
   } else {
   a1 = centre.x;
   a2 = centre.y;
   a3 = centre.z;
   }
   cosPhi = Math.cos(phi); sinPhi = Math.sin(phi);
   cosPhi2 = cosPhi * cosPhi; sinPhi2 = sinPhi * sinPhi;
   cosTheta = Math.cos(theta);
   sinTheta = Math.sin(theta);
   cosTheta2 = cosTheta * cosTheta;
   sinTheta2 = sinTheta * sinTheta;
   cosAlpha = Math.cos(alpha);
   sinAlpha = Math.sin(alpha);
   c = 1.0 - cosAlpha;
   m00 = cosTheta2 * (cosAlpha * cosPhi2 + sinPhi2)
   + cosAlpha * sinTheta2;
   m10 = sinAlpha * cosPhi + c * sinPhi2 * cosTheta * sinTheta;
   m20 = sinPhi * (cosPhi * cosTheta * c - sinAlpha * sinTheta);
   m30 = 0.0; m01 = sinPhi2 * cosTheta * sinTheta * c - sinAlpha * cosPhi;
   m11 = sinTheta2 * (cosAlpha * cosPhi2 + sinPhi2)
   + cosAlpha * cosTheta2;
   m21 = sinPhi * (cosPhi * sinTheta * c + sinAlpha * cosTheta);
   m31 = 0.0; m02 = sinPhi * (cosPhi * cosTheta * c + sinAlpha * sinTheta);
   m12 = sinPhi * (cosPhi * sinTheta * c - sinAlpha * cosTheta);
   m22 = cosAlpha * sinPhi2 + cosPhi2;
   m32 = 0.0; m03 = a1 - a1 * m00 - a2 * m01 - a3 * m02;
   m13 = a2 - a1 * m10 - a2 * m11 - a3 * m12;
   m23 = a3 - a1 * m20 - a2 * m21 - a3 * m22;
   m33 = 1.0;
   }/** format values into a string with square brackets
   * @return a string representation of this class
   * */
   public String toString(){
   String s1="["+m00+","+m01+","+m02+","+m03+"]";
   String s2="["+m10+","+m11+","+m12+","+m13+"]";
   String s3="["+m20+","+m21+","+m22+","+m23+"]";
   String s4="["+m30+","+m31+","+m32+","+m33+"]";
   return ""+s1+"\n"+s2+"\n"+s3+"\n"+s4;
   }/** output as a string
   * @param mode possible values:
   * 0 - output modified values
   * 1 - output original values
   * 2 - output attribute
   * 3 - output attribute in brackets
   * 4 - output with f prefix
   * @return a string representation of this class
   */
   public String outstring(int i) {
   return "\n"+m00+","+m01+","+m02+","+m03+"\n"+
   m10+","+m11+","+m12+","+m13+"\n"+
   m20+","+m21+","+m22+","+m23+"\n"+
   m30+","+m31+","+m32+","+m33;
   }/** find inverse matrix
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * */
   public void invert() {
   double det = determinant();
   double t00 = m12*m23*m31 - m13*m22*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33    + m11*m22*m33;
   double t01 = m03*m22*m31 - m02*m23*m31 - m03*m21*m32 + m01*m23*m32 + m02*m21*m33    - m01*m22*m33;
   double t02 = m02*m13*m31 - m03*m12*m31 + m03*m11*m32 - m01*m13*m32 - m02*m11*m33    + m01*m12*m33;
   double t03 = m03*m12*m21 - m02*m13*m21 - m03*m11*m22 + m01*m13*m22 + m02*m11*m23    - m01*m12*m23;
   double t10 = m13*m22*m30 - m12*m23*m30 - m13*m20*m32 + m10*m23*m32 + m12*m20*m33    - m10*m22*m33;
   double t11 = m02*m23*m30 - m03*m22*m30 + m03*m20*m32 - m00*m23*m32 - m02*m20*m33    + m00*m22*m33;
   double t12 = m03*m12*m30 - m02*m13*m30 - m03*m10*m32 + m00*m13*m32 + m02*m10*m33    - m00*m12*m33;
   double t13 = m02*m13*m20 - m03*m12*m20 + m03*m10*m22 - m00*m13*m22 - m02*m10*m23    + m00*m12*m23;
   double t20 = m11*m23*m30 - m13*m21*m30 + m13*m20*m31 - m10*m23*m31 - m11*m20*m33    + m10*m21*m33;
   double t21 = m03*m21*m30 - m01*m23*m30 - m03*m20*m31 + m00*m23*m31 + m01*m20*m33    - m00*m21*m33;
   double t22 = m01*m13*m30 - m03*m11*m30 + m03*m10*m31 - m00*m13*m31 - m01*m10*m33    + m00*m11*m33;
   double t23 = m03*m11*m20 - m01*m13*m20 - m03*m10*m21 + m00*m13*m21 + m01*m10*m23    - m00*m11*m23;
   double t30 = m12*m21*m30 - m11*m22*m30 - m12*m20*m31 + m10*m22*m31 + m11*m20*m32    - m10*m21*m32;
   double t31 = m01*m22*m30 - m02*m21*m30 + m02*m20*m31 - m00*m22*m31 - m01*m20*m32    + m00*m21*m32;
   double t32 = m02*m11*m30 - m01*m12*m30 - m02*m10*m31 + m00*m12*m31 + m01*m10*m32    - m00*m11*m32;
   double t33 = m01*m12*m20 - m02*m11*m20 + m02*m10*m21 - m00*m12*m21 - m01*m10*m22    + m00*m11*m22;
   m00 = t00;
   m01 = t01;
   m02 = t02;
   m03 = t03;
   m10 = t10;
   m11 = t11;
   m12 = t12;
   m13 = t13;
   m20 = t20;
   m21 = t21;
   m22 = t22;
   m23 = t23;
   m30 = t30;
   m31 = t31;
   m32 = t32;
   m33 = t33;
   scale(1/det);
   }/** for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   */
   public void invertAffine() {
   double d = determinantAffine();
   if (d != 0.0) {
   double t00 = (m11*m22 - m12*m21) / d;
   double t01 = (m02*m21 - m01*m22) / d;
   double t02 = (m01*m12 - m02*m11) / d;
   double t10 = (m12*m20 - m10*m22) / d;
   double t11 = (m00*m22 - m02*m20) / d;
   double t12 = (m02*m10 - m00*m12) / d;
   double t20 = (m10*m21 - m11*m20) / d;
   double t21 = (m01*m20 - m00*m21) / d;
   double t22 = (m00*m11 - m01*m10) / d;
   m00 = t00;
   m01 = t01;
   m02 = t02;
   m10 = t10;
   m11 = t11;
   m12 = t12;
   m20 = t20;
   m21 = t21;
   m22 = t22;
   }
   m03 *= -1.0;
   m13 *= -1.0;
   m23 *= -1.0;
   }/** Calculates the determinant of this matrix
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * @return the determinant of the matrix
   * */
   public double determinant() {
   double value;
   value =
   m03 * m12 * m21 * m30-m02 * m13 * m21 * m30-m03 * m11 * m22 * m30+m01 * m13    * m22 * m30+
   m02 * m11 * m23 * m30-m01 * m12 * m23 * m30-m03 * m12 * m20 * m31+m02 * m13    * m20 * m31+
   m03 * m10 * m22 * m31-m00 * m13 * m22 * m31-m02 * m10 * m23 * m31+m00 * m12    * m23 * m31+
   m03 * m11 * m20 * m32-m01 * m13 * m20 * m32-m03 * m10 * m21 * m32+m00 * m13    * m21 * m32+
   m01 * m10 * m23 * m32-m00 * m11 * m23 * m32-m02 * m11 * m20 * m33+m01 * m12    * m20 * m33+
   m02 * m10 * m21 * m33-m00 * m12 * m21 * m33-m01 * m10 * m22 * m33+m00 * m11    * m22 * m33;
   return value;
   }/** calculates the transpose
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * */
   public void transpose() {
   double tmp = m01;
   m01 = m10;
   m10 = tmp; tmp = m02;
   m02 = m20;
   m20 = tmp; tmp = m03;
   m03 = m30;
   m30 = tmp; tmp = m12;
   m12 = m21;
   m21 = tmp; tmp = m13;
   m13 = m31;
   m31 = tmp; tmp = m23;
   m23 = m32;
   m32 = tmp;
   }/** calculates the affine determinant of this matrix.
   * for theory see:
   * https://www.euclideanspace.com/maths/algebra/matrix/arithmetic/index.htm
   * @return the determinant of the matrix
   * */
   public double determinantAffine() {
   double value;
   value = m00 * ( m11 * m22 - m21 * m12 );
   value -= m01 * ( m10 * m22 - m20 * m12 );
   value += m02 * ( m10 * m21 - m20 * m11 );
   return value;
   }/** generate java code to file
   * @param f
   * @param mode
   * @param maxInstances
   * */
   public void writeJava(filter f,int mode,int maxInstances){
   try {
   if (mode != 0) return; // no procedure defn required
   f.status(getClass().getName());
   f.writeln("// code for "+getClass().getName(),0);
   f.writeln("Transform3D t3d = new Transform3D();",2);
   f.writeln("Matrix4d m = new Matrix4d();",2);
   f.writeln("double []d = {",2);
   f.writeln(""+m00+","+m01+","+m02+","+m03+",",2);
   f.writeln(""+m10+","+m11+","+m12+","+m13+",",2);
   f.writeln(""+m20+","+m21+","+m22+","+m23+",",2);
   f.writeln(""+m30+","+m31+","+m32+","+m33+",",2);
   f.writeln("};",2);
   f.writeln("m.set(d);",2);
   f.writeln("t3d.set(m);",2);
   } catch (Exception e) {
   System.out.println("sftransform.writeJava " + e.toString());
   }
   return;
   }/** write in VRML mode (except that SFTransform does not exist in VRML)
   * @param f file parameters and methods
   * @param mode mode values
   /// 0 - output VRML97 modified values
   /// 1 - output VRML97 original values
   /// 2 - output xml (x3d)
   /// 3 - output attribute in brackets
   /// 4 - output with f prefix</param>
   * @param indent
   */
   public void write(filter f,int mode,int indent){
   f.write(outstring(mode));
   }/** read in VRML mode (except that SFTransform does not exist in VRML)
   * used by mfparam.vrml2par
   * @param f">file parameters and methods</param>
   * @param sfp"></param>
   * @param n"></param>
   * @param mode"></param>
   * @return
   */
   public boolean instring(filter f,sfparam sfp,nodeBean n,int mode) {
   return false;
   }
}