src/jalview/renderer/OverviewRenderer.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.renderer;
  22
  23 import jalview.api.AlignmentColsCollectionI;
  24 import jalview.api.AlignmentRowsCollectionI;
  25 import jalview.api.RendererListenerI;
  26 import jalview.datamodel.AlignmentAnnotation;
  27 import jalview.datamodel.Annotation;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.renderer.seqfeatures.FeatureColourFinder;
  30 import jalview.renderer.seqfeatures.FeatureRenderer;
  31 import jalview.viewmodel.OverviewDimensions;
  32
  33 import java.awt.Color;
  34 import java.awt.Graphics;
  35 import java.awt.image.BufferedImage;
  36 import java.beans.PropertyChangeSupport;
  37
  38 public class OverviewRenderer
  39 {
  40   public static final String UPDATE = "OverviewUpdate";
  41
  42   protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
  43           this);
  44
  45   private FeatureColourFinder finder;
  46
  47   private jalview.api.SequenceRenderer sr;
  48
  49   // image to render on
  50   private BufferedImage miniMe;
  51
  52   // raw number of pixels to allocate to each column
  53   private float pixelsPerCol;
  54
  55   // raw number of pixels to allocate to each row
  56   private float pixelsPerSeq;
  57
  58   // height in pixels of graph
  59   private int graphHeight;
  60
  61   // flag to indicate whether to halt drawing
  62   private volatile boolean redraw = false;
  63
  64   public OverviewRenderer(jalview.api.SequenceRenderer seqRenderer,
  65           FeatureRenderer fr, OverviewDimensions od)
  66   {
  67     sr = seqRenderer;
  68     finder = new FeatureColourFinder(fr);
  69
  70     pixelsPerCol = od.getPixelsPerCol();
  71     pixelsPerSeq = od.getPixelsPerSeq();
  72     graphHeight = od.getGraphHeight();
  73     miniMe = new BufferedImage(od.getWidth(), od.getHeight(),
  74             BufferedImage.TYPE_INT_RGB);
  75   }
  76
  77   /**
  78    * Draw alignment rows and columns onto an image
  79    *
  80    * @param rit
  81    *          Iterator over rows to be drawn
  82    * @param cit
  83    *          Iterator over columns to be drawn
  84    * @return image containing the drawing
  85    */
  86   public BufferedImage draw(AlignmentRowsCollectionI rows,
  87           AlignmentColsCollectionI cols)
  88   {
  89     int rgbcolor = Color.white.getRGB();
  90     int seqIndex = 0;
  91     int pixelRow = 0;
  92     int alignmentHeight = miniMe.getHeight() - graphHeight;
  93
  94     changeSupport.firePropertyChange(UPDATE, -1, 0);
  95
  96     for (int alignmentRow : rows)
  97     {
  98       if (redraw)
  99       {
 100         break;
 101       }
 102
 103       // get details of this alignment row
 104       boolean hidden = rows.isHidden(alignmentRow);
 105       SequenceI seq = rows.getSequence(alignmentRow);
 106
 107       // calculate where this row extends to in pixels
 108       int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
 109               miniMe.getHeight() - 1);
 110
 111       int colIndex = 0;
 112       int pixelCol = 0;
 113       for (int alignmentCol : cols)
 114       {
 115         if (redraw)
 116         {
 117           break;
 118         }
 119
 120         // calculate where this column extends to in pixels
 121         int endCol = Math.min(
 122                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 123                 miniMe.getWidth() - 1);
 124
 125         // don't do expensive colour determination if we're not going to use it
 126         // NB this is important to avoid performance issues in the overview
 127         // panel
 128         if (pixelCol <= endCol)
 129         {
 130           // determine the colour based on the sequence and column position
 131           rgbcolor = getColumnColourFromSequence(seq,
 132                   hidden || cols.isHidden(alignmentCol), alignmentCol,
 133                   finder);
 134
 135           // fill in the appropriate number of pixels
 136           for (int row = pixelRow; row <= endRow; ++row)
 137           {
 138             for (int col = pixelCol; col <= endCol; ++col)
 139             {
 140               miniMe.setRGB(col, row, rgbcolor);
 141             }
 142           }
 143
 144           pixelCol = endCol + 1;
 145         }
 146         colIndex++;
 147       }
 148
 149       if (pixelRow != endRow + 1)
 150       {
 151         changeSupport.firePropertyChange(UPDATE,
 152                 Math.round(100 * (float) pixelRow / alignmentHeight),
 153                 Math.round(
 154                         100 * ((float) (endRow + 1) / alignmentHeight)));
 155         pixelRow = endRow + 1;
 156       }
 157       seqIndex++;
 158     }
 159
 160     // final update to progress bar if present
 161     if (redraw)
 162     {
 163       changeSupport.firePropertyChange(UPDATE,
 164               Math.round(100 * (float) (pixelRow - 1) / alignmentHeight),
 165               0);
 166     }
 167     else
 168     {
 169       changeSupport.firePropertyChange(UPDATE,
 170               Math.round(100 * alignmentHeight / miniMe.getHeight() - 1),
 171               Math.round(100 * alignmentHeight / miniMe.getHeight()));
 172     }
 173     return miniMe;
 174   }
 175
 176   /*
 177    * Find the colour of a sequence at a specified column position
 178    */
 179   private int getColumnColourFromSequence(jalview.datamodel.SequenceI seq,
 180           boolean isHidden, int lastcol, FeatureColourFinder fcfinder)
 181   {
 182     Color color = Color.white;
 183
 184     if ((seq != null) && (seq.getLength() > lastcol))
 185     {
 186       color = sr.getResidueColour(seq, lastcol, fcfinder);
 187     }
 188
 189     if (isHidden)
 190     {
 191       color = color.darker().darker();
 192     }
 193
 194     return color.getRGB();
 195   }
 196
 197   /**
 198    * Draw the alignment annotation in the overview panel
 199    *
 200    * @param g
 201    *          the graphics object to draw on
 202    * @param anno
 203    *          alignment annotation information
 204    * @param charWidth
 205    *          alignment character width value
 206    * @param y
 207    *          y-position for the annotation graph
 208    * @param cols
 209    *          the collection of columns used in the overview panel
 210    */
 211   public void drawGraph(Graphics g, AlignmentAnnotation anno, int charWidth,
 212           int y, AlignmentColsCollectionI cols)
 213   {
 214     Annotation[] annotations = anno.annotations;
 215     g.setColor(Color.white);
 216     g.fillRect(0, 0, miniMe.getWidth(), y);
 217
 218     int height;
 219     int colIndex = 0;
 220     int pixelCol = 0;
 221     for (int alignmentCol : cols)
 222     {
 223       if (redraw)
 224       {
 225         changeSupport.firePropertyChange(UPDATE, 99, 0);
 226         break;
 227       }
 228
 229       if (alignmentCol >= annotations.length)
 230       {
 231         break; // no more annotations to draw here
 232       }
 233       else
 234       {
 235         int endCol = Math.min(
 236                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 237                 miniMe.getWidth() - 1);
 238
 239         if (annotations[alignmentCol] != null)
 240         {
 241           if (annotations[alignmentCol].colour == null)
 242           {
 243             g.setColor(Color.black);
 244           }
 245           else
 246           {
 247             g.setColor(annotations[alignmentCol].colour);
 248           }
 249
 250           height = (int) ((annotations[alignmentCol].value / anno.graphMax) * y);
 251           if (height > y)
 252           {
 253             height = y;
 254           }
 255
 256           g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height);
 257         }
 258         pixelCol = endCol + 1;
 259         colIndex++;
 260       }
 261     }
 262     changeSupport.firePropertyChange(UPDATE, 99, 100);
 263   }
 264
 265   public void setRedraw(boolean b)
 266   {
 267     synchronized (this)
 268     {
 269       redraw = b;
 270     }
 271   }
 272
 273   public void addPropertyChangeListener(RendererListenerI listener)
 274   {
 275     changeSupport.addPropertyChangeListener(listener);
 276   }
 277
 278   public void removePropertyChangeListener(RendererListenerI listener)
 279   {
 280     changeSupport.removePropertyChangeListener(listener);
 281   }
 282 }