src/jalview/gui/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.gui;
  22
  23 import jalview.api.RotatableCanvasI;
  24 import jalview.datamodel.Point;
  25 import jalview.datamodel.SequenceGroup;
  26 import jalview.datamodel.SequenceI;
  27 import jalview.datamodel.SequencePoint;
  28 import jalview.math.RotatableMatrix;
  29 import jalview.math.RotatableMatrix.Axis;
  30 import jalview.util.ColorUtils;
  31 import jalview.util.MessageManager;
  32 import jalview.viewmodel.AlignmentViewport;
  33
  34 import java.awt.Color;
  35 import java.awt.Dimension;
  36 import java.awt.Font;
  37 import java.awt.Graphics;
  38 import java.awt.Graphics2D;
  39 import java.awt.Image;
  40 import java.awt.RenderingHints;
  41 import java.awt.event.InputEvent;
  42 import java.awt.event.KeyEvent;
  43 import java.awt.event.KeyListener;
  44 import java.awt.event.MouseEvent;
  45 import java.awt.event.MouseListener;
  46 import java.awt.event.MouseMotionListener;
  47 import java.awt.event.MouseWheelEvent;
  48 import java.awt.event.MouseWheelListener;
  49 import java.util.Arrays;
  50 import java.util.Iterator;
  51 import java.util.List;
  52
  53 import javax.swing.JPanel;
  54 import javax.swing.ToolTipManager;
  55
  56 /**
  57  * Models a Panel on which a set of points, and optionally x/y/z axes, can be
  58  * drawn, and rotated or zoomed with the mouse
  59  */
  60 public class RotatableCanvas extends JPanel implements MouseListener,
  61         MouseMotionListener, KeyListener, RotatableCanvasI,
  62         MouseWheelListener
  63 {
  64   private static final float ZOOM_OUT = 0.9f;
  65
  66   private static final float ZOOM_IN = 1.1f;
  67
  68   /*
  69    * pixels distance within which tooltip shows sequence name
  70    */
  71   private static final int NEARBY = 3;
  72
  73   private static final List<String> AXES = Arrays.asList("x", "y", "z");
  74
  75   private static final Color AXIS_COLOUR = Color.yellow;
  76
  77   private static final int DIMS = 3;
  78
  79   boolean drawAxes = true;
  80
  81   int mouseX;
  82
  83   int mouseY;
  84
  85   Image img;
  86
  87   Graphics ig;
  88
  89   Dimension prefSize;
  90
  91   /*
  92    * the min-max [x, y, z] values of sequence points when the points
  93    * were set on the object, or when the view is reset;
  94    * x and y ranges are not recomputed as points are rotated, as this
  95    * would make scaling (zoom) unstable, but z ranges are (for correct
  96    * graduated colour brightness based on z-coordinate)
  97    */
  98   float[] seqMin;
  99
 100   float[] seqMax;
 101
 102   /*
 103    * a scale factor used in drawing; when equal to 1, the points span
 104    * half the available width or height (whichever is less); increase this
 105    * factor to zoom in, decrease it to zoom out
 106    */
 107   float scaleFactor;
 108
 109   int npoint;
 110
 111   /*
 112    * sequences and their (x, y, z) PCA dimension values
 113    */
 114   List<SequencePoint> sequencePoints;
 115
 116   /*
 117    * x, y, z axis end points (PCA dimension values)
 118    */
 119   Point[] axisEndPoints;
 120
 121   // fields for 'select rectangle' (JAL-1124)
 122   // int rectx1;
 123   // int recty1;
 124   // int rectx2;
 125   // int recty2;
 126
 127   AlignmentViewport av;
 128
 129   AlignmentPanel ap;
 130
 131   boolean showLabels;
 132
 133   Color bgColour;
 134
 135   boolean applyToAllViews;
 136
 137   /**
 138    * Constructor
 139    *
 140    * @param panel
 141    */
 142   public RotatableCanvas(AlignmentPanel panel)
 143   {
 144     this.av = panel.av;
 145     this.ap = panel;
 146     axisEndPoints = new Point[DIMS];
 147     showLabels = false;
 148     applyToAllViews = false;
 149     bgColour = Color.BLACK;
 150     resetAxes();
 151
 152     ToolTipManager.sharedInstance().registerComponent(this);
 153
 154     addMouseListener(this);
 155     addMouseMotionListener(this);
 156     addMouseWheelListener(this);
 157   }
 158
 159   /**
 160    * Refreshes the display with labels shown (or not)
 161    *
 162    * @param show
 163    */
 164   public void showLabels(boolean show)
 165   {
 166     showLabels = show;
 167     repaint();
 168   }
 169
 170   @Override
 171   public void setPoints(List<SequencePoint> points, int np)
 172   {
 173     this.sequencePoints = points;
 174     this.npoint = np;
 175     prefSize = getPreferredSize();
 176
 177     findWidths();
 178
 179     scaleFactor = 1f;
 180   }
 181
 182   /**
 183    * Resets axes to the initial state: x-axis to the right, y-axis up, z-axis to
 184    * back (so obscured in a 2-D display)
 185    */
 186   protected void resetAxes()
 187   {
 188     axisEndPoints[0] = new Point(1f, 0f, 0f);
 189     axisEndPoints[1] = new Point(0f, 1f, 0f);
 190     axisEndPoints[2] = new Point(0f, 0f, 1f);
 191   }
 192
 193   /**
 194    * Computes and saves the min-max ranges of x/y/z positions of the sequence
 195    * points
 196    */
 197   protected void findWidths()
 198   {
 199     float[] max = new float[DIMS];
 200     float[] min = new float[DIMS];
 201
 202     max[0] = -Float.MAX_VALUE;
 203     max[1] = -Float.MAX_VALUE;
 204     max[2] = -Float.MAX_VALUE;
 205
 206     min[0] = Float.MAX_VALUE;
 207     min[1] = Float.MAX_VALUE;
 208     min[2] = Float.MAX_VALUE;
 209
 210     for (SequencePoint sp : sequencePoints)
 211     {
 212       max[0] = Math.max(max[0], sp.coord.x);
 213       max[1] = Math.max(max[1], sp.coord.y);
 214       max[2] = Math.max(max[2], sp.coord.z);
 215       min[0] = Math.min(min[0], sp.coord.x);
 216       min[1] = Math.min(min[1], sp.coord.y);
 217       min[2] = Math.min(min[2], sp.coord.z);
 218     }
 219
 220     seqMin = min;
 221     seqMax = max;
 222   }
 223
 224   /**
 225    * Answers the preferred size if it has been set, else 400 x 400
 226    *
 227    * @return
 228    */
 229   @Override
 230   public Dimension getPreferredSize()
 231   {
 232     if (prefSize != null)
 233     {
 234       return prefSize;
 235     }
 236     else
 237     {
 238       return new Dimension(400, 400);
 239     }
 240   }
 241
 242   /**
 243    * Answers the preferred size
 244    *
 245    * @return
 246    * @see RotatableCanvas#getPreferredSize()
 247    */
 248   @Override
 249   public Dimension getMinimumSize()
 250   {
 251     return getPreferredSize();
 252   }
 253
 254   /**
 255    * Repaints the panel
 256    *
 257    * @param g
 258    */
 259   @Override
 260   public void paintComponent(Graphics g1)
 261   {
 262
 263     Graphics2D g = (Graphics2D) g1;
 264
 265     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 266             RenderingHints.VALUE_ANTIALIAS_ON);
 267     if (sequencePoints == null)
 268     {
 269       g.setFont(new Font("Verdana", Font.PLAIN, 18));
 270       g.drawString(
 271               MessageManager.getString("label.calculating_pca") + "....",
 272               20, getHeight() / 2);
 273     }
 274     else
 275     {
 276       /*
 277        * create the image at the beginning or after a resize
 278        */
 279       boolean resized = prefSize.width != getWidth()
 280               || prefSize.height != getHeight();
 281       if (img == null || resized)
 282       {
 283         prefSize.width = getWidth();
 284         prefSize.height = getHeight();
 285
 286         img = createImage(getWidth(), getHeight());
 287         ig = img.getGraphics();
 288       }
 289
 290       drawBackground(ig, bgColour);
 291       drawScene(ig);
 292
 293       if (drawAxes)
 294       {
 295         drawAxes(ig);
 296       }
 297
 298       g.drawImage(img, 0, 0, this);
 299     }
 300   }
 301
 302   /**
 303    * Resets the rotation and choice of axes to the initial state (without change
 304    * of scale factor)
 305    */
 306   public void resetView()
 307   {
 308     img = null;
 309     findWidths();
 310     resetAxes();
 311     repaint();
 312   }
 313
 314   /**
 315    * Draws lines for the x, y, z axes
 316    *
 317    * @param g
 318    */
 319   public void drawAxes(Graphics g)
 320   {
 321     g.setColor(AXIS_COLOUR);
 322
 323     int midX = getWidth() / 2;
 324     int midY = getHeight() / 2;
 325     float maxWidth = Math.max(Math.abs(seqMax[0] - seqMin[0]),
 326             Math.abs(seqMax[1] - seqMin[1]));
 327     int pix = Math.min(getWidth(), getHeight());
 328     float scaleBy = pix * scaleFactor / (2f * maxWidth);
 329
 330     for (int i = 0; i < DIMS; i++)
 331     {
 332       g.drawLine(midX, midY,
 333               midX + (int) (axisEndPoints[i].x * scaleBy * seqMax[0]),
 334               midY + (int) (axisEndPoints[i].y * scaleBy * seqMax[1]));
 335     }
 336   }
 337
 338   /**
 339    * Fills the background with the specified colour
 340    *
 341    * @param g
 342    * @param col
 343    */
 344   public void drawBackground(Graphics g, Color col)
 345   {
 346     g.setColor(col);
 347     g.fillRect(0, 0, prefSize.width, prefSize.height);
 348   }
 349
 350   /**
 351    * Draws points (6x6 squares) for the sequences of the PCA, and labels
 352    * (sequence names) if configured to do so. The sequence points colours are
 353    * taken from the sequence ids in the alignment (converting black to white).
 354    * Sequences 'at the back' (z-coordinate is negative) are shaded slightly
 355    * darker to help give a 3-D sensation.
 356    *
 357    * @param g
 358    */
 359   public void drawScene(Graphics g1)
 360   {
 361     Graphics2D g = (Graphics2D) g1;
 362
 363     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 364             RenderingHints.VALUE_ANTIALIAS_ON);
 365     int pix = Math.min(getWidth(), getHeight());
 366     float xWidth = Math.abs(seqMax[0] - seqMin[0]);
 367     float yWidth = Math.abs(seqMax[1] - seqMin[1]);
 368     float maxWidth = Math.max(xWidth, yWidth);
 369     float scaleBy = pix * scaleFactor / (2f * maxWidth);
 370
 371     float[] centre = getCentre();
 372
 373     for (int i = 0; i < npoint; i++)
 374     {
 375       /*
 376        * sequence point colour as sequence id, but
 377        * gray if sequence is currently selected
 378        */
 379       SequencePoint sp = sequencePoints.get(i);
 380       Color sequenceColour = getSequencePointColour(sp);
 381       g.setColor(sequenceColour);
 382
 383       int halfwidth = getWidth() / 2;
 384       int halfheight = getHeight() / 2;
 385       int x = (int) ((sp.coord.x - centre[0]) * scaleBy) + halfwidth;
 386       int y = (int) ((sp.coord.y - centre[1]) * scaleBy) + halfheight;
 387       g.fillRect(x - 3, y - 3, 6, 6);
 388
 389       if (showLabels)
 390       {
 391         g.setColor(Color.red);
 392         g.drawString(sp.getSequence().getName(), x - 3, y - 4);
 393       }
 394     }
 395     if (showLabels)
 396     {
 397       g.setColor(AXIS_COLOUR);
 398       int midX = getWidth() / 2;
 399       int midY = getHeight() / 2;
 400       Iterator<String> axes = AXES.iterator();
 401       for (Point p : axisEndPoints)
 402       {
 403         int x = midX + (int) (p.x * scaleBy * seqMax[0]);
 404         int y = midY + (int) (p.y * scaleBy * seqMax[1]);
 405         g.drawString(axes.next(), x - 3, y - 4);
 406       }
 407     }
 408     // //Now the rectangle
 409     // if (rectx2 != -1 && recty2 != -1) {
 410     // g.setColor(Color.white);
 411     //
 412     // g.drawRect(rectx1,recty1,rectx2-rectx1,recty2-recty1);
 413     // }
 414   }
 415
 416   /**
 417    * Determines the colour to use when drawing a sequence point. The colour is
 418    * taken from the sequence id, with black converted to white, and then
 419    * graduated from darker (at the back) to brighter (at the front) based on the
 420    * z-axis coordinate of the point.
 421    *
 422    * @param sp
 423    * @return
 424    */
 425   protected Color getSequencePointColour(SequencePoint sp)
 426   {
 427     SequenceI sequence = sp.getSequence();
 428     Color sequenceColour = av.getSequenceColour(sequence);
 429     if (sequenceColour == Color.black)
 430     {
 431       sequenceColour = Color.white;
 432     }
 433     if (av.getSelectionGroup() != null)
 434     {
 435       if (av.getSelectionGroup().getSequences(null).contains(sequence))
 436       {
 437         sequenceColour = Color.gray;
 438       }
 439     }
 440
 441     /*
 442      * graduate brighter for point in front of centre, darker if behind centre
 443      */
 444     float zCentre = (seqMin[2] + seqMax[2]) / 2f;
 445     if (sp.coord.z > zCentre)
 446     {
 447       sequenceColour = ColorUtils.getGraduatedColour(sp.coord.z, 0,
 448               sequenceColour, seqMax[2], sequenceColour.brighter());
 449     }
 450     else if (sp.coord.z < zCentre)
 451     {
 452       sequenceColour = ColorUtils.getGraduatedColour(sp.coord.z, seqMin[2],
 453               sequenceColour.darker(), 0, sequenceColour);
 454     }
 455
 456     return sequenceColour;
 457   }
 458
 459   @Override
 460   public void keyTyped(KeyEvent evt)
 461   {
 462   }
 463
 464   @Override
 465   public void keyReleased(KeyEvent evt)
 466   {
 467   }
 468
 469   /**
 470    * Responds to up or down arrow key by zooming in or out, respectively
 471    *
 472    * @param evt
 473    */
 474   @Override
 475   public void keyPressed(KeyEvent evt)
 476   {
 477     int keyCode = evt.getKeyCode();
 478
 479     if (keyCode == KeyEvent.VK_UP)
 480     {
 481       zoom(ZOOM_IN);
 482     }
 483     else if (keyCode == KeyEvent.VK_DOWN)
 484     {
 485       zoom(ZOOM_OUT);
 486     }
 487     else if (evt.getKeyChar() == 's')
 488     {
 489       // Cache.log.warn("DEBUG: Rectangle selection");
 490       // todo not yet enabled as rectx2, recty2 are always -1
 491       // need to set them in mouseDragged; JAL-1124
 492       // if ((rectx2 != -1) && (recty2 != -1))
 493       // {
 494       // rectSelect(rectx1, recty1, rectx2, recty2);
 495       // }
 496     }
 497
 498     repaint();
 499   }
 500
 501   @Override
 502   public void zoom(float factor)
 503   {
 504     if (factor > 0f)
 505     {
 506       scaleFactor *= factor;
 507     }
 508   }
 509
 510   @Override
 511   public void mouseClicked(MouseEvent evt)
 512   {
 513   }
 514
 515   @Override
 516   public void mouseEntered(MouseEvent evt)
 517   {
 518   }
 519
 520   @Override
 521   public void mouseExited(MouseEvent evt)
 522   {
 523   }
 524
 525   @Override
 526   public void mouseReleased(MouseEvent evt)
 527   {
 528   }
 529
 530   /**
 531    * If the mouse press is at (within 2 pixels of) a sequence point, toggles
 532    * (adds or removes) the corresponding sequence as a member of the viewport
 533    * selection group. This supports configuring a group in the alignment by
 534    * clicking on points in the PCA display.
 535    */
 536   @Override
 537   public void mousePressed(MouseEvent evt)
 538   {
 539     int x = evt.getX();
 540     int y = evt.getY();
 541
 542     mouseX = x;
 543     mouseY = y;
 544
 545     // rectx1 = x;
 546     // recty1 = y;
 547     // rectx2 = -1;
 548     // recty2 = -1;
 549
 550     SequenceI found = findSequenceAtPoint(x, y);
 551
 552     if (found != null)
 553     {
 554       AlignmentPanel[] aps = getAssociatedPanels();
 555
 556       for (int a = 0; a < aps.length; a++)
 557       {
 558         if (aps[a].av.getSelectionGroup() != null)
 559         {
 560           aps[a].av.getSelectionGroup().addOrRemove(found, true);
 561         }
 562         else
 563         {
 564           aps[a].av.setSelectionGroup(new SequenceGroup());
 565           aps[a].av.getSelectionGroup().addOrRemove(found, true);
 566           aps[a].av.getSelectionGroup()
 567                   .setEndRes(aps[a].av.getAlignment().getWidth() - 1);
 568         }
 569       }
 570       PaintRefresher.Refresh(this, av.getSequenceSetId());
 571       // canonical selection is sent to other listeners
 572       av.sendSelection();
 573     }
 574
 575     repaint();
 576   }
 577
 578   /**
 579    * Sets the tooltip to the name of the sequence within 2 pixels of the mouse
 580    * position, or clears the tooltip if none found
 581    */
 582   @Override
 583   public void mouseMoved(MouseEvent evt)
 584   {
 585     SequenceI found = findSequenceAtPoint(evt.getX(), evt.getY());
 586
 587     this.setToolTipText(found == null ? null : found.getName());
 588   }
 589
 590   /**
 591    * Action handler for a mouse drag. Rotates the display around the X axis (for
 592    * up/down mouse movement) and/or the Y axis (for left/right mouse movement).
 593    *
 594    * @param evt
 595    */
 596   @Override
 597   public void mouseDragged(MouseEvent evt)
 598   {
 599     int xPos = evt.getX();
 600     int yPos = evt.getY();
 601
 602     if (xPos == mouseX && yPos == mouseY)
 603     {
 604       return;
 605     }
 606
 607     int xDelta = xPos - mouseX;
 608     int yDelta = yPos - mouseY;
 609
 610     // Check if this is a rectangle drawing drag
 611     if ((evt.getModifiers() & InputEvent.BUTTON2_MASK) != 0)
 612     {
 613       // rectx2 = evt.getX();
 614       // recty2 = evt.getY();
 615     }
 616     else
 617     {
 618       rotate(xDelta, yDelta);
 619
 620       mouseX = xPos;
 621       mouseY = yPos;
 622
 623       // findWidths();
 624
 625       repaint();
 626     }
 627   }
 628
 629   @Override
 630   public void rotate(float x, float y)
 631   {
 632     if (x == 0f && y == 0f)
 633     {
 634       return;
 635     }
 636
 637     /*
 638      * get the identity transformation...
 639      */
 640     RotatableMatrix rotmat = new RotatableMatrix();
 641
 642     /*
 643      * rotate around the X axis for change in Y
 644      * (mouse movement up/down); note we are equating a
 645      * number of pixels with degrees of rotation here!
 646      */
 647     if (y != 0)
 648     {
 649       rotmat.rotate(y, Axis.X);
 650     }
 651
 652     /*
 653      * rotate around the Y axis for change in X
 654      * (mouse movement left/right)
 655      */
 656     if (x != 0)
 657     {
 658       rotmat.rotate(x, Axis.Y);
 659     }
 660
 661     /*
 662      * apply the composite transformation to sequence points;
 663      * update z min-max range (affects colour graduation), but not
 664      * x or y min-max (as this would affect axis scaling)
 665      */
 666     float[] centre = getCentre();
 667     float zMin = Float.MAX_VALUE;
 668     float zMax = -Float.MAX_VALUE;
 669
 670     for (int i = 0; i < npoint; i++)
 671     {
 672       SequencePoint sp = sequencePoints.get(i);
 673       sp.translate(-centre[0], -centre[1], -centre[2]);
 674
 675       // Now apply the rotation matrix
 676       sp.coord = rotmat.vectorMultiply(sp.coord);
 677
 678       // Now translate back again
 679       sp.translate(centre[0], centre[1], centre[2]);
 680
 681       zMin = Math.min(zMin, sp.coord.z);
 682       zMax = Math.max(zMax, sp.coord.z);
 683     }
 684
 685     seqMin[2] = zMin;
 686     seqMax[2] = zMax;
 687
 688     /*
 689      * rotate the x/y/z axis positions
 690      */
 691     for (int i = 0; i < DIMS; i++)
 692     {
 693       axisEndPoints[i] = rotmat.vectorMultiply(axisEndPoints[i]);
 694     }
 695   }
 696
 697   /**
 698    * Answers the x/y/z coordinates that are midway between the maximum and
 699    * minimum sequence point values
 700    *
 701    * @return
 702    */
 703   private float[] getCentre()
 704   {
 705     float xCentre = (seqMin[0] + seqMax[0]) / 2f;
 706     float yCentre = (seqMin[1] + seqMax[1]) / 2f;
 707     float zCentre = (seqMin[2] + seqMax[2]) / 2f;
 708
 709     return new float[] { xCentre, yCentre, zCentre };
 710   }
 711
 712   /**
 713    * Adds any sequences whose displayed points are within the given rectangle to
 714    * the viewport's current selection. Intended for key 's' after dragging to
 715    * select a region of the PCA.
 716    *
 717    * @param x1
 718    * @param y1
 719    * @param x2
 720    * @param y2
 721    */
 722   protected void rectSelect(int x1, int y1, int x2, int y2)
 723   {
 724     float[] centre = getCentre();
 725
 726     for (int i = 0; i < npoint; i++)
 727     {
 728       SequencePoint sp = sequencePoints.get(i);
 729       int tmp1 = (int) (((sp.coord.x - centre[0]) * scaleFactor)
 730               + (getWidth() / 2.0));
 731       int tmp2 = (int) (((sp.coord.y - centre[1]) * scaleFactor)
 732               + (getHeight() / 2.0));
 733
 734       if ((tmp1 > x1) && (tmp1 < x2) && (tmp2 > y1) && (tmp2 < y2))
 735       {
 736         if (av != null)
 737         {
 738           SequenceI sequence = sp.getSequence();
 739           if (!av.getSelectionGroup().getSequences(null)
 740                   .contains(sequence))
 741           {
 742             av.getSelectionGroup().addSequence(sequence, true);
 743           }
 744         }
 745       }
 746     }
 747   }
 748
 749   /**
 750    * Answers the first sequence found whose point on the display is within 2
 751    * pixels of the given coordinates, or null if none is found
 752    *
 753    * @param x
 754    * @param y
 755    *
 756    * @return
 757    */
 758   protected SequenceI findSequenceAtPoint(int x, int y)
 759   {
 760     int halfwidth = getWidth() / 2;
 761     int halfheight = getHeight() / 2;
 762
 763     int found = -1;
 764     int pix = Math.min(getWidth(), getHeight());
 765     float xWidth = Math.abs(seqMax[0] - seqMin[0]);
 766     float yWidth = Math.abs(seqMax[1] - seqMin[1]);
 767     float maxWidth = Math.max(xWidth, yWidth);
 768     float scaleBy = pix * scaleFactor / (2f * maxWidth);
 769
 770     float[] centre = getCentre();
 771
 772     for (int i = 0; i < npoint; i++)
 773     {
 774       SequencePoint sp = sequencePoints.get(i);
 775       int px = (int) ((sp.coord.x - centre[0]) * scaleBy)
 776               + halfwidth;
 777       int py = (int) ((sp.coord.y - centre[1]) * scaleBy)
 778               + halfheight;
 779
 780       if ((Math.abs(px - x) < NEARBY) && (Math.abs(py - y) < NEARBY))
 781       {
 782         found = i;
 783         break;
 784       }
 785     }
 786
 787     if (found != -1)
 788     {
 789       return sequencePoints.get(found).getSequence();
 790     }
 791     else
 792     {
 793       return null;
 794     }
 795   }
 796
 797   /**
 798    * Answers the panel the PCA is associated with (all panels for this alignment
 799    * if 'associate with all panels' is selected).
 800    *
 801    * @return
 802    */
 803   AlignmentPanel[] getAssociatedPanels()
 804   {
 805     if (applyToAllViews)
 806     {
 807       return PaintRefresher.getAssociatedPanels(av.getSequenceSetId());
 808     }
 809     else
 810     {
 811       return new AlignmentPanel[] { ap };
 812     }
 813   }
 814
 815   public Color getBackgroundColour()
 816   {
 817     return bgColour;
 818   }
 819
 820   /**
 821    * Zooms in or out in response to mouse wheel movement
 822    */
 823   @Override
 824   public void mouseWheelMoved(MouseWheelEvent e)
 825   {
 826     double wheelRotation = e.getPreciseWheelRotation();
 827     if (wheelRotation > 0)
 828     {
 829       zoom(ZOOM_IN);
 830       repaint();
 831     }
 832     else if (wheelRotation < 0)
 833     {
 834       zoom(ZOOM_OUT);
 835       repaint();
 836     }
 837   }
 838
 839   /**
 840    * Answers the sequence point minimum [x, y, z] values. Note these are derived
 841    * when sequence points are set, but x and y values are not updated on
 842    * rotation (because this would result in changes to scaling).
 843    *
 844    * @return
 845    */
 846   public float[] getSeqMin()
 847   {
 848     return seqMin;
 849   }
 850
 851   /**
 852    * Answers the sequence point maximum [x, y, z] values. Note these are derived
 853    * when sequence points are set, but x and y values are not updated on
 854    * rotation (because this would result in changes to scaling).
 855    *
 856    * @return
 857    */
 858   public float[] getSeqMax()
 859   {
 860     return seqMax;
 861   }
 862
 863   /**
 864    * Sets the minimum and maximum [x, y, z] positions for sequence points. For
 865    * use when restoring a saved PCA from state data.
 866    *
 867    * @param min
 868    * @param max
 869    */
 870   public void setSeqMinMax(float[] min, float[] max)
 871   {
 872     seqMin = min;
 873     seqMax = max;
 874   }
 875 }