X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Frenderer%2FOverviewRenderer.java;h=1b5d5da4bb677d3f4ba3584ef1227f3a400958f4;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=607988f4b4f6ea6845433b966b66bca89a46cd84;hpb=aebfd3e1071a70f850b5ef051f9c70bd5e027706;p=jalview.git diff --git a/src/jalview/renderer/OverviewRenderer.java b/src/jalview/renderer/OverviewRenderer.java index 607988f..1b5d5da 100644 --- a/src/jalview/renderer/OverviewRenderer.java +++ b/src/jalview/renderer/OverviewRenderer.java @@ -22,6 +22,7 @@ package jalview.renderer; import jalview.api.AlignmentColsCollectionI; import jalview.api.AlignmentRowsCollectionI; +import jalview.api.RendererListenerI; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; import jalview.datamodel.Annotation; @@ -31,12 +32,25 @@ import jalview.renderer.seqfeatures.FeatureColourFinder; import jalview.renderer.seqfeatures.FeatureRenderer; import jalview.viewmodel.OverviewDimensions; +import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Graphics; +import java.awt.Graphics2D; import java.awt.image.BufferedImage; +import java.beans.PropertyChangeSupport; public class OverviewRenderer { + // transparency of hidden cols/seqs overlay + private final float TRANSPARENCY = 0.5f; + + public static final String UPDATE = "OverviewUpdate"; + + private static final int MAX_PROGRESS = 100; + + private PropertyChangeSupport changeSupport = new PropertyChangeSupport( + this); + private FeatureColourFinder finder; // image to render on @@ -48,6 +62,9 @@ public class OverviewRenderer // raw number of pixels to allocate to each row private float pixelsPerSeq; + // height in pixels of graph + private int graphHeight; + // flag to indicate whether to halt drawing private volatile boolean redraw = false; @@ -56,20 +73,21 @@ public class OverviewRenderer private ResidueShaderI shader; - private ResidueColourFinder resColFinder; + private OverviewResColourFinder resColFinder; public OverviewRenderer(FeatureRenderer fr, OverviewDimensions od, - AlignmentI alignment, - ResidueShaderI resshader) + AlignmentI alignment, ResidueShaderI resshader, + OverviewResColourFinder colFinder) { finder = new FeatureColourFinder(fr); - resColFinder = new OverviewResColourFinder(); + resColFinder = colFinder; al = alignment; shader = resshader; pixelsPerCol = od.getPixelsPerCol(); pixelsPerSeq = od.getPixelsPerSeq(); + graphHeight = od.getGraphHeight(); miniMe = new BufferedImage(od.getWidth(), od.getHeight(), BufferedImage.TYPE_INT_RGB); } @@ -89,6 +107,12 @@ public class OverviewRenderer int rgbcolor = Color.white.getRGB(); int seqIndex = 0; int pixelRow = 0; + int alignmentHeight = miniMe.getHeight() - graphHeight; + int totalPixels = miniMe.getWidth() * alignmentHeight; + + int lastRowUpdate = 0; + int lastUpdate = 0; + changeSupport.firePropertyChange(UPDATE, -1, 0); for (int alignmentRow : rows) { @@ -98,8 +122,8 @@ public class OverviewRenderer } // get details of this alignment row - boolean hidden = rows.isHidden(alignmentRow); SequenceI seq = rows.getSequence(alignmentRow); + // rate limiting step when rendering overview for lots of groups SequenceGroup[] allGroups = al.findAllGroups(seq); @@ -117,8 +141,7 @@ public class OverviewRenderer } // calculate where this column extends to in pixels - int endCol = Math.min( - Math.round((colIndex + 1) * pixelsPerCol) - 1, + int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1, miniMe.getWidth() - 1); // don't do expensive colour determination if we're not going to use it @@ -126,10 +149,8 @@ public class OverviewRenderer // panel if (pixelCol <= endCol) { - // determine the colour based on the sequence and column position rgbcolor = getColumnColourFromSequence(allGroups, seq, - hidden || cols.isHidden(alignmentCol), alignmentCol, - finder); + alignmentCol); // fill in the appropriate number of pixels for (int row = pixelRow; row <= endRow; ++row) @@ -140,38 +161,189 @@ public class OverviewRenderer } } + // store last update value + lastUpdate = sendProgressUpdate( + (pixelCol + 1) * (endRow - pixelRow), totalPixels, + lastRowUpdate, lastUpdate); + pixelCol = endCol + 1; } colIndex++; } - pixelRow = endRow + 1; + + if (pixelRow != endRow + 1) + { + // store row offset and last update value + lastRowUpdate = sendProgressUpdate(endRow + 1, alignmentHeight, 0, + lastUpdate); + lastUpdate = lastRowUpdate; + pixelRow = endRow + 1; + } seqIndex++; } + + overlayHiddenRegions(rows, cols); + // final update to progress bar if present + if (redraw) + { + sendProgressUpdate(pixelRow - 1, alignmentHeight, 0, 0); + } + else + { + sendProgressUpdate(alignmentHeight, miniMe.getHeight(), 0, 0); + } return miniMe; } /* - * Find the colour of a sequence at a specified column position + * Calculate progress update value and fire event + * @param rowOffset number of rows to offset calculation by + * @return new rowOffset - return value only to be used when at end of a row + */ + private int sendProgressUpdate(int position, int maximum, int rowOffset, + int lastUpdate) + { + int newUpdate = rowOffset + + Math.round(MAX_PROGRESS * ((float) position / maximum)); + if (newUpdate > lastUpdate) + { + changeSupport.firePropertyChange(UPDATE, rowOffset, newUpdate); + return newUpdate; + } + return newUpdate; + } + + /* + * Find the RGB value of the colour of a sequence at a specified column position + * + * @param seq + * sequence to get colour for + * @param lastcol + * column position to get colour for + * @return colour of sequence at this position, as RGB */ - private int getColumnColourFromSequence(SequenceGroup[] allGroups, - jalview.datamodel.SequenceI seq, - boolean isHidden, int lastcol, FeatureColourFinder fcfinder) + int getColumnColourFromSequence(SequenceGroup[] allGroups, SequenceI seq, + int lastcol) { - Color color = Color.white; + Color color = resColFinder.GAP_COLOUR; if ((seq != null) && (seq.getLength() > lastcol)) { color = resColFinder.getResidueColour(true, shader, allGroups, seq, - lastcol, - fcfinder); + lastcol, finder); } - if (isHidden) + return color.getRGB(); + } + + /** + * Overlay the hidden regions on the overview image + * + * @param rows + * collection of rows the overview is built over + * @param cols + * collection of columns the overview is built over + */ + private void overlayHiddenRegions(AlignmentRowsCollectionI rows, + AlignmentColsCollectionI cols) + { + if (cols.hasHidden() || rows.hasHidden()) { - color = color.darker().darker(); + BufferedImage mask = buildHiddenImage(rows, cols, miniMe.getWidth(), + miniMe.getHeight()); + + Graphics2D g = (Graphics2D) miniMe.getGraphics(); + g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, + TRANSPARENCY)); + g.drawImage(mask, 0, 0, miniMe.getWidth(), miniMe.getHeight(), null); } + } - return color.getRGB(); + /** + * Build a masking image of hidden columns and rows to be applied on top of + * the main overview image. + * + * @param rows + * collection of rows the overview is built over + * @param cols + * collection of columns the overview is built over + * @param width + * width of overview in pixels + * @param height + * height of overview in pixels + * @return BufferedImage containing mask of hidden regions + */ + private BufferedImage buildHiddenImage(AlignmentRowsCollectionI rows, + AlignmentColsCollectionI cols, int width, int height) + { + // new masking image + BufferedImage hiddenImage = new BufferedImage(width, height, + BufferedImage.TYPE_INT_ARGB); + + int colIndex = 0; + int pixelCol = 0; + + Color hidden = resColFinder.getHiddenColour(); + + Graphics2D g2d = (Graphics2D) hiddenImage.getGraphics(); + + // set background to transparent + // g2d.setComposite(AlphaComposite.Clear); + // g2d.fillRect(0, 0, width, height); + + // set next colour to opaque + g2d.setComposite(AlphaComposite.Src); + + for (int alignmentCol : cols) + { + if (redraw) + { + break; + } + + // calculate where this column extends to in pixels + int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1, + hiddenImage.getWidth() - 1); + + if (pixelCol <= endCol) + { + // determine the colour based on the sequence and column position + if (cols.isHidden(alignmentCol)) + { + g2d.setColor(hidden); + g2d.fillRect(pixelCol, 0, endCol - pixelCol + 1, height); + } + + pixelCol = endCol + 1; + } + colIndex++; + + } + + int seqIndex = 0; + int pixelRow = 0; + for (int alignmentRow : rows) + { + if (redraw) + { + break; + } + + // calculate where this row extends to in pixels + int endRow = Math.min(Math.round((seqIndex + 1) * pixelsPerSeq) - 1, + miniMe.getHeight() - 1); + + // get details of this alignment row + if (rows.isHidden(alignmentRow)) + { + g2d.setColor(hidden); + g2d.fillRect(0, pixelRow, width, endRow - pixelRow + 1); + } + pixelRow = endRow + 1; + seqIndex++; + } + + return hiddenImage; } /** @@ -181,15 +353,13 @@ public class OverviewRenderer * the graphics object to draw on * @param anno * alignment annotation information - * @param charWidth - * alignment character width value * @param y * y-position for the annotation graph * @param cols * the collection of columns used in the overview panel */ - public void drawGraph(Graphics g, AlignmentAnnotation anno, int charWidth, - int y, AlignmentColsCollectionI cols) + public void drawGraph(Graphics g, AlignmentAnnotation anno, int y, + AlignmentColsCollectionI cols) { Annotation[] annotations = anno.annotations; g.setColor(Color.white); @@ -202,16 +372,17 @@ public class OverviewRenderer { if (redraw) { + changeSupport.firePropertyChange(UPDATE, MAX_PROGRESS - 1, 0); break; } + if (alignmentCol >= annotations.length) { break; // no more annotations to draw here } else { - int endCol = Math.min( - Math.round((colIndex + 1) * pixelsPerCol) - 1, + int endCol = Math.min(Math.round((colIndex + 1) * pixelsPerCol) - 1, miniMe.getWidth() - 1); if (annotations[alignmentCol] != null) @@ -225,7 +396,8 @@ public class OverviewRenderer g.setColor(annotations[alignmentCol].colour); } - height = (int) ((annotations[alignmentCol].value / anno.graphMax) * y); + height = (int) ((annotations[alignmentCol].value / anno.graphMax) + * y); if (height > y) { height = y; @@ -233,12 +405,22 @@ public class OverviewRenderer g.fillRect(pixelCol, y - height, endCol - pixelCol + 1, height); } + pixelCol = endCol + 1; colIndex++; } } + changeSupport.firePropertyChange(UPDATE, MAX_PROGRESS - 1, + MAX_PROGRESS); } + /** + * Allows redraw flag to be set + * + * @param b + * value to set redraw to: true = redraw is occurring, false = no + * redraw + */ public void setRedraw(boolean b) { synchronized (this) @@ -246,4 +428,14 @@ public class OverviewRenderer redraw = b; } } + + public void addPropertyChangeListener(RendererListenerI listener) + { + changeSupport.addPropertyChangeListener(listener); + } + + public void removePropertyChangeListener(RendererListenerI listener) + { + changeSupport.removePropertyChangeListener(listener); + } }