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.datamodel.AlignmentAnnotation;
  26 import jalview.datamodel.AlignmentI;
  27 import jalview.datamodel.Annotation;
  28 import jalview.datamodel.SequenceGroup;
  29 import jalview.datamodel.SequenceI;
  30 import jalview.renderer.seqfeatures.FeatureColourFinder;
  31 import jalview.renderer.seqfeatures.FeatureRenderer;
  32 import jalview.viewmodel.OverviewDimensions;
  33
  34 import java.awt.Color;
  35 import java.awt.Graphics;
  36 import java.awt.image.BufferedImage;
  37
  38 public class OverviewRenderer
  39 {
  40   private FeatureColourFinder finder;
  41
  42   // image to render on
  43   private BufferedImage miniMe;
  44
  45   // raw number of pixels to allocate to each column
  46   private float pixelsPerCol;
  47
  48   // raw number of pixels to allocate to each row
  49   private float pixelsPerSeq;
  50
  51   // flag to indicate whether to halt drawing
  52   private volatile boolean redraw = false;
  53
  54   // reference to alignment, needed to get sequence groups
  55   private AlignmentI al;
  56
  57   private ResidueShaderI shader;
  58
  59   private ResidueColourFinder resColFinder;
  60
  61   public OverviewRenderer(FeatureRenderer fr, OverviewDimensions od,
  62           AlignmentI alignment,
  63           ResidueShaderI resshader)
  64   {
  65     finder = new FeatureColourFinder(fr);
  66     resColFinder = new OverviewResColourFinder();
  67
  68     al = alignment;
  69     shader = resshader;
  70
  71     pixelsPerCol = od.getPixelsPerCol();
  72     pixelsPerSeq = od.getPixelsPerSeq();
  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
  93     for (int alignmentRow : rows)
  94     {
  95       if (redraw)
  96       {
  97         break;
  98       }
  99
 100       // get details of this alignment row
 101       boolean hidden = rows.isHidden(alignmentRow);
 102       SequenceI seq = rows.getSequence(alignmentRow);
 103       // rate limiting step when rendering overview for lots of groups
 104       SequenceGroup[] allGroups = al.findAllGroups(seq);
 105
 106       // calculate where this row extends to in pixels
 107       int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
 108               miniMe.getHeight() - 1);
 109
 110       int colIndex = 0;
 111       int pixelCol = 0;
 112       for (int alignmentCol : cols)
 113       {
 114         if (redraw)
 115         {
 116           break;
 117         }
 118
 119         // calculate where this column extends to in pixels
 120         int endCol = Math.min(
 121                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 122                 miniMe.getWidth() - 1);
 123
 124         // don't do expensive colour determination if we're not going to use it
 125         // NB this is important to avoid performance issues in the overview
 126         // panel
 127         if (pixelCol <= endCol)
 128         {
 129           // determine the colour based on the sequence and column position
 130           rgbcolor = getColumnColourFromSequence(allGroups, seq,
 131                   hidden || cols.isHidden(alignmentCol), alignmentCol,
 132                   finder);
 133
 134           // fill in the appropriate number of pixels
 135           for (int row = pixelRow; row <= endRow; ++row)
 136           {
 137             for (int col = pixelCol; col <= endCol; ++col)
 138             {
 139               miniMe.setRGB(col, row, rgbcolor);
 140             }
 141           }
 142
 143           pixelCol = endCol + 1;
 144         }
 145         colIndex++;
 146       }
 147       pixelRow = endRow + 1;
 148       seqIndex++;
 149     }
 150     return miniMe;
 151   }
 152
 153   /*
 154    * Find the colour of a sequence at a specified column position
 155    */
 156   private int getColumnColourFromSequence(SequenceGroup[] allGroups,
 157           jalview.datamodel.SequenceI seq,
 158           boolean isHidden, int lastcol, FeatureColourFinder fcfinder)
 159   {
 160     Color color = Color.white;
 161
 162     if ((seq != null) && (seq.getLength() > lastcol))
 163     {
 164       color = resColFinder.getResidueColour(true, shader, allGroups, seq,
 165               lastcol,
 166               fcfinder);
 167     }
 168
 169     if (isHidden)
 170     {
 171       color = color.darker().darker();
 172     }
 173
 174     return color.getRGB();
 175   }
 176
 177   /**
 178    * Draw the alignment annotation in the overview panel
 179    *
 180    * @param g
 181    *          the graphics object to draw on
 182    * @param anno
 183    *          alignment annotation information
 184    * @param charWidth
 185    *          alignment character width value
 186    * @param y
 187    *          y-position for the annotation graph
 188    * @param cols
 189    *          the collection of columns used in the overview panel
 190    */
 191   public void drawGraph(Graphics g, AlignmentAnnotation anno, int charWidth,
 192           int y, AlignmentColsCollectionI cols)
 193   {
 194     Annotation[] annotations = anno.annotations;
 195     g.setColor(Color.white);
 196     g.fillRect(0, 0, miniMe.getWidth(), y);
 197
 198     int height;
 199     int colIndex = 0;
 200     int pixelCol = 0;
 201     for (int alignmentCol : cols)
 202     {
 203       if (redraw)
 204       {
 205         break;
 206       }
 207       if (alignmentCol >= annotations.length)
 208       {
 209         break; // no more annotations to draw here
 210       }
 211       else
 212       {
 213         int endCol = Math.min(
 214                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 215                 miniMe.getWidth() - 1);
 216
 217         if (annotations[alignmentCol] != null)
 218         {
 219           if (annotations[alignmentCol].colour == null)
 220           {
 221             g.setColor(Color.black);
 222           }
 223           else
 224           {
 225             g.setColor(annotations[alignmentCol].colour);
 226           }
 227
 228           height = (int) ((annotations[alignmentCol].value / anno.graphMax) * y);
 229           if (height > y)
 230           {
 231             height = y;
 232           }
 233
 234           g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height);
 235         }
 236         pixelCol = endCol + 1;
 237         colIndex++;
 238       }
 239     }
 240   }
 241
 242   public void setRedraw(boolean b)
 243   {
 244     synchronized (this)
 245     {
 246       redraw = b;
 247     }
 248   }
 249 }