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.Annotation;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.renderer.seqfeatures.FeatureColourFinder;
  29 import jalview.renderer.seqfeatures.FeatureRenderer;
  30 import jalview.viewmodel.OverviewDimensions;
  31
  32 import java.awt.Color;
  33 import java.awt.Graphics;
  34 import java.awt.image.BufferedImage;
  35
  36 public class OverviewRenderer
  37 {
  38   private FeatureColourFinder finder;
  39
  40   private jalview.api.SequenceRenderer sr;
  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   public OverviewRenderer(jalview.api.SequenceRenderer seqRenderer,
  52           FeatureRenderer fr, OverviewDimensions od)
  53   // FeatureColourFinder colfinder, OverviewDimensions od)
  54   {
  55     sr = seqRenderer;
  56     finder = new FeatureColourFinder(fr); // colfinder;
  57
  58     pixelsPerCol = od.getPixelsPerCol();
  59     pixelsPerSeq = od.getPixelsPerSeq();
  60     miniMe = new BufferedImage(od.getWidth(), od.getHeight(),
  61             BufferedImage.TYPE_INT_RGB);
  62   }
  63
  64   /**
  65    * Draw alignment rows and columns onto an image
  66    *
  67    * @param rit
  68    *          Iterator over rows to be drawn
  69    * @param cit
  70    *          Iterator over columns to be drawn
  71    * @return image containing the drawing
  72    */
  73   public BufferedImage draw(AlignmentRowsCollectionI rows,
  74           AlignmentColsCollectionI cols)
  75   {
  76     int rgbcolor = Color.white.getRGB();
  77     int seqIndex = 0;
  78     int pixelRow = 0;
  79     for (int alignmentRow : rows)
  80     {
  81       // get details of this alignment row
  82       boolean hidden = rows.isHidden(alignmentRow);
  83       SequenceI seq = rows.getSequence(alignmentRow);
  84
  85       // calculate where this row extends to in pixels
  86       int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1,
  87               miniMe.getHeight() - 1);
  88
  89       int colIndex = 0;
  90       int pixelCol = 0;
  91       for (int alignmentCol : cols)
  92       {
  93         // calculate where this column extends to in pixels
  94         int endCol = Math.min(
  95                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
  96                 miniMe.getWidth() - 1);
  97
  98         // determine the colour based on the sequence and column position
  99         rgbcolor = getColumnColourFromSequence(seq,
 100                 hidden || cols.isHidden(alignmentCol), alignmentCol, finder);
 101
 102         // fill in the appropriate number of pixels
 103         for (int row = pixelRow; row <= endRow; ++row)
 104         {
 105           for (int col = pixelCol; col <= endCol; ++col)
 106           {
 107             miniMe.setRGB(col, row, rgbcolor);
 108           }
 109         }
 110
 111         pixelCol = endCol + 1;
 112         colIndex++;
 113       }
 114       pixelRow = endRow + 1;
 115       seqIndex++;
 116     }
 117     return miniMe;
 118   }
 119
 120   /*
 121    * Find the colour of a sequence at a specified column position
 122    */
 123   private int getColumnColourFromSequence(jalview.datamodel.SequenceI seq,
 124           boolean isHidden, int lastcol, FeatureColourFinder fcfinder)
 125   {
 126     Color color = Color.white;
 127
 128     if ((seq != null) && (seq.getLength() > lastcol))
 129     {
 130       color = sr.getResidueColour(seq, lastcol, fcfinder);
 131     }
 132
 133     if (isHidden)
 134     {
 135       color = color.darker().darker();
 136     }
 137
 138     return color.getRGB();
 139   }
 140
 141   /**
 142    * Draw the alignment annotation in the overview panel
 143    *
 144    * @param g
 145    *          the graphics object to draw on
 146    * @param anno
 147    *          alignment annotation information
 148    * @param charWidth
 149    *          alignment character width value
 150    * @param y
 151    *          y-position for the annotation graph
 152    * @param cols
 153    *          the collection of columns used in the overview panel
 154    */
 155   public void drawGraph(Graphics g, AlignmentAnnotation anno, int charWidth,
 156           int y, AlignmentColsCollectionI cols)
 157   {
 158     Annotation[] annotations = anno.annotations;
 159     g.setColor(Color.white);
 160     g.fillRect(0, 0, miniMe.getWidth(), y);
 161
 162     int height;
 163     int colIndex = 0;
 164     int pixelCol = 0;
 165     for (int alignmentCol : cols)
 166     {
 167       if (alignmentCol >= annotations.length)
 168       {
 169         break; // no more annotations to draw here
 170       }
 171       else
 172       {
 173         int endCol = Math.min(
 174                 Math.round((colIndex + 1) * pixelsPerCol) - 1,
 175                 miniMe.getWidth() - 1);
 176
 177         if (annotations[alignmentCol] != null)
 178         {
 179           if (annotations[alignmentCol].colour == null)
 180           {
 181             g.setColor(Color.black);
 182           }
 183           else
 184           {
 185             g.setColor(annotations[alignmentCol].colour);
 186           }
 187
 188           height = (int) ((annotations[alignmentCol].value / anno.graphMax) * y);
 189           if (height > y)
 190           {
 191             height = y;
 192           }
 193
 194           g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height);
 195         }
 196         pixelCol = endCol + 1;
 197         colIndex++;
 198       }
 199     }
 200   }
 201 }