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
 118           break;
 119         }
 120
 121         // calculate where this column extends to in pixels
 122         int endCol = Math.min(
 123                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 124                 miniMe.getWidth() - 1);
 125
 126         // don't do expensive colour determination if we're not going to use it
 127         // NB this is important to avoid performance issues in the overview
 128         // panel
 129         if (pixelCol <= endCol)
 130         {
 131           // determine the colour based on the sequence and column position
 132           rgbcolor = getColumnColourFromSequence(seq,
 133                   hidden || cols.isHidden(alignmentCol), alignmentCol,
 134                   finder);
 135
 136           // fill in the appropriate number of pixels
 137           for (int row = pixelRow; row <= endRow; ++row)
 138           {
 139             for (int col = pixelCol; col <= endCol; ++col)
 140             {
 141               miniMe.setRGB(col, row, rgbcolor);
 142             }
 143           }
 144
 145           pixelCol = endCol + 1;
 146         }
 147         colIndex++;
 148       }
 149
 150       if (pixelRow != endRow + 1)
 151       {
 152         changeSupport.firePropertyChange(UPDATE,
 153                 Math.round(100 * (float) pixelRow / alignmentHeight),
 154                 Math.round(
 155                         100 * ((float) (endRow + 1) / alignmentHeight)));
 156         pixelRow = endRow + 1;
 157       }
 158       seqIndex++;
 159     }
 160
 161     // final update to progress bar if present
 162     if (redraw)
 163     {
 164       changeSupport.firePropertyChange(UPDATE,
 165               Math.round(100 * (float) (pixelRow - 1) / alignmentHeight),
 166               0);
 167     }
 168     else
 169     {
 170       changeSupport.firePropertyChange(UPDATE,
 171               Math.round(100 * alignmentHeight / miniMe.getHeight() - 1),
 172               Math.round(100 * alignmentHeight / miniMe.getHeight()));
 173     }
 174     return miniMe;
 175   }
 176
 177   /*
 178    * Find the colour of a sequence at a specified column position
 179    */
 180   private int getColumnColourFromSequence(jalview.datamodel.SequenceI seq,
 181           boolean isHidden, int lastcol, FeatureColourFinder fcfinder)
 182   {
 183     Color color = Color.white;
 184
 185     if ((seq != null) && (seq.getLength() > lastcol))
 186     {
 187       color = sr.getResidueColour(seq, lastcol, fcfinder);
 188     }
 189
 190     if (isHidden)
 191     {
 192       color = color.darker().darker();
 193     }
 194
 195     return color.getRGB();
 196   }
 197
 198   /**
 199    * Draw the alignment annotation in the overview panel
 200    *
 201    * @param g
 202    *          the graphics object to draw on
 203    * @param anno
 204    *          alignment annotation information
 205    * @param charWidth
 206    *          alignment character width value
 207    * @param y
 208    *          y-position for the annotation graph
 209    * @param cols
 210    *          the collection of columns used in the overview panel
 211    */
 212   public void drawGraph(Graphics g, AlignmentAnnotation anno, int charWidth,
 213           int y, AlignmentColsCollectionI cols)
 214   {
 215     Annotation[] annotations = anno.annotations;
 216     g.setColor(Color.white);
 217     g.fillRect(0, 0, miniMe.getWidth(), y);
 218
 219     int height;
 220     int colIndex = 0;
 221     int pixelCol = 0;
 222     for (int alignmentCol : cols)
 223     {
 224       if (redraw)
 225       {
 226         changeSupport.firePropertyChange(UPDATE, 99, 0);
 227         break;
 228       }
 229
 230       if (alignmentCol >= annotations.length)
 231       {
 232         break; // no more annotations to draw here
 233       }
 234       else
 235       {
 236         int endCol = Math.min(
 237                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 238                 miniMe.getWidth() - 1);
 239
 240         if (annotations[alignmentCol] != null)
 241         {
 242           if (annotations[alignmentCol].colour == null)
 243           {
 244             g.setColor(Color.black);
 245           }
 246           else
 247           {
 248             g.setColor(annotations[alignmentCol].colour);
 249           }
 250
 251           height = (int) ((annotations[alignmentCol].value / anno.graphMax) * y);
 252           if (height > y)
 253           {
 254             height = y;
 255           }
 256
 257           g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height);
 258         }
 259         pixelCol = endCol + 1;
 260         colIndex++;
 261       }
 262     }
 263     changeSupport.firePropertyChange(UPDATE, 99, 100);
 264   }
 265
 266   public void setRedraw(boolean b)
 267   {
 268     synchronized (this)
 269     {
 270       redraw = b;
 271     }
 272   }
 273
 274   public void addPropertyChangeListener(RendererListenerI listener)
 275   {
 276     changeSupport.addPropertyChangeListener(listener);
 277   }
 278
 279   public void removePropertyChangeListener(RendererListenerI listener)
 280   {
 281     changeSupport.removePropertyChangeListener(listener);
 282   }
 283 }