src/jalview/math/RotatableMatrix.java

   1 /*
   2 * Jalview - A Sequence Alignment Editor and Viewer
   3 * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License
   7 * as published by the Free Software Foundation; either version 2
   8 * of the License, or (at your option) any later version.
   9 *
  10 * This program is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write to the Free Software
  17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 */
  19 package jalview.math;
  20
  21
  22 /**
  23  * DOCUMENT ME!
  24  *
  25  * @author $author$
  26  * @version $Revision$
  27  */
  28 public class RotatableMatrix
  29 {
  30     float[][] matrix;
  31     float[] temp;
  32     float[][] rot;
  33
  34     /**
  35      * Creates a new RotatableMatrix object.
  36      *
  37      * @param rows DOCUMENT ME!
  38      * @param cols DOCUMENT ME!
  39      */
  40     public RotatableMatrix(int rows, int cols)
  41     {
  42         matrix = new float[rows][cols];
  43
  44         temp = new float[3];
  45
  46         rot = new float[3][3];
  47     }
  48
  49     /**
  50      * DOCUMENT ME!
  51      *
  52      * @param i DOCUMENT ME!
  53      * @param j DOCUMENT ME!
  54      * @param value DOCUMENT ME!
  55      */
  56     public void addElement(int i, int j, float value)
  57     {
  58         matrix[i][j] = value;
  59     }
  60
  61     /**
  62      * DOCUMENT ME!
  63      */
  64     public void print()
  65     {
  66         System.out.println(matrix[0][0] + " " + matrix[0][1] + " " +
  67             matrix[0][2]);
  68
  69         System.out.println(matrix[1][0] + " " + matrix[1][1] + " " +
  70             matrix[1][2]);
  71
  72         System.out.println(matrix[2][0] + " " + matrix[2][1] + " " +
  73             matrix[2][2]);
  74     }
  75
  76     /**
  77      * DOCUMENT ME!
  78      *
  79      * @param degrees DOCUMENT ME!
  80      * @param axis DOCUMENT ME!
  81      */
  82     public void rotate(float degrees, char axis)
  83     {
  84         float costheta = (float) Math.cos((degrees * Math.PI) / (float) 180.0);
  85
  86         float sintheta = (float) Math.sin((degrees * Math.PI) / (float) 180.0);
  87
  88         if (axis == 'z')
  89         {
  90             rot[0][0] = (float) costheta;
  91
  92             rot[0][1] = (float) -sintheta;
  93
  94             rot[0][2] = (float) 0.0;
  95
  96             rot[1][0] = (float) sintheta;
  97
  98             rot[1][1] = (float) costheta;
  99
 100             rot[1][2] = (float) 0.0;
 101
 102             rot[2][0] = (float) 0.0;
 103
 104             rot[2][1] = (float) 0.0;
 105
 106             rot[2][2] = (float) 1.0;
 107
 108             preMultiply(rot);
 109         }
 110
 111         if (axis == 'x')
 112         {
 113             rot[0][0] = (float) 1.0;
 114
 115             rot[0][1] = (float) 0.0;
 116
 117             rot[0][2] = (float) 0.0;
 118
 119             rot[1][0] = (float) 0.0;
 120
 121             rot[1][1] = (float) costheta;
 122
 123             rot[1][2] = (float) sintheta;
 124
 125             rot[2][0] = (float) 0.0;
 126
 127             rot[2][1] = (float) -sintheta;
 128
 129             rot[2][2] = (float) costheta;
 130
 131             preMultiply(rot);
 132         }
 133
 134         if (axis == 'y')
 135         {
 136             rot[0][0] = (float) costheta;
 137
 138             rot[0][1] = (float) 0.0;
 139
 140             rot[0][2] = (float) -sintheta;
 141
 142             rot[1][0] = (float) 0.0;
 143
 144             rot[1][1] = (float) 1.0;
 145
 146             rot[1][2] = (float) 0.0;
 147
 148             rot[2][0] = (float) sintheta;
 149
 150             rot[2][1] = (float) 0.0;
 151
 152             rot[2][2] = (float) costheta;
 153
 154             preMultiply(rot);
 155         }
 156     }
 157
 158     /**
 159      * DOCUMENT ME!
 160      *
 161      * @param vect DOCUMENT ME!
 162      *
 163      * @return DOCUMENT ME!
 164      */
 165     public float[] vectorMultiply(float[] vect)
 166     {
 167         temp[0] = vect[0];
 168
 169         temp[1] = vect[1];
 170
 171         temp[2] = vect[2];
 172
 173         for (int i = 0; i < 3; i++)
 174         {
 175             temp[i] = (matrix[i][0] * vect[0]) + (matrix[i][1] * vect[1]) +
 176                 (matrix[i][2] * vect[2]);
 177         }
 178
 179         vect[0] = temp[0];
 180
 181         vect[1] = temp[1];
 182
 183         vect[2] = temp[2];
 184
 185         return vect;
 186     }
 187
 188     /**
 189      * DOCUMENT ME!
 190      *
 191      * @param mat DOCUMENT ME!
 192      */
 193     public void preMultiply(float[][] mat)
 194     {
 195         float[][] tmp = new float[3][3];
 196
 197         for (int i = 0; i < 3; i++)
 198         {
 199             for (int j = 0; j < 3; j++)
 200             {
 201                 tmp[i][j] = (mat[i][0] * matrix[0][j]) +
 202                     (mat[i][1] * matrix[1][j]) + (mat[i][2] * matrix[2][j]);
 203             }
 204         }
 205
 206         for (int i = 0; i < 3; i++)
 207         {
 208             for (int j = 0; j < 3; j++)
 209             {
 210                 matrix[i][j] = tmp[i][j];
 211             }
 212         }
 213     }
 214
 215     /**
 216      * DOCUMENT ME!
 217      *
 218      * @param mat DOCUMENT ME!
 219      */
 220     public void postMultiply(float[][] mat)
 221     {
 222         float[][] tmp = new float[3][3];
 223
 224         for (int i = 0; i < 3; i++)
 225         {
 226             for (int j = 0; j < 3; j++)
 227             {
 228                 tmp[i][j] = (matrix[i][0] * mat[0][j]) +
 229                     (matrix[i][1] * mat[1][j]) + (matrix[i][2] * mat[2][j]);
 230             }
 231         }
 232
 233         for (int i = 0; i < 3; i++)
 234         {
 235             for (int j = 0; j < 3; j++)
 236             {
 237                 matrix[i][j] = tmp[i][j];
 238             }
 239         }
 240     }
 241
 242     /**
 243      * DOCUMENT ME!
 244      *
 245      * @param args DOCUMENT ME!
 246      */
 247     public static void main(String[] args)
 248     {
 249         RotatableMatrix m = new RotatableMatrix(3, 3);
 250
 251         m.addElement(0, 0, 1);
 252
 253         m.addElement(0, 1, 0);
 254
 255         m.addElement(0, 2, 0);
 256
 257         m.addElement(1, 0, 0);
 258
 259         m.addElement(1, 1, 2);
 260
 261         m.addElement(1, 2, 0);
 262
 263         m.addElement(2, 0, 0);
 264
 265         m.addElement(2, 1, 0);
 266
 267         m.addElement(2, 2, 1);
 268
 269         m.print();
 270
 271         RotatableMatrix n = new RotatableMatrix(3, 3);
 272
 273         n.addElement(0, 0, 2);
 274
 275         n.addElement(0, 1, 1);
 276
 277         n.addElement(0, 2, 1);
 278
 279         n.addElement(1, 0, 2);
 280
 281         n.addElement(1, 1, 1);
 282
 283         n.addElement(1, 2, 1);
 284
 285         n.addElement(2, 0, 2);
 286
 287         n.addElement(2, 1, 1);
 288
 289         n.addElement(2, 2, 1);
 290
 291         n.print();
 292
 293         //m.postMultiply(n.matrix);
 294         //m.print();
 295         //     m.rotate(45,'z',new RotatableMatrix(3,3));
 296         float[] vect = new float[3];
 297
 298         vect[0] = 2;
 299
 300         vect[1] = 4;
 301
 302         vect[2] = 6;
 303
 304         vect = m.vectorMultiply(vect);
 305
 306         System.out.println(vect[0] + " " + vect[1] + " " + vect[2]);
 307     }
 308
 309     /**
 310      * DOCUMENT ME!
 311      */
 312     public void setIdentity()
 313     {
 314         matrix[0][0] = (float) 1.0;
 315
 316         matrix[1][1] = (float) 1.0;
 317
 318         matrix[2][2] = (float) 1.0;
 319
 320         matrix[0][1] = (float) 0.0;
 321
 322         matrix[0][2] = (float) 0.0;
 323
 324         matrix[1][0] = (float) 0.0;
 325
 326         matrix[1][2] = (float) 0.0;
 327
 328         matrix[2][0] = (float) 0.0;
 329
 330         matrix[2][1] = (float) 0.0;
 331     }
 332 }