JAL-2403 redundant 'implements' removed
[jalview.git] / src / jalview / appletgui / RotatableCanvas.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.appletgui;
22
23 import jalview.api.RotatableCanvasI;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.datamodel.SequencePoint;
27 import jalview.math.RotatableMatrix;
28 import jalview.util.Format;
29 import jalview.util.MessageManager;
30 import jalview.viewmodel.AlignmentViewport;
31
32 import java.awt.Color;
33 import java.awt.Dimension;
34 import java.awt.Font;
35 import java.awt.Graphics;
36 import java.awt.Image;
37 import java.awt.Panel;
38 import java.awt.event.KeyEvent;
39 import java.awt.event.KeyListener;
40 import java.awt.event.MouseEvent;
41 import java.awt.event.MouseListener;
42 import java.awt.event.MouseMotionListener;
43 import java.util.Vector;
44
45 public class RotatableCanvas extends Panel implements MouseListener,
46         MouseMotionListener, KeyListener, RotatableCanvasI
47 {
48   RotatableMatrix idmat = new RotatableMatrix(3, 3);
49
50   RotatableMatrix objmat = new RotatableMatrix(3, 3);
51
52   RotatableMatrix rotmat = new RotatableMatrix(3, 3);
53
54   String tooltip;
55
56   int toolx, tooly;
57
58   // RubberbandRectangle rubberband;
59
60   boolean drawAxes = true;
61
62   int omx = 0;
63
64   int mx = 0;
65
66   int omy = 0;
67
68   int my = 0;
69
70   Image img;
71
72   Graphics ig;
73
74   Dimension prefsize;
75
76   float centre[] = new float[3];
77
78   float width[] = new float[3];
79
80   float max[] = new float[3];
81
82   float min[] = new float[3];
83
84   float maxwidth;
85
86   float scale;
87
88   int npoint;
89
90   Vector points;
91
92   float[][] orig;
93
94   float[][] axes;
95
96   int startx;
97
98   int starty;
99
100   int lastx;
101
102   int lasty;
103
104   int rectx1;
105
106   int recty1;
107
108   int rectx2;
109
110   int recty2;
111
112   float scalefactor = 1;
113
114   AlignmentViewport av;
115
116   boolean showLabels = false;
117
118   public RotatableCanvas(AlignmentViewport av)
119   {
120     this.av = av;
121   }
122
123   public void showLabels(boolean b)
124   {
125     showLabels = b;
126     repaint();
127   }
128
129   public void setPoints(Vector points, int npoint)
130   {
131     this.points = points;
132     this.npoint = npoint;
133     PaintRefresher.Register(this, av.getSequenceSetId());
134
135     prefsize = getPreferredSize();
136     orig = new float[npoint][3];
137
138     for (int i = 0; i < npoint; i++)
139     {
140       SequencePoint sp = (SequencePoint) points.elementAt(i);
141       for (int j = 0; j < 3; j++)
142       {
143         orig[i][j] = sp.coord[j];
144       }
145     }
146     // Initialize the matrices to identity
147
148     for (int i = 0; i < 3; i++)
149     {
150       for (int j = 0; j < 3; j++)
151       {
152         if (i != j)
153         {
154           idmat.addElement(i, j, 0);
155           objmat.addElement(i, j, 0);
156           rotmat.addElement(i, j, 0);
157         }
158         else
159         {
160           idmat.addElement(i, j, 0);
161           objmat.addElement(i, j, 0);
162           rotmat.addElement(i, j, 0);
163         }
164       }
165     }
166
167     axes = new float[3][3];
168     initAxes();
169
170     findCentre();
171     findWidth();
172
173     scale = findScale();
174
175     // System.out.println("Scale factor = " + scale);
176
177     addMouseListener(this);
178     addKeyListener(this);
179     // if (getParent() != null) {
180     // getParent().addKeyListener(this);
181     // }
182     addMouseMotionListener(this);
183
184     // Add rubberband
185     // rubberband = new RubberbandRectangle(this);
186     // rubberband.setActive(true);
187     // rubberband.addListener(this);
188   }
189
190   /*
191    * public boolean handleSequenceSelectionEvent(SequenceSelectionEvent evt) {
192    * redrawneeded = true; repaint(); return true; }
193    * 
194    * public void removeNotify() { controller.removeListener(this);
195    * super.removeNotify(); }
196    */
197
198   public void initAxes()
199   {
200     for (int i = 0; i < 3; i++)
201     {
202       for (int j = 0; j < 3; j++)
203       {
204         if (i != j)
205         {
206           axes[i][j] = 0;
207         }
208         else
209         {
210           axes[i][j] = 1;
211         }
212       }
213     }
214   }
215
216   public void findWidth()
217   {
218     max = new float[3];
219     min = new float[3];
220
221     max[0] = (float) -1e30;
222     max[1] = (float) -1e30;
223     max[2] = (float) -1e30;
224
225     min[0] = (float) 1e30;
226     min[1] = (float) 1e30;
227     min[2] = (float) 1e30;
228
229     for (int i = 0; i < 3; i++)
230     {
231       for (int j = 0; j < npoint; j++)
232       {
233         SequencePoint sp = (SequencePoint) points.elementAt(j);
234         if (sp.coord[i] >= max[i])
235         {
236           max[i] = sp.coord[i];
237         }
238         if (sp.coord[i] <= min[i])
239         {
240           min[i] = sp.coord[i];
241         }
242       }
243     }
244
245     // System.out.println("xmax " + max[0] + " min " + min[0]);
246     // System.out.println("ymax " + max[1] + " min " + min[1]);
247     // System.out.println("zmax " + max[2] + " min " + min[2]);
248
249     width[0] = Math.abs(max[0] - min[0]);
250     width[1] = Math.abs(max[1] - min[1]);
251     width[2] = Math.abs(max[2] - min[2]);
252
253     maxwidth = width[0];
254
255     if (width[1] > width[0])
256     {
257       maxwidth = width[1];
258     }
259     if (width[2] > width[1])
260     {
261       maxwidth = width[2];
262     }
263
264     // System.out.println("Maxwidth = " + maxwidth);
265   }
266
267   public float findScale()
268   {
269     int dim, width, height;
270     if (getSize().width != 0)
271     {
272       width = getSize().width;
273       height = getSize().height;
274     }
275     else
276     {
277       width = prefsize.width;
278       height = prefsize.height;
279     }
280
281     if (width < height)
282     {
283       dim = width;
284     }
285     else
286     {
287       dim = height;
288     }
289
290     return (float) (dim * scalefactor / (2 * maxwidth));
291   }
292
293   public void findCentre()
294   {
295     // Find centre coordinate
296     findWidth();
297
298     centre[0] = (max[0] + min[0]) / 2;
299     centre[1] = (max[1] + min[1]) / 2;
300     centre[2] = (max[2] + min[2]) / 2;
301
302     // System.out.println("Centre x " + centre[0]);
303     // System.out.println("Centre y " + centre[1]);
304     // System.out.println("Centre z " + centre[2]);
305   }
306
307   public Dimension getPreferredSize()
308   {
309     if (prefsize != null)
310     {
311       return prefsize;
312     }
313     else
314     {
315       return new Dimension(400, 400);
316     }
317   }
318
319   public Dimension getMinimumSize()
320   {
321     return getPreferredSize();
322   }
323
324   public void update(Graphics g)
325   {
326     paint(g);
327   }
328
329   public void paint(Graphics g)
330   {
331     if (points == null)
332     {
333       g.setFont(new Font("Verdana", Font.PLAIN, 18));
334       g.drawString(MessageManager.getString("label.calculating_pca")
335               + "....", 20, getSize().height / 2);
336     }
337     else
338     {
339
340       // Only create the image at the beginning -
341       if ((img == null) || (prefsize.width != getSize().width)
342               || (prefsize.height != getSize().height))
343       {
344         prefsize.width = getSize().width;
345         prefsize.height = getSize().height;
346
347         scale = findScale();
348
349         // System.out.println("New scale = " + scale);
350         img = createImage(getSize().width, getSize().height);
351         ig = img.getGraphics();
352
353       }
354
355       drawBackground(ig, Color.black);
356       drawScene(ig);
357       if (drawAxes == true)
358       {
359         drawAxes(ig);
360       }
361
362       if (tooltip != null)
363       {
364         ig.setColor(Color.red);
365         ig.drawString(tooltip, toolx, tooly);
366       }
367
368       g.drawImage(img, 0, 0, this);
369     }
370   }
371
372   public void drawAxes(Graphics g)
373   {
374
375     g.setColor(Color.yellow);
376     for (int i = 0; i < 3; i++)
377     {
378       g.drawLine(getSize().width / 2, getSize().height / 2,
379               (int) (axes[i][0] * scale * max[0] + getSize().width / 2),
380               (int) (axes[i][1] * scale * max[1] + getSize().height / 2));
381     }
382   }
383
384   public void drawBackground(Graphics g, Color col)
385   {
386     g.setColor(col);
387     g.fillRect(0, 0, prefsize.width, prefsize.height);
388   }
389
390   public void drawScene(Graphics g)
391   {
392     // boolean darker = false;
393
394     int halfwidth = getSize().width / 2;
395     int halfheight = getSize().height / 2;
396
397     for (int i = 0; i < npoint; i++)
398     {
399       SequencePoint sp = (SequencePoint) points.elementAt(i);
400       int x = (int) ((float) (sp.coord[0] - centre[0]) * scale) + halfwidth;
401       int y = (int) ((float) (sp.coord[1] - centre[1]) * scale)
402               + halfheight;
403       float z = sp.coord[1] - centre[2];
404
405       if (av.getSequenceColour(sp.sequence) == Color.black)
406       {
407         g.setColor(Color.white);
408       }
409       else
410       {
411         g.setColor(av.getSequenceColour(sp.sequence));
412       }
413
414       if (av.getSelectionGroup() != null)
415       {
416         if (av.getSelectionGroup().getSequences(null)
417                 .contains(((SequencePoint) points.elementAt(i)).sequence))
418         {
419           g.setColor(Color.gray);
420         }
421       }
422       if (z < 0)
423       {
424         g.setColor(g.getColor().darker());
425       }
426
427       g.fillRect(x - 3, y - 3, 6, 6);
428       if (showLabels)
429       {
430         g.setColor(Color.red);
431         g.drawString(
432                 ((SequencePoint) points.elementAt(i)).sequence.getName(),
433                 x - 3, y - 4);
434       }
435     }
436   }
437
438   public Dimension minimumsize()
439   {
440     return prefsize;
441   }
442
443   public Dimension preferredsize()
444   {
445     return prefsize;
446   }
447
448   public void keyTyped(KeyEvent evt)
449   {
450   }
451
452   public void keyReleased(KeyEvent evt)
453   {
454   }
455
456   public void keyPressed(KeyEvent evt)
457   {
458     if (evt.getKeyCode() == KeyEvent.VK_UP)
459     {
460       scalefactor = (float) (scalefactor * 1.1);
461       scale = findScale();
462     }
463     else if (evt.getKeyCode() == KeyEvent.VK_DOWN)
464     {
465       scalefactor = (float) (scalefactor * 0.9);
466       scale = findScale();
467     }
468     else if (evt.getKeyChar() == 's')
469     {
470       System.err.println("DEBUG: Rectangle selection"); // log.debug
471       if (rectx2 != -1 && recty2 != -1)
472       {
473         rectSelect(rectx1, recty1, rectx2, recty2);
474
475       }
476     }
477     repaint();
478   }
479
480   public void printPoints()
481   {
482     for (int i = 0; i < npoint; i++)
483     {
484       SequencePoint sp = (SequencePoint) points.elementAt(i);
485       Format.print(System.out, "%5d ", i);
486       for (int j = 0; j < 3; j++)
487       {
488         Format.print(System.out, "%13.3f  ", sp.coord[j]);
489       }
490       System.out.println();
491     }
492   }
493
494   public void mouseClicked(MouseEvent evt)
495   {
496   }
497
498   public void mouseEntered(MouseEvent evt)
499   {
500   }
501
502   public void mouseExited(MouseEvent evt)
503   {
504   }
505
506   public void mouseReleased(MouseEvent evt)
507   {
508   }
509
510   public void mousePressed(MouseEvent evt)
511   {
512     int x = evt.getX();
513     int y = evt.getY();
514
515     mx = x;
516     my = y;
517
518     omx = mx;
519     omy = my;
520
521     startx = x;
522     starty = y;
523
524     rectx1 = x;
525     recty1 = y;
526
527     rectx2 = -1;
528     recty2 = -1;
529
530     SequenceI found = findPoint(x, y);
531
532     if (found != null)
533     {
534       // TODO: applet PCA is not associatable with multi-panels - only parent
535       // view
536       if (av.getSelectionGroup() != null)
537       {
538         av.getSelectionGroup().addOrRemove(found, true);
539         av.getSelectionGroup().setEndRes(av.getAlignment().getWidth() - 1);
540       }
541       else
542       {
543         av.setSelectionGroup(new SequenceGroup());
544         av.getSelectionGroup().addOrRemove(found, true);
545         av.getSelectionGroup().setEndRes(av.getAlignment().getWidth() - 1);
546
547       }
548       PaintRefresher.Refresh(this, av.getSequenceSetId());
549       av.sendSelection();
550     }
551     repaint();
552   }
553
554   public void mouseMoved(MouseEvent evt)
555   {
556     SequenceI found = findPoint(evt.getX(), evt.getY());
557     if (found == null)
558     {
559       tooltip = null;
560     }
561     else
562     {
563       tooltip = found.getName();
564       toolx = evt.getX();
565       tooly = evt.getY();
566     }
567     repaint();
568   }
569
570   public void mouseDragged(MouseEvent evt)
571   {
572     mx = evt.getX();
573     my = evt.getY();
574
575     rotmat.setIdentity();
576
577     rotmat.rotate((float) (my - omy), 'x');
578     rotmat.rotate((float) (mx - omx), 'y');
579
580     for (int i = 0; i < npoint; i++)
581     {
582       SequencePoint sp = (SequencePoint) points.elementAt(i);
583       sp.coord[0] -= centre[0];
584       sp.coord[1] -= centre[1];
585       sp.coord[2] -= centre[2];
586
587       // Now apply the rotation matrix
588       sp.coord = rotmat.vectorMultiply(sp.coord);
589
590       // Now translate back again
591       sp.coord[0] += centre[0];
592       sp.coord[1] += centre[1];
593       sp.coord[2] += centre[2];
594     }
595
596     for (int i = 0; i < 3; i++)
597     {
598       axes[i] = rotmat.vectorMultiply(axes[i]);
599     }
600     omx = mx;
601     omy = my;
602
603     paint(this.getGraphics());
604   }
605
606   public void rectSelect(int x1, int y1, int x2, int y2)
607   {
608     // boolean changedSel = false;
609     for (int i = 0; i < npoint; i++)
610     {
611       SequencePoint sp = (SequencePoint) points.elementAt(i);
612       int tmp1 = (int) ((sp.coord[0] - centre[0]) * scale + (float) getSize().width / 2.0);
613       int tmp2 = (int) ((sp.coord[1] - centre[1]) * scale + (float) getSize().height / 2.0);
614
615       if (tmp1 > x1 && tmp1 < x2 && tmp2 > y1 && tmp2 < y2)
616       {
617         if (av != null)
618         {
619           if (!av.getSelectionGroup().getSequences(null)
620                   .contains(sp.sequence))
621           {
622             av.getSelectionGroup().addSequence(sp.sequence, true);
623           }
624         }
625       }
626     }
627   }
628
629   public SequenceI findPoint(int x, int y)
630   {
631
632     int halfwidth = getSize().width / 2;
633     int halfheight = getSize().height / 2;
634
635     int found = -1;
636
637     for (int i = 0; i < npoint; i++)
638     {
639
640       SequencePoint sp = (SequencePoint) points.elementAt(i);
641       int px = (int) ((float) (sp.coord[0] - centre[0]) * scale)
642               + halfwidth;
643       int py = (int) ((float) (sp.coord[1] - centre[1]) * scale)
644               + halfheight;
645
646       if (Math.abs(px - x) < 3 && Math.abs(py - y) < 3)
647       {
648         found = i;
649       }
650     }
651     if (found != -1)
652     {
653       return ((SequencePoint) points.elementAt(found)).sequence;
654     }
655     else
656     {
657       return null;
658     }
659   }
660
661 }