1   package fi.jyu.mit.graphics;
2   import static java.lang.Math.round;
3   
4   /**
5    * Matriisliluokka kuvamuunnoslaskuihin. 
6    * @author Markus Kivioja
7    * @author Vesa Lappalainen
8    *
9    */
10  public class Matrix {
11      
12      protected final static int VSIZE = 4;
13      private double mat[][] = new double[VSIZE][VSIZE];
14      
15      /**
16       * Luo uuden 4x4 yksikkömatriin
17       */
18      public Matrix() {
19          this.ident();
20      }
21      
22      /**
23       * Luo kopion matriisista M
24       * @param M matriisi josta kopio luodaan
25       */
26      public Matrix(Matrix M) {
27          for (int r = 0; r < VSIZE; r++)
28              for (int s = 0; s < VSIZE; s++)
29                mat[r][s] = M.mat[r][s];
30      }
31      
32      /**
33       * Muuttaa matriisin yksikkömatriisiksi
34       */
35      protected final void ident() {
36          for (int r = 0; r < VSIZE; r++)
37              for (int s = 0; s < VSIZE; s++)
38                  mat[r][s] = 0.0;
39          for (int r = 0; r < VSIZE; r++)
40              mat[r][r] = 1.0;
41      }
42      
43      /**
44       * Palauttaa matriisin r:n rivin kopion
45       * @param r palautettava rivi
46       * @return r:n rivin kopio
47       */
48      public Vector row(int r) {   // NOPMD
49          Vector v = new Vector(); // NOPMD
50          for (int s = 0; s < VSIZE; s++) {
51              v.set(s, mat[r][s]);
52          }
53          return v;
54      }
55      
56      /**
57       * Palauttaa matriisin s:n sarakkeen kopion
58       * @param s palautettava sarake
59       * @return s:n sarakkeen kopio
60       */
61      public Vector column(int s) { // NOPMD
62          Vector v = new Vector();  // NOPMD
63          for (int r = 0; r < VSIZE; r++) {
64              v.set(r, mat[r][s]);
65          }
66          return v;
67      }
68      
69      /**
70       * Palauttaa matriisin alkion paikassa r,s
71       * @param r rivi jolta alkio halutaan
72       * @param s sarake jolta alkio halutaan
73       * @return r,s paikassa oleva alkio
74       */
75      public double m(int r, int s) { // NOPMD
76          return mat[r][s];
77      }
78      
79      /**
80       * Asettaa matriisin paikassa r,s olevan alkion
81       * @param r rivi jonka alkio asetetaan
82       * @param s sarake jonka alkio asetetaan
83       * @param d uusi arvo alkiolle
84       */
85      protected void set(int r, int s, double d) {
86          mat[r][s] = d;
87      }
88      
89      /**
90       * Kertoo matriisin b matriisilla ja palauttaa uuden matriisin tuloksena
91       * @param b matriisi joka kerrotaan
92       * @return uusi matriisi this * b
93       */
94      public Matrix multiply(Matrix b) {
95          if ( b == null ) return this;
96          return multiply(b,new Matrix());
97      }
98      
99      
100     
101     
102     /**
103      * Kertoo matriisin b matriisilla ja palauttaa uuden matriisin tuloksena.
104      * this eikä b ei saa olla c!
105      * @param b matriisi joka kerrotaan
106      * @param c matriisi johon tulos tulee
107      * @return uusi matriisi this * b
108      */
109     public Matrix multiply(Matrix b, Matrix c) {
110         // if ( b == c ) throw new Execption
111         for (int r = 0; r < VSIZE; r++)
112             for (int s = 0; s < VSIZE; s++) {
113                 double sum = 0;
114                 for (int i = 0; i < VSIZE; i++) 
115                     sum += mat[r][i] * b.mat[i][s];
116                 c.mat[r][s] = sum;  
117             }   
118         return c;
119     }
120     
121     /**
122      * Kertoo matriisin b matriisilla ja laittaa tuloksen itseensä
123      * @param b matriisi joka kerrotaan
124      * @return  this * b
125      */
126     public Matrix multiplyThis(Matrix b) {
127         double row[] = {0,0,0,0};
128         for (int r = 0; r < VSIZE; r++) {
129             for (int s = 0; s < VSIZE; s++) {
130                 double sum = 0;
131                 for (int i = 0; i < VSIZE; i++) 
132                     sum += mat[r][i] * b.mat[i][s];
133                 row[s] = sum;   
134             }   
135             for (int s = 0; s < VSIZE; s++) 
136                 mat[r][s] = row[s];
137         }   
138         return this;
139     }
140     
141     /**
142      * Kertoo vektorin tällä matriisilla, luo uuden paluuvektorin
143      * @param b vektori joka kerrotaan
144      * @return this * b
145      */
146     public Vector multiply(Vector b) { // NOPMD
147         Vector y = new Vector();       // NOPMD
148         for (int r = 0; r < VSIZE; r++) {
149             double sum = 0;
150             for (int s = 0; s < VSIZE; s++)
151                 sum += mat[r][s] * b.a(s);
152             y.set(r, sum );
153         }
154         return y;
155     }
156     
157     /**
158      * Kertoo vektorin tällä matriisilla ja tuloksen vektoriin y
159      * @param b vektori joka kerrotaan
160      * @param y vektori johon tulos tulee
161      * @return this * b
162      */
163     public Vector multiply(Vector b, Vector y) { // NOPMD
164         for (int r = 0; r < VSIZE; r++) {
165             double sum = 0;
166             for (int s = 0; s < VSIZE; s++)
167                 sum += mat[r][s] * b.a(s);
168             y.set(r, sum );
169         }
170         return y;
171     }
172     
173     /**
174      * Kertoo vektorin tällä matriisilla ja sijoittaa tuloksen näyttökoordinaattiin iy.
175      * Spesiaalikertominen erityisesti kuvamuunnoksiin, joissa
176      * tarvitaan vain 2 ensimmäistä alkiota vektorista iy.
177      * @param b vektori joka kerrotaan
178      * @param iy vektori johon tulos tulee
179      * @return this * b
180      */
181     public SPoint transform(Vector b, SPoint iy) { // NOPMD
182         double sum0 = 0, sum1 = 0;
183         for (int s = 0; s < VSIZE; s++) sum0 += mat[0][s] * b.a(s);
184         for (int s = 0; s < VSIZE; s++) sum1 += mat[1][s] * b.a(s);
185         // TODO: pitäisi vielä laskea viimeisen rivin arvo, jos
186         //       se on !=1; niin sillä jaetaan x ja y.
187         //       Tarvitaan sitten kun mat[3] rivillä on jotakin
188         return iy.set((int)round(sum0), (int)round(sum1));
189     }
190     
191     /**
192      * Kertoo vektorin tällä matriisilla ja sijoittaa tuloksen näyttökoordinaattiin iy.
193      * Spesiaalikertominen erityisesti kuvamuunnoksiin, joissa
194      * tarvitaan vain 2 ensimmäistä alkiota vektorista iy.
195      * @param b vektori joka kerrotaan
196      * @param iy vektori johon tulos tulee
197      * @return this * b
198      */
199     public Vector transform(Vector b,  Vector iy) { // NOPMD
200         double sum0 = 0, sum1 = 0;
201         for (int s = 0; s < VSIZE; s++) sum0 += mat[0][s] * b.a(s);
202         for (int s = 0; s < VSIZE; s++) sum1 += mat[1][s] * b.a(s);
203         // TODO: pitäisi vielä laskea viimeisen rivin arvo, jos
204         //       se on !=1; niin sillä jaetaan x ja y.
205         //       Tarvitaan sitten kun mat[3] rivillä on jotakin
206         return iy.set(sum0, sum1);
207     }
208     
209     /**
210      * Muuntaa koordinaatin (x,y,z) näytön pisteeksi. 
211      * @param x
212      * @param y
213      * @param z
214      * @return uusi näytön piste joka edustaa (x,y,z)
215      */
216     public SPoint transform(double x, double y, double z) {
217         Vector vr = new Vector(x, y, z); // NOPMD
218         SPoint sp = new SPoint(0,0);
219         return this.transform(vr,sp);
220     }
221     
222     /**
223      * Muuntaa koordinaatin (x,y,z) näytön pisteeksi.
224      * "Optimoitu" versio, jolle viedään työtilat parametrina. 
225      * @param x
226      * @param y
227      * @param z
228      * @param vr vektori johon saa sijoittaa väliaikaisesti (x,y,z)
229      * @param sp näytön piste johon tuloksen saa sijoittaa.
230      * @return parametrina tuotu näytön piste joka edustaa (x,y,z)
231      */
232     public SPoint transform(double x, double y, double z, Vector vr, SPoint sp) { // NOPMD
233         return this.transform(vr.set(x,y,z),sp);
234     }
235     
236 
237     /**
238      * Muuntaa koordinaatin (x,y,z) näytön pisteeksi.
239      * "Optimoitu" versio, jolle viedään työtilat parametrina. 
240      * @param x
241      * @param y
242      * @param z
243      * @param vr vektori johon saa sijoittaa väliaikaisesti (x,y,z)
244      * @param sp näytön piste johon tuloksen saa sijoittaa.
245      * @return parametrina tuotu näytön piste joka edustaa (x,y,z)
246      */
247     public Vector transform(double x, double y, double z, Vector vr, Vector sp) { // NOPMD
248         return this.transform(vr.set(x,y,z),sp);
249     }
250     
251 
252     /**
253      * Muuntaa pisteen p näytön pisteeksi. 
254      * @param p muunettava piste.
255      * @return uusi näytönpiste joka vastaa pistettä p.
256      */
257     public SPoint transform(RPoint p) {
258         SPoint sp = new SPoint(0,0);
259         return this.transform(p,sp);
260     }
261     
262     /**
263      * Palauttaa tämän matrisiin merkkijonona
264      * @return tämä matriisi merkkijonona
265      */
266     public String toString() {
267         StringBuilder sb = new StringBuilder();
268         for (int r = 0; r < VSIZE; r++) {
269             sb.append("( ");
270             for (int s = 0; s < VSIZE; s++)
271                 sb.append(" " + mat[r][s]);
272             sb.append(" )\n");
273         }   
274         return sb.toString();       
275     }
276     
277 }
278 
279