X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Frenderer%2FAnnotationRenderer.java;h=524e29142e272464fe2c71c4f61c48904520d720;hb=efd301320c3bd89d126980f661e4a7dbfca8bbfe;hp=5b897726ed6f2a426edaf89d759b3eea372b4d34;hpb=be8b596f15d36db1a9aec20efd993a6aa44a863a;p=jalview.git diff --git a/src/jalview/renderer/AnnotationRenderer.java b/src/jalview/renderer/AnnotationRenderer.java index 5b89772..524e291 100644 --- a/src/jalview/renderer/AnnotationRenderer.java +++ b/src/jalview/renderer/AnnotationRenderer.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,14 +20,6 @@ */ package jalview.renderer; -import jalview.analysis.AAFrequency; -import jalview.analysis.StructureFrequency; -import jalview.api.AlignViewportI; -import jalview.datamodel.AlignmentAnnotation; -import jalview.datamodel.Annotation; -import jalview.datamodel.ColumnSelection; -import jalview.schemes.ColourSchemeI; - import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; @@ -35,94 +27,53 @@ import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; -import java.awt.font.LineMetrics; +import java.awt.RenderingHints; +import java.awt.Stroke; import java.awt.geom.AffineTransform; import java.awt.image.ImageObserver; import java.util.BitSet; +import java.util.Collections; +import java.util.HashMap; import java.util.Hashtable; +import java.util.List; +import java.util.Map; -import com.stevesoft.pat.Regex; +import org.jfree.graphics2d.svg.SVGGraphics2D; +import org.jibble.epsgraphics.EpsGraphics2D; + +import jalview.analysis.AAFrequency; +import jalview.analysis.CodingUtils; +import jalview.analysis.Rna; +import jalview.analysis.StructureFrequency; +import jalview.api.AlignViewportI; +import jalview.bin.Cache; +import jalview.bin.Console; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.Annotation; +import jalview.datamodel.ColumnSelection; +import jalview.datamodel.HiddenColumns; +import jalview.datamodel.ProfilesI; +import jalview.datamodel.annotations.AnnotationColouringI; +import jalview.renderer.api.AnnotationRendererFactoryI; +import jalview.renderer.api.AnnotationRowRendererI; +import jalview.schemes.ColourSchemeI; +import jalview.schemes.NucleotideColourScheme; +import jalview.schemes.ResidueProperties; +import jalview.schemes.ZappoColourScheme; +import jalview.util.Platform; public class AnnotationRenderer { - /** - * flag indicating if timing and redraw parameter info should be output - */ - private final boolean debugRedraw; + private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32 - public AnnotationRenderer() - { - this(false); - } + private static final int CHAR_A = 'A'; // 65 + + private static final int CHAR_Z = 'Z'; // 90 /** - * Create a new annotation Renderer - * - * @param debugRedraw - * flag indicating if timing and redraw parameter info should be - * output + * flag indicating if timing and redraw parameter info should be output */ - public AnnotationRenderer(boolean debugRedraw) - { - this.debugRedraw = debugRedraw; - } - - public void drawStemAnnot(Graphics g, Annotation[] row_annotations, - int lastSSX, int x, int y, int iconOffset, int startRes, - int column, boolean validRes, boolean validEnd) - { - g.setColor(STEM_COLOUR); - int sCol = (lastSSX / charWidth) + startRes; - int x1 = lastSSX; - int x2 = (x * charWidth); - Regex closeparen = new Regex("(\\))"); - - String dc = (column == 0 || row_annotations[column - 1] == null) ? "" - : row_annotations[column - 1].displayCharacter; - - boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null - || !dc.equals(row_annotations[sCol - 1].displayCharacter); - boolean diffdownstream = !validRes || !validEnd - || row_annotations[column] == null - || !dc.equals(row_annotations[column].displayCharacter); - // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream); - // If a closing base pair half of the stem, display a backward arrow - if (column > 0 && closeparen.search(dc)) - { - - if (diffupstream) - // if (validRes && column>1 && row_annotations[column-2]!=null && - // dc.equals(row_annotations[column-2].displayCharacter)) - { - g.fillPolygon(new int[] - { lastSSX + 5, lastSSX + 5, lastSSX }, new int[] - { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3); - x1 += 5; - } - if (diffdownstream) - { - x2 -= 1; - } - } - else - { - - // display a forward arrow - if (diffdownstream) - { - g.fillPolygon(new int[] - { x2 - 5, x2 - 5, x2 }, new int[] - { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3); - x2 -= 5; - } - if (diffupstream) - { - x1 += 1; - } - } - // draw arrow body - g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7); - } + private final boolean debugRedraw; private int charWidth, endRes, charHeight; @@ -130,21 +81,29 @@ public class AnnotationRenderer private FontMetrics fm; - private final boolean MAC = new jalview.util.Platform().isAMac(); + private final boolean USE_FILL_ROUND_RECT = Platform.isAMacAndNotJS(); boolean av_renderHistogram = true, av_renderProfile = true, av_normaliseProfile = false; - ColourSchemeI profcolour = null; + ResidueShaderI profcolour = null; private ColumnSelection columnSelection; - private Hashtable[] hconsensus; + private HiddenColumns hiddenColumns; + + private ProfilesI hconsensus; - private Hashtable[] hStrucConsensus; + private Hashtable[] complementConsensus; + + private Hashtable[] hStrucConsensus; private boolean av_ignoreGapsConsensus; + private boolean renderingVectors = false; + + private boolean glyphLineDrawn = false; + /** * attributes set from AwtRenderPanelI */ @@ -186,40 +145,199 @@ public class AnnotationRenderer */ private boolean canClip = false; - public void drawNotCanonicalAnnot(Graphics g, Color nonCanColor, + /** + * Property to set text antialiasing method + */ + private static final String TEXT_ANTIALIAS_METHOD = "TEXT_ANTIALIAS_METHOD"; + + private static final Object textAntialiasMethod; + + static + { + final String textAntialiasMethodPref = Cache + .getDefault(TEXT_ANTIALIAS_METHOD, "GASP"); + switch (textAntialiasMethodPref) + { + case "ON": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_ON; + break; + case "GASP": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP; + break; + case "LCD_HBGR": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR; + break; + case "LCD_HRGB": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB; + break; + case "LCD_VBGR": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR; + break; + case "LCD_VRGB": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB; + break; + case "OFF": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF; + break; + case "DEFAULT": + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT; + break; + default: + jalview.bin.Console.warn(TEXT_ANTIALIAS_METHOD + " value '" + + textAntialiasMethodPref + + "' not recognised, defaulting to 'GASP'. See https://docs.oracle.com/javase/8/docs/api/java/awt/RenderingHints.html#KEY_TEXT_ANTIALIASING"); + textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP; + } + } + + public AnnotationRenderer() + { + this(false); + } + + /** + * Create a new annotation Renderer + * + * @param debugRedraw + * flag indicating if timing and redraw parameter info should be + * output + */ + public AnnotationRenderer(boolean debugRedraw) + { + this.debugRedraw = debugRedraw; + } + + /** + * Remove any references and resources when this object is no longer required + */ + public void dispose() + { + hiddenColumns = null; + hconsensus = null; + complementConsensus = null; + hStrucConsensus = null; + fadedImage = null; + annotationPanel = null; + rendererFactoryI = null; + } + + void drawStemAnnot(Graphics g, Annotation[] row_annotations, int lastSSX, + int x, int y, int iconOffset, int startRes, int column, + boolean validRes, boolean validEnd) + { + int sCol = (lastSSX / charWidth) + + hiddenColumns.visibleToAbsoluteColumn(startRes); + int x1 = lastSSX; + int x2 = (x * charWidth); + + char dc = (column == 0 || row_annotations[column - 1] == null) ? ' ' + : row_annotations[column - 1].secondaryStructure; + + boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null + || dc != row_annotations[sCol - 1].secondaryStructure + || !validEnd; + boolean diffdownstream = !validRes || !validEnd + || row_annotations[column] == null + || dc != row_annotations[column].secondaryStructure; + + if (diffupstream || diffdownstream) + { + // draw glyphline under arrow + drawGlyphLine(g, lastSSX, x, y, iconOffset); + } + g.setColor(STEM_COLOUR); + + if (column > 0 && Rna.isClosingParenthesis(dc)) + { + if (diffupstream) + // if (validRes && column>1 && row_annotations[column-2]!=null && + // dc.equals(row_annotations[column-2].displayCharacter)) + { + /* + * if new annotation with a closing base pair half of the stem, + * display a backward arrow + */ + fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX }, + new int[] + { y + iconOffset + 1, y + 13 + iconOffset, + y + 7 + iconOffset }, + 3); + x1 += 5; + } + if (diffdownstream) + { + x2 -= 1; + } + } + else + { + // display a forward arrow + if (diffdownstream) + { + /* + * if annotation ending with an opeing base pair half of the stem, + * display a forward arrow + */ + fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 }, + new int[] + { y + iconOffset + 1, y + 13 + iconOffset, + y + 7 + iconOffset }, + 3); + x2 -= 5; + } + if (diffupstream) + { + x1 += 1; + } + } + // draw arrow body + unsetAntialias(g); + fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6); + } + + void drawNotCanonicalAnnot(Graphics g, Color nonCanColor, Annotation[] row_annotations, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd) { - // System.out.println(nonCanColor); + // Console.info(nonCanColor); - g.setColor(nonCanColor); - int sCol = (lastSSX / charWidth) + startRes; + int sCol = (lastSSX / charWidth) + + hiddenColumns.visibleToAbsoluteColumn(startRes); int x1 = lastSSX; int x2 = (x * charWidth); - Regex closeparen = new Regex("}|]|<|[a-z]"); String dc = (column == 0 || row_annotations[column - 1] == null) ? "" : row_annotations[column - 1].displayCharacter; boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null - || !dc.equals(row_annotations[sCol - 1].displayCharacter); + || !dc.equals(row_annotations[sCol - 1].displayCharacter) + || !validEnd; boolean diffdownstream = !validRes || !validEnd || row_annotations[column] == null || !dc.equals(row_annotations[column].displayCharacter); - // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream); + // Console.info("Column "+column+" diff up: + // "+diffupstream+" + // down:"+diffdownstream); // If a closing base pair half of the stem, display a backward arrow - if (column > 0 && closeparen.search(dc))// closeletter_b.search(dc)||closeletter_c.search(dc)||closeletter_d.search(dc)||closecrochet.search(dc)) - // ) + if (diffupstream || diffdownstream) + { + // draw glyphline under arrow + drawGlyphLine(g, lastSSX, x, y, iconOffset); + } + g.setColor(nonCanColor); + if (column > 0 && Rna.isClosingParenthesis(dc)) { if (diffupstream) // if (validRes && column>1 && row_annotations[column-2]!=null && // dc.equals(row_annotations[column-2].displayCharacter)) { - g.fillPolygon(new int[] - { lastSSX + 5, lastSSX + 5, lastSSX }, new int[] - { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3); + fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX }, + new int[] + { y + iconOffset + 1, y + 13 + iconOffset, + y + 7 + iconOffset }, + 3); x1 += 5; } if (diffdownstream) @@ -233,9 +351,11 @@ public class AnnotationRenderer // display a forward arrow if (diffdownstream) { - g.fillPolygon(new int[] - { x2 - 5, x2 - 5, x2 }, new int[] - { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3); + fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 }, + new int[] + { y + iconOffset + 1, y + 13 + iconOffset, + y + 7 + iconOffset }, + 3); x2 -= 5; } if (diffupstream) @@ -244,7 +364,8 @@ public class AnnotationRenderer } } // draw arrow body - g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7); + unsetAntialias(g); + fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6); } // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI @@ -276,54 +397,82 @@ public class AnnotationRenderer useClip = false; } + rendererFactoryI = AnnotationRendererFactory.getRendererFactory(); updateFromAlignViewport(av); } public void updateFromAlignViewport(AlignViewportI av) { charWidth = av.getCharWidth(); - endRes = av.getEndRes(); + endRes = av.getRanges().getEndRes(); charHeight = av.getCharHeight(); hasHiddenColumns = av.hasHiddenColumns(); validCharWidth = av.isValidCharWidth(); av_renderHistogram = av.isShowConsensusHistogram(); av_renderProfile = av.isShowSequenceLogo(); av_normaliseProfile = av.isNormaliseSequenceLogo(); - profcolour = av.getGlobalColourScheme(); - if (profcolour == null) + profcolour = av.getResidueShading(); + if (profcolour == null || profcolour.getColourScheme() == null) { - // Set the default colour for sequence logo if the alignnent has no - // colourscheme set - profcolour = av.getAlignment().isNucleotide() ? new jalview.schemes.NucleotideColourScheme() - : new jalview.schemes.ZappoColourScheme(); + /* + * Use default colour for sequence logo if + * the alignment has no colourscheme set + * (would like to use user preference but n/a for applet) + */ + ColourSchemeI col = av.getAlignment().isNucleotide() + ? new NucleotideColourScheme() + : new ZappoColourScheme(); + profcolour = new ResidueShader(col); } columnSelection = av.getColumnSelection(); - hconsensus = av.getSequenceConsensusHash();// hconsensus; - hStrucConsensus = av.getRnaStructureConsensusHash(); // hStrucConsensus; - av_ignoreGapsConsensus = av.getIgnoreGapsConsensus(); + hiddenColumns = av.getAlignment().getHiddenColumns(); + hconsensus = av.getSequenceConsensusHash(); + complementConsensus = av.getComplementConsensusHash(); + hStrucConsensus = av.getRnaStructureConsensusHash(); + av_ignoreGapsConsensus = av.isIgnoreGapsConsensus(); } - public int[] getProfileFor(AlignmentAnnotation aa, int column) + /** + * Returns profile data; the first element is the profile type, the second is + * the number of distinct values, the third the total count, and the remainder + * depend on the profile type. + * + * @param aa + * @param column + * @return + */ + int[] getProfileFor(AlignmentAnnotation aa, int column) { // TODO : consider refactoring the global alignment calculation // properties/rendering attributes as a global 'alignment group' which holds // all vis settings for the alignment as a whole rather than a subset // - if (aa.autoCalculated && aa.label.startsWith("Consensus")) + if (aa.autoCalculated && (aa.label.startsWith("Consensus") + || aa.label.startsWith("cDNA Consensus"))) { + boolean forComplement = aa.label.startsWith("cDNA Consensus"); if (aa.groupRef != null && aa.groupRef.consensusData != null && aa.groupRef.isShowSequenceLogo()) { + // TODO? group consensus for cDNA complement return AAFrequency.extractProfile( - aa.groupRef.consensusData[column], + aa.groupRef.consensusData.get(column), aa.groupRef.getIgnoreGapsConsensus()); } // TODO extend annotation row to enable dynamic and static profile data to // be stored if (aa.groupRef == null && aa.sequenceRef == null) { - return AAFrequency.extractProfile(hconsensus[column], - av_ignoreGapsConsensus); + if (forComplement) + { + return AAFrequency.extractCdnaProfile(complementConsensus[column], + av_ignoreGapsConsensus); + } + else + { + return AAFrequency.extractProfile(hconsensus.get(column), + av_ignoreGapsConsensus); + } } } else @@ -353,6 +502,10 @@ public class AnnotationRenderer return null; } + boolean rna = false; + + private AnnotationRendererFactoryI rendererFactoryI; + /** * Render the annotation rows associated with an alignment. * @@ -375,6 +528,20 @@ public class AnnotationRenderer AlignViewportI av, Graphics g, int activeRow, int startRes, int endRes) { + return drawComponent(annotPanel, av, g, activeRow, startRes, endRes, + false); + } + + public boolean drawComponent(AwtRenderPanelI annotPanel, + AlignViewportI av, Graphics g, int activeRow, int startRes, + int endRes, boolean forExport) + { + if (g instanceof EpsGraphics2D || g instanceof SVGGraphics2D) + { + this.setVectorRendering(true); + } + Graphics2D g2d = (Graphics2D) g; + long stime = System.currentTimeMillis(); boolean usedFaded = false; // NOTES: @@ -383,7 +550,7 @@ public class AnnotationRenderer updateFromAwtRenderPanel(annotPanel, av); fm = g.getFontMetrics(); AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation(); - int temp = 0; + // int temp = 0; if (aa == null) { return false; @@ -396,19 +563,17 @@ public class AnnotationRenderer boolean validRes = false; boolean validEnd = false; boolean labelAllCols = false; - boolean centreColLabels, centreColLabelsDef = av - .getCentreColumnLabels(); + // boolean centreColLabels; + // boolean centreColLabelsDef = av.isCentreColumnLabels(); boolean scaleColLabel = false; - AlignmentAnnotation consensusAnnot = av - .getAlignmentConsensusAnnotation(), structConsensusAnnot = av + final AlignmentAnnotation consensusAnnot = av + .getAlignmentConsensusAnnotation(); + final AlignmentAnnotation structConsensusAnnot = av .getAlignmentStrucConsensusAnnotation(); - boolean renderHistogram = true, renderProfile = true, normaliseProfile = false; + final AlignmentAnnotation complementConsensusAnnot = av + .getComplementConsensusAnnotation(); BitSet graphGroupDrawn = new BitSet(); - int charOffset = 0; // offset for a label - float fmWidth, fmScaling = 1f; // scaling for a label to fit it into a - // column. - Font ofont = g.getFont(); // \u03B2 \u03B1 // debug ints int yfrom = 0, f_i = 0, yto = 0, f_to = 0; @@ -416,43 +581,42 @@ public class AnnotationRenderer for (int i = 0; i < aa.length; i++) { AlignmentAnnotation row = aa[i]; + boolean renderHistogram = true; + boolean renderProfile = false; + boolean normaliseProfile = false; + boolean isRNA = row.isRNA(); + + // check if this is a consensus annotation row and set the display + // settings appropriately + // TODO: generalise this to have render styles for consensus/profile + // data + if (row.groupRef != null && row == row.groupRef.getConsensus()) { - // check if this is a consensus annotation row and set the display - // settings appropriately - // TODO: generalise this to have render styles for consensus/profile - // data - if (row.groupRef != null && row == row.groupRef.getConsensus()) - { - renderHistogram = row.groupRef.isShowConsensusHistogram(); - renderProfile = row.groupRef.isShowSequenceLogo(); - normaliseProfile = row.groupRef.isNormaliseSequenceLogo(); - } - else if (row == consensusAnnot || row == structConsensusAnnot) - { - renderHistogram = av_renderHistogram; - renderProfile = av_renderProfile; - normaliseProfile = av_normaliseProfile; - } - else - { - renderHistogram = true; - // don't need to set render/normaliseProfile since they are not - // currently used in any other annotation track renderer - } + renderHistogram = row.groupRef.isShowConsensusHistogram(); + renderProfile = row.groupRef.isShowSequenceLogo(); + normaliseProfile = row.groupRef.isNormaliseSequenceLogo(); } + else if (row == consensusAnnot || row == structConsensusAnnot + || row == complementConsensusAnnot) + { + renderHistogram = av_renderHistogram; + renderProfile = av_renderProfile; + normaliseProfile = av_normaliseProfile; + } + Annotation[] row_annotations = row.annotations; if (!row.visible) { continue; } - centreColLabels = row.centreColLabels || centreColLabelsDef; + // centreColLabels = row.centreColLabels || centreColLabelsDef; labelAllCols = row.showAllColLabels; scaleColLabel = row.scaleColLabel; lastSS = ' '; lastSSX = 0; - if (!useClip - || ((y - charHeight) < visHeight && (y + row.height + charHeight * 2) >= sOffset)) + if (!useClip || ((y - charHeight) < visHeight + && (y + row.height + charHeight * 2) >= sOffset)) {// if_in_visible_region if (!clipst) { @@ -492,8 +656,8 @@ public class AnnotationRenderer { y += charHeight; usedFaded = true; - g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0, y - - row.height, imgWidth, y, annotationPanel); + g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0, + y - row.height, imgWidth, y, annotationPanel); g.setColor(Color.black); // g.drawString("Calculating "+aa[i].label+"....",20, y-row.height/2); @@ -522,15 +686,20 @@ public class AnnotationRenderer * * continue; } */ + // first pass sets up state for drawing continuation from left-hand // column // of startRes + + // flag used for vector rendition + this.glyphLineDrawn = false; x = (startRes == 0) ? 0 : -1; + while (x < endRes - startRes) { if (hasHiddenColumns) { - column = columnSelection.adjustForHiddenColumns(startRes + x); + column = hiddenColumns.visibleToAbsoluteColumn(startRes + x); if (column > row_annotations.length - 1) { break; @@ -551,87 +720,114 @@ public class AnnotationRenderer { validRes = true; } + final String displayChar = validRes + ? row_annotations[column].displayCharacter + : null; if (x > -1) { + unsetAntialias(g); if (activeRow == i) { g.setColor(Color.red); if (columnSelection != null) { - for (int n = 0; n < columnSelection.size(); n++) + if (columnSelection.contains(column)) { - int v = columnSelection.columnAt(n); - - if (v == column) - { - g.fillRect(x * charWidth, y, charWidth, charHeight); - } + fillRect(g, x * charWidth, y, charWidth, charHeight); } } } - if (!row.isValidStruc()) + if (row.getInvalidStrucPos() > x) { g.setColor(Color.orange); - g.fillRect((int) row.getInvalidStrucPos() * charWidth, y, - charWidth, charHeight); + fillRect(g, x * charWidth, y, charWidth, charHeight); } - if (validCharWidth - && validRes - && row_annotations[column].displayCharacter != null - && (row_annotations[column].displayCharacter.length() > 0)) + else if (row.getInvalidStrucPos() == x) { - - if (centreColLabels || scaleColLabel) + g.setColor(Color.orange.darker()); + fillRect(g, x * charWidth, y, charWidth, charHeight); + } + if (validCharWidth && validRes && displayChar != null + && (displayChar.length() > 0)) + { + float fmWidth = fm.stringWidth(displayChar); + + /* + * shrink label width to fit in column, if that is + * both configured and necessary + */ + boolean scaledToFit = false; + float fmScaling = 1f; + if (scaleColLabel && fmWidth > charWidth) { - fmWidth = fm.charsWidth( - row_annotations[column].displayCharacter - .toCharArray(), 0, - row_annotations[column].displayCharacter.length()); + scaledToFit = true; + fmScaling = (float) charWidth / fmWidth; + // and update the label's width to reflect the scaling. + fmWidth = charWidth; + } - if (scaleColLabel) - { - // justify the label and scale to fit in column - if (fmWidth > charWidth) - { - // scale only if the current font isn't already small enough - fmScaling = charWidth; - fmScaling /= fmWidth; - g.setFont(ofont.deriveFont(AffineTransform - .getScaleInstance(fmScaling, 1.0))); - // and update the label's width to reflect the scaling. - fmWidth = charWidth; - } - } + float charOffset = (charWidth - fmWidth) / 2f; + + if (row_annotations[column].colour == null) + { + g2d.setColor(Color.black); } else { - fmWidth = fm - .charWidth(row_annotations[column].displayCharacter - .charAt(0)); + g2d.setColor(row_annotations[column].colour); } - charOffset = (int) ((charWidth - fmWidth) / 2f); - - if (row_annotations[column].colour == null) - g.setColor(Color.black); - else - g.setColor(row_annotations[column].colour); + /* + * draw the label, unless it is the same secondary structure + * symbol (excluding RNA Helix) as the previous column + */ + final float xPos = (x * charWidth) + charOffset; + final float yPos = y + iconOffset; + + // Act on a copy of the Graphics2d object + Graphics2D g2dCopy = (Graphics2D) g2d.create(); + // Clip to this annotation line (particularly width). + // This removes artifacts from text when side scrolling + // (particularly in wrap format), but can result in clipped + // characters until a full paint is drawn. + // Add charHeight allowance above and below annotation for + // character overhang. + // If we're in an image export, set the clip width to be the + // entire width of the annotation. + + int clipWidth = forExport + ? row_annotations.length * charWidth - 1 + : imgWidth - 1; + g2dCopy.setClip(0, (int) yPos - 2 * charHeight, clipWidth, + charHeight * 3); + /* + * translate to drawing position _before_ applying any scaling + */ + g2dCopy.translate(xPos, yPos); + if (scaledToFit) + { + /* + * use a scaling transform to make the label narrower + * (JalviewJS doesn't have Font.deriveFont(AffineTransform)) + */ + g2dCopy.transform( + AffineTransform.getScaleInstance(fmScaling, 1.0)); + } + setAntialias(g2dCopy, true); if (column == 0 || row.graph > 0) { - g.drawString(row_annotations[column].displayCharacter, - (x * charWidth) + charOffset, y + iconOffset); + g2dCopy.drawString(displayChar, 0, 0); } - else if (row_annotations[column - 1] == null - || (labelAllCols - || !row_annotations[column].displayCharacter - .equals(row_annotations[column - 1].displayCharacter) || (row_annotations[column].displayCharacter - .length() < 2 && row_annotations[column].secondaryStructure == ' '))) + else if (row_annotations[column - 1] == null || (labelAllCols + || !displayChar.equals( + row_annotations[column - 1].displayCharacter) + || (displayChar.length() < 2 + && row_annotations[column].secondaryStructure == ' '))) { - g.drawString(row_annotations[column].displayCharacter, x - * charWidth + charOffset, y + iconOffset); + g2dCopy.drawString(displayChar, 0, 0); } - g.setFont(ofont); + g2dCopy.dispose(); } } if (row.hasIcons) @@ -642,7 +838,7 @@ public class AnnotationRenderer if (ss == '(') { // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf(')') > -1) + if (displayChar.indexOf(')') > -1) { ss = ')'; @@ -651,7 +847,7 @@ public class AnnotationRenderer } if (ss == '[') { - if ((row_annotations[column].displayCharacter.indexOf(']') > -1)) + if ((displayChar.indexOf(']') > -1)) { ss = ']'; @@ -660,7 +856,7 @@ public class AnnotationRenderer if (ss == '{') { // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('}') > -1) + if (displayChar.indexOf('}') > -1) { ss = '}'; @@ -669,50 +865,61 @@ public class AnnotationRenderer if (ss == '<') { // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('<') > -1) + if (displayChar.indexOf('<') > -1) { ss = '>'; } } - if (ss >= 65) + if (isRNA && (ss >= CHAR_A) && (ss <= CHAR_Z)) { // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf(ss + 32) > -1) + int ssLowerCase = ss + UPPER_TO_LOWER; + // TODO would .equals() be safer here? or charAt(0)? + if (displayChar.indexOf(ssLowerCase) > -1) { - - ss = (char) (ss + 32); - + ss = (char) ssLowerCase; } } if (!validRes || (ss != lastSS)) { - if (x > -1) + if (x > 0) { - int nb_annot = x - temp; - // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre annot :"+nb_annot); + // int nb_annot = x - temp; + // Console.info("\t type :"+lastSS+"\t x + // :"+x+"\t nbre + // annot :"+nb_annot); switch (lastSS) { - - case '$': - drawHelixAnnot(g, row_annotations, lastSSX, x, y, - iconOffset, startRes, column, validRes, validEnd); - break; - - case 0xCE: - drawSheetAnnot(g, row_annotations, lastSSX, x, y, - iconOffset, startRes, column, validRes, validEnd); - break; - case '(': // Stem case for RNA secondary structure case ')': // and opposite direction drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset, startRes, column, validRes, validEnd); - temp = x; + // temp = x; break; + + case 'H': + if (!isRNA) + { + drawHelixAnnot(g, row_annotations, lastSSX, x, y, + iconOffset, startRes, column, validRes, + validEnd); + break; + } + // no break if isRNA - falls through to drawNotCanonicalAnnot! + case 'E': + if (!isRNA) + { + drawSheetAnnot(g, row_annotations, lastSSX, x, y, + iconOffset, startRes, column, validRes, + validEnd); + break; + } + // no break if isRNA - fall through to drawNotCanonicalAnnot! + case '{': case '}': case '[': @@ -727,13 +934,11 @@ public class AnnotationRenderer case 'c': case 'D': case 'd': - case 'E': case 'e': case 'F': case 'f': case 'G': case 'g': - case 'H': case 'h': case 'I': case 'i': @@ -776,13 +981,20 @@ public class AnnotationRenderer drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX, x, y, iconOffset, startRes, column, validRes, validEnd); - temp = x; + // temp = x; break; default: - g.setColor(Color.gray); - g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - - lastSSX, 2); - temp = x; + if (isVectorRendering()) + { + // draw single full width glyphline + drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset); + // disable more glyph lines + this.glyphLineDrawn = true; + } + else + { + drawGlyphLine(g, lastSSX, x, y, iconOffset); + } break; } } @@ -821,24 +1033,33 @@ public class AnnotationRenderer { validRes = true; } - // x ++; if (row.hasIcons) { switch (lastSS) { - case '$': - drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); - break; - case 0xCE: - drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); - break; - case 's': - case 'S': // Stem case for RNA secondary structure + case 'H': + if (!isRNA) + { + drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset, + startRes, column, validRes, validEnd); + break; + } + // no break if isRNA - fall through to drawNotCanonicalAnnot! + + case 'E': + if (!isRNA) + { + drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset, + startRes, column, validRes, validEnd); + break; + } + // no break if isRNA - fall through to drawNotCanonicalAnnot! + + case '(': + case ')': // Stem case for RNA secondary structure drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset, startRes, column, validRes, validEnd); @@ -858,13 +1079,11 @@ public class AnnotationRenderer case 'c': case 'D': case 'd': - case 'E': case 'e': case 'F': case 'f': case 'G': case 'g': - case 'H': case 'h': case 'I': case 'i': @@ -900,14 +1119,23 @@ public class AnnotationRenderer case 'y': case 'Z': case 'z': - // System.out.println(lastSS); + // Console.info(lastSS); Color nonCanColor = getNotCanonicalColor(lastSS); drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX, x, y, iconOffset, startRes, column, validRes, validEnd); break; default: - drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); + if (isVectorRendering()) + { + // draw single full width glyphline + drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset); + // disable more glyph lines + this.glyphLineDrawn = true; + } + else + { + drawGlyphLine(g, lastSSX, x, y, iconOffset); + } break; } } @@ -965,6 +1193,32 @@ public class AnnotationRenderer row.graphMin, row.graphMax, y, renderHistogram, renderProfile, normaliseProfile); } + else + { + AnnotationRowRendererI renderer = rendererFactoryI + .getRendererFor(row); + if (renderer != null) + { + renderer.renderRow(g, charWidth, charHeight, hasHiddenColumns, + av, hiddenColumns, columnSelection, row, + row_annotations, startRes, endRes, row.graphMin, + row.graphMax, y, isVectorRendering()); + } + if (debugRedraw) + { + if (renderer == null) + { + System.err + .println("No renderer found for " + row.toString()); + } + else + { + Console.warn( + "rendered with " + renderer.getClass().toString()); + } + } + + } } } else @@ -973,7 +1227,7 @@ public class AnnotationRenderer { clipend = true; } - }// end if_in_visible_region + } // end if_in_visible_region if (row.graph > 0 && row.hasText) { y += charHeight; @@ -990,17 +1244,15 @@ public class AnnotationRenderer { if (clipst) { - System.err.println("Start clip at : " + yfrom + " (index " + f_i - + ")"); + Console.warn("Start clip at : " + yfrom + " (index " + f_i + ")"); } if (clipend) { - System.err.println("End clip at : " + yto + " (index " + f_to - + ")"); + Console.warn("End clip at : " + yto + " (index " + f_to + ")"); } } ; - System.err.println("Annotation Rendering time:" + Console.warn("Annotation Rendering time:" + (System.currentTimeMillis() - stime)); } ; @@ -1008,75 +1260,88 @@ public class AnnotationRenderer return !usedFaded; } - private final Color GLYPHLINE_COLOR = Color.gray; + public static final Color GLYPHLINE_COLOR = Color.gray; - private final Color SHEET_COLOUR = Color.green; + public static final Color SHEET_COLOUR = Color.green; - private final Color HELIX_COLOUR = Color.red; + public static final Color HELIX_COLOUR = Color.red; - private final Color STEM_COLOUR = Color.blue; + public static final Color STEM_COLOUR = Color.blue; - private Color sdNOTCANONICAL_COLOUR; + // private Color sdNOTCANONICAL_COLOUR; - public void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, - int x, int y, int iconOffset, int startRes, int column, - boolean validRes, boolean validEnd) + void drawGlyphLine(Graphics g, int lastSSX, int x, int y, int iconOffset) { + if (glyphLineDrawn) + { + // if we've drawn a single long glyphline for an export, don't draw the + // bits + return; + } + unsetAntialias(g); g.setColor(GLYPHLINE_COLOR); g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2); } - public void drawSheetAnnot(Graphics g, Annotation[] row, + void drawSheetAnnot(Graphics g, Annotation[] row, - int lastSSX, int x, int y, int iconOffset, int startRes, int column, - boolean validRes, boolean validEnd) + int lastSSX, int x, int y, int iconOffset, int startRes, + int column, boolean validRes, boolean validEnd) { - g.setColor(SHEET_COLOUR); - if (!validEnd || !validRes || row == null || row[column] == null || row[column].secondaryStructure != 'E') { - g.fillRect(lastSSX, y + 4 + iconOffset, - (x * charWidth) - lastSSX - 4, 7); - g.fillPolygon(new int[] - { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) }, + // draw the glyphline underneath + drawGlyphLine(g, lastSSX, x, y, iconOffset); + + g.setColor(SHEET_COLOUR); + fillRect(g, lastSSX, y + 4 + iconOffset, + (x * charWidth) - lastSSX - 4, 6); + fillPolygon(g, + new int[] + { (x * charWidth) - 6, (x * charWidth) - 6, + (x * charWidth - 1) }, new int[] - { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset }, + { y + iconOffset + 1, y + 13 + iconOffset, + y + 7 + iconOffset }, 3); } else { - g.fillRect(lastSSX, y + 4 + iconOffset, - (x + 1) * charWidth - lastSSX, 7); + g.setColor(SHEET_COLOUR); + fillRect(g, lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX, + 6); } - } - public void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, - int x, int y, int iconOffset, int startRes, int column, - boolean validRes, boolean validEnd) + void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, int x, + int y, int iconOffset, int startRes, int column, boolean validRes, + boolean validEnd) { - g.setColor(HELIX_COLOUR); - - int sCol = (lastSSX / charWidth) + startRes; + int sCol = (lastSSX / charWidth) + + hiddenColumns.visibleToAbsoluteColumn(startRes); int x1 = lastSSX; int x2 = (x * charWidth); - if (MAC) + if (USE_FILL_ROUND_RECT || isVectorRendering()) { + // draw glyph line behind helix (visible in EPS or SVG output) + drawGlyphLine(g, lastSSX, x, y, iconOffset); + + g.setColor(HELIX_COLOUR); + setAntialias(g); int ofs = charWidth / 2; // Off by 1 offset when drawing rects and ovals // to offscreen image on the MAC - g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8); + fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - 1, 8, 8, 8); if (sCol == 0 || row[sCol - 1] == null || row[sCol - 1].secondaryStructure != 'H') { } else { - // g.setColor(Color.orange); - g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8, - 0, 0); + fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - ofs, 8, 0, + 0); } if (!validRes || row[column] == null || row[column].secondaryStructure != 'H') @@ -1085,41 +1350,55 @@ public class AnnotationRenderer } else { - // g.setColor(Color.magenta); - g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs - + 1, 8, 0, 0); - + fillRoundRect(g, lastSSX + ofs, y + 3 + iconOffset, x2 - x1 - ofs, + 8, 0, 0); } return; } - if (sCol == 0 || row[sCol - 1] == null - || row[sCol - 1].secondaryStructure != 'H') + boolean leftEnd = sCol == 0 || row[sCol - 1] == null + || row[sCol - 1].secondaryStructure != 'H'; + boolean rightEnd = !validRes || row[column] == null + || row[column].secondaryStructure != 'H'; + + if (leftEnd || rightEnd) + { + drawGlyphLine(g, lastSSX, x, y, iconOffset); + } + g.setColor(HELIX_COLOUR); + + if (leftEnd) { - g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180); + fillArc(g, lastSSX, y + 3 + iconOffset, charWidth, 8, 90, 180); x1 += charWidth / 2; } - if (!validRes || row[column] == null - || row[column].secondaryStructure != 'H') + if (rightEnd) { - g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset, charWidth, - 8, 270, 180); + fillArc(g, ((x - 1) * charWidth), y + 3 + iconOffset, charWidth, 8, + 270, 180); x2 -= charWidth / 2; } - g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8); + fillRect(g, x1, y + 3 + iconOffset, x2 - x1, 8); } - public void drawLineGraph(Graphics g, AlignmentAnnotation _aa, - Annotation[] aa_annotations, int sRes, int eRes, int y, - float min, float max, int graphHeight) + void drawLineGraph(Graphics g, AlignmentAnnotation _aa, + Annotation[] aa_annotations, int sRes, int eRes, int y, float min, + float max, int graphHeight) { if (sRes > aa_annotations.length) { return; } + Stroke roundStroke = new BasicStroke(1, BasicStroke.CAP_ROUND, + BasicStroke.JOIN_ROUND); + Stroke squareStroke = new BasicStroke(1, BasicStroke.CAP_SQUARE, + BasicStroke.JOIN_MITER); + Graphics2D g2d = (Graphics2D) g; + Stroke prevStroke = g2d.getStroke(); + g2d.setStroke(roundStroke); int x = 0; @@ -1131,11 +1410,6 @@ public class AnnotationRenderer eRes = Math.min(eRes, aa_annotations.length); - if (sRes == 0) - { - x++; - } - int y1 = y, y2 = y; float range = max - min; @@ -1146,19 +1420,25 @@ public class AnnotationRenderer } g.setColor(Color.gray); - g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2); + drawLine(g, squareStroke, x * charWidth, y2, (eRes - sRes) * charWidth, + y2); + + if (sRes == 0) + { + x++; + } eRes = Math.min(eRes, aa_annotations.length); int column; int aaMax = aa_annotations.length - 1; - while (x < eRes - sRes) + while (x <= eRes - sRes) { column = sRes + x; if (hasHiddenColumns) { - column = columnSelection.adjustForHiddenColumns(column); + column = hiddenColumns.visibleToAbsoluteColumn(column); } if (column > aaMax) @@ -1166,25 +1446,91 @@ public class AnnotationRenderer break; } - if (aa_annotations[column] == null - || aa_annotations[column - 1] == null) + if (aa_annotations[column] == null) { x++; continue; } + boolean individualColour = false; if (aa_annotations[column].colour == null) + { g.setColor(Color.black); + } else + { g.setColor(aa_annotations[column].colour); + individualColour = true; + } - y1 = y - - (int) (((aa_annotations[column - 1].value - min) / range) * graphHeight); - y2 = y - - (int) (((aa_annotations[column].value - min) / range) * graphHeight); + boolean value1Exists = column > 0 + && aa_annotations[column - 1] != null; + float value1 = 0f; + Color color1 = null; + if (value1Exists) + { + value1 = aa_annotations[column - 1].value; + color1 = aa_annotations[column - 1].colour; + } + float value2 = aa_annotations[column].value; + boolean nextValueExists = aa_annotations.length > column + 1 + && aa_annotations[column + 1] != null; - g.drawLine(x * charWidth - charWidth / 2, y1, x * charWidth - + charWidth / 2, y2); + // check for standalone value + if (!value1Exists && !nextValueExists) + { + y2 = y - yValueToPixelHeight(value2, min, range, graphHeight); + drawLine(g, x * charWidth + charWidth / 4, y2, + x * charWidth + 3 * charWidth / 4, y2); + x++; + continue; + } + + if (!value1Exists) + { + x++; + continue; + } + + y1 = y - yValueToPixelHeight(value1, min, range, graphHeight); + y2 = y - yValueToPixelHeight(value2, min, range, graphHeight); + + float v1 = value1; + float v2 = value2; + int a1 = (x - 1) * charWidth + charWidth / 2; + int b1 = y1; + int a2 = x * charWidth + charWidth / 2; + int b2 = y2; + if (x == 0) + { + // only draw an initial half-line + a1 = x * charWidth; + b1 = y1 + (y2 - y1) / 2; + v1 = value1 + (value2 - value1) / 2; + } + else if (x == eRes - sRes) + { + // this is one past the end to draw -- only draw the first half of the + // line + a2 = x * charWidth - 1; + b2 = y1 + (y2 - y1) / 2; + v2 = value1 + (value2 - value1) / 2; + } + else + { + } + AnnotationColouringI ac = aa_annotations[column] + .getAnnotationColouring(); + List> valCols = ac == null ? null + : ac.rangeColours(v1, v2); + if (valCols != null) + { + drawSegmentedLine(g, valCols, a1, b1, a2, b2); + } + else + { + drawLine(g, a1, b1, a2, b2); + } x++; } @@ -1192,17 +1538,139 @@ public class AnnotationRenderer { g.setColor(_aa.threshold.colour); Graphics2D g2 = (Graphics2D) g; - g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE, - BasicStroke.JOIN_ROUND, 3f, new float[] - { 5f, 3f }, 0f)); - y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight); - g.drawLine(0, y2, (eRes - sRes) * charWidth, y2); - g2.setStroke(new BasicStroke()); + drawLine(g, dashedLine(charWidth), 0, y2, (eRes - sRes) * charWidth, + y2); + } + g2d.setStroke(prevStroke); + } + + private static double log2 = Math.log(2); + + // Cached dashed line Strokes + private static Map dashedLineLookup = new HashMap<>(); + + /** + * Returns a dashed line stroke as close to 6-4 pixels as fits within the + * charWidth. This allows translations of multiples of charWidth without + * disrupting the dashed line. The exact values are 0.6-0.4 proportions of + * charWidth for charWidth under 16. For charWidth 16 or over, the number of + * dashes doubles as charWidth doubles. + * + * @param charWidth + * @return Stroke with appropriate dashed line fitting exactly within the + * charWidth + */ + private static Stroke dashedLine(int charWidth) + { + if (!dashedLineLookup.containsKey(charWidth)) + { + int power2 = charWidth >= 8 ? (int) (Math.log(charWidth) / log2) : 2; + float width = ((float) charWidth) / ((float) Math.pow(2, power2 - 3)); + float segment1 = width * 0.6f; + float segment2 = width - segment1; + dashedLineLookup.put(charWidth, new BasicStroke(1, + BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 3f, new float[] + { segment1, segment2 }, 0f)); } + return dashedLineLookup.get(charWidth); } - public void drawBarGraph(Graphics g, AlignmentAnnotation _aa, + private void drawSegmentedLine(Graphics g, + List> valCols, int x1, int y1, int x2, + int y2) + { + if (valCols == null || valCols.size() == 0) + { + return; + } + // let's only go forwards+up|down -- try and avoid providing right to left + // x values + if (x2 < x1) + { + int tmp = y2; + y2 = y1; + y1 = tmp; + tmp = x2; + x2 = x1; + x1 = tmp; + Collections.reverse(valCols); + } + Graphics2D g2d = (Graphics2D) g.create(); + float yd = y2 - y1; + boolean reverse = yd > 0; // reverse => line going DOWN (y increasing) + Map.Entry firstValCol = valCols.remove(0); + float firstVal = firstValCol.getKey(); + Color firstCol = firstValCol.getValue(); + int yy1 = 0; + yy1 = reverse ? (int) Math.ceil(y1 + firstVal * yd) + : (int) Math.floor(y1 + firstVal * yd); + Color thisCol = firstCol; + for (int i = 0; i < valCols.size(); i++) + { + Map.Entry valCol = valCols.get(i); + float val = valCol.getKey(); + Color col = valCol.getValue(); + int clipX = x1 - 1; + int clipW = x2 - x1 + 2; + int clipY = 0; + int clipH = 0; + int yy2 = 0; + if (reverse) // line going down + { + yy2 = (int) Math.ceil(y1 + val * yd); + g2d.setColor(thisCol); + clipY = yy1 - 1; + clipH = yy2 - yy1; + if (i == 0) + { + // highest segment, don't clip at the top + clipY -= 2; + clipH += 2; + } + if (i == valCols.size() - 1) + { + // lowest segment, don't clip at the bottom + clipH += 2; + } + } + else // line going up (or level) + { + yy2 = (int) Math.floor(y1 + val * yd); + // g2d.setColor(Color.cyan); g2d.drawRect(x1 - 1, yy1, x2 - x1 + 1, yy2 + // - + // yy1 + 1); + g2d.setColor(col); + clipY = yy2; + clipH = yy1 - yy2; + if (i == 0) + { + // lowest segment, don't clip at the bottom + clipH += 2; + } + if (i == valCols.size() - 1) + { + // highest segment, don't clip at the top + clipY -= 2; + clipH += 2; + } + } + g2d.setClip(clipX, clipY, clipW, clipH); + drawLine(g2d, x1, y1, x2, y2); + yy1 = yy2; + thisCol = col; + } + g2d.dispose(); + } + + private static int yValueToPixelHeight(float value, float min, + float range, int graphHeight) + { + return (int) (((value - min) / range) * graphHeight); + } + + @SuppressWarnings("unused") + void drawBarGraph(Graphics g, AlignmentAnnotation _aa, Annotation[] aa_annotations, int sRes, int eRes, float min, float max, int y, boolean renderHistogram, boolean renderProfile, boolean normaliseProfile) @@ -1225,7 +1693,7 @@ public class AnnotationRenderer g.setColor(Color.gray); - g.drawLine(x, y2, (eRes - sRes) * charWidth, y2); + drawLine(g, x, y2, (eRes - sRes) * charWidth, y2); int column; int aaMax = aa_annotations.length - 1; @@ -1234,7 +1702,7 @@ public class AnnotationRenderer column = sRes + x; if (hasHiddenColumns) { - column = columnSelection.adjustForHiddenColumns(column); + column = hiddenColumns.visibleToAbsoluteColumn(column); } if (column > aaMax) @@ -1248,91 +1716,169 @@ public class AnnotationRenderer continue; } if (aa_annotations[column].colour == null) + { g.setColor(Color.black); + } else + { g.setColor(aa_annotations[column].colour); + } - y1 = y - - (int) (((aa_annotations[column].value - min) / (range)) * _aa.graphHeight); + y1 = y - (int) (((aa_annotations[column].value - min) / (range)) + * _aa.graphHeight); if (renderHistogram) { if (y1 - y2 > 0) { - g.fillRect(x * charWidth, y2, charWidth, y1 - y2); + fillRect(g, x * charWidth, y2, charWidth, y1 - y2); } else { - g.fillRect(x * charWidth, y1, charWidth, y2 - y1); + fillRect(g, x * charWidth, y1, charWidth, y2 - y1); } } // draw profile if available if (renderProfile) { + /* + * {profile type, #values, total count, char1, pct1, char2, pct2...} + */ int profl[] = getProfileFor(_aa, column); + // just try to draw the logo if profl is not null - if (profl != null && profl[1] != 0) + if (profl != null && profl[2] != 0) { + boolean isStructureProfile = profl[0] == AlignmentAnnotation.STRUCTURE_PROFILE; + boolean isCdnaProfile = profl[0] == AlignmentAnnotation.CDNA_PROFILE; float ht = normaliseProfile ? y - _aa.graphHeight : y1; - double htn = normaliseProfile ? _aa.graphHeight : (y2 - y1);// aa.graphHeight; - double hght; - float wdth; - double ht2 = 0; - char[] dc; + final double normaliseFactor = normaliseProfile ? _aa.graphHeight + : (y2 - y1); /** - * profl.length == 74 indicates that the profile of a secondary - * structure conservation row was accesed. Therefore dc gets length 2, - * to have space for a basepair instead of just a single nucleotide + * Render a single base for a sequence profile, a base pair for + * structure profile, and a triplet for a cdna profile */ - if (profl.length == 74) - { - dc = new char[2]; - } - else - { - dc = new char[1]; - } - LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g); - double scale = 1f / (normaliseProfile ? profl[1] : 100f); - float ofontHeight = 1f / lm.getAscent();// magnify to fill box - double scl = 0.0; - for (int c = 2; c < profl[0];) + char[] dc = new char[isStructureProfile ? 2 + : (isCdnaProfile ? 3 : 1)]; + + // lm is not necessary - we can just use fm - could be off by no more + // than 0.5 px + // LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g); + // Console.info(asc + " " + dec + " " + (asc - + // lm.getAscent()) + // + " " + (dec - lm.getDescent())); + + double asc = fm.getAscent(); + double dec = fm.getDescent(); + double fht = fm.getHeight(); + + double scale = 1f / (normaliseProfile ? profl[2] : 100f); + // float ofontHeight = 1f / fm.getAscent();// magnify to fill box + + /* + * Traverse the character(s)/percentage data in the array + */ + + float ht2 = ht; + + // profl[1] is the number of values in the profile + for (int i = 0, c = 3, last = profl[1]; i < last; i++) { - dc[0] = (char) profl[c++]; - if (_aa.label.startsWith("StrucConsensus")) + String s; + if (isStructureProfile) { + // todo can we encode a structure pair as an int, like codons? + dc[0] = (char) profl[c++]; dc[1] = (char) profl[c++]; + s = new String(dc); } + else if (isCdnaProfile) + { + CodingUtils.decodeCodon2(profl[c++], dc); + s = new String(dc); + } + else + { + dc[0] = (char) profl[c++]; + s = new String(dc); + } + // next profl[] position is profile % for the character(s) - wdth = charWidth; - wdth /= fm.charsWidth(dc, 0, dc.length); - - ht += scl; + int percent = profl[c++]; + if (percent == 0) + { + // failsafe in case a count rounds down to 0% + continue; + } + double newHeight = normaliseFactor * scale * percent; + + /* + * Set character colour as per alignment colour scheme; use the + * codon translation if a cDNA profile + */ + Color colour = null; + if (isCdnaProfile) + { + final String codonTranslation = ResidueProperties + .codonTranslate(s); + colour = profcolour.findColour(codonTranslation.charAt(0), + column, null); + } + else + { + colour = profcolour.findColour(dc[0], column, null); + } + g.setColor(colour == Color.white ? Color.lightGray : colour); + + double sx = 1f * charWidth / fm.charsWidth(dc, 0, dc.length); + double sy = newHeight / asc; + double newAsc = asc * sy; + double newDec = dec * sy; + // it is not necessary to recalculate lm for the new font. + // note: lm.getBaselineOffsets()[lm.getBaselineIndex()]) must be 0 + // by definition. Was: + // int hght = (int) (ht + (newAsc - newDec); + // - lm.getBaselineOffsets()[lm.getBaselineIndex()])); + + if (Platform.isJS()) + { + /* + * SwingJS does not implement font.deriveFont() + * so use a scaling transform to draw instead, + * this is off by a very small amount + */ + final int hght = (int) (ht2 + (newAsc - newDec)); + Graphics2D gg = (Graphics2D) g; + int xShift = (int) Math.round(x * charWidth / sx); + int yShift = (int) Math.round(hght / sy); + gg.transform(AffineTransform.getScaleInstance(sx, sy)); + gg.drawString(s, xShift, yShift); + gg.transform( + AffineTransform.getScaleInstance(1D / sx, 1D / sy)); + ht2 += newHeight; + } + else + /** + * Java only + * + * @j2sIgnore + */ { - scl = htn * scale * profl[c++]; - lm = ofont.getLineMetrics(dc, 0, 1, g.getFontMetrics() - .getFontRenderContext()); - g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance( - wdth, scl / lm.getAscent()))); - lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g); - - // Debug - render boxes around characters - // g.setColor(Color.red); - // g.drawRect(x*av.charWidth, (int)ht, av.charWidth, - // (int)(scl)); - // g.setColor(profcolour.findColour(dc[0]).darker()); - g.setColor(profcolour.findColour(dc[0], column, null)); - - hght = (ht + (scl - lm.getDescent() - lm.getBaselineOffsets()[lm - .getBaselineIndex()])); - - g.drawChars(dc, 0, dc.length, x * charWidth, (int) hght); + // Java ('normal') method is to scale the font to fit + + final int hght = (int) (ht + (newAsc - newDec)); + Font font = ofont + .deriveFont(AffineTransform.getScaleInstance(sx, sy)); + g.setFont(font); + g.drawChars(dc, 0, dc.length, x * charWidth, hght); + g.setFont(ofont); + + ht += newHeight; } } - g.setFont(ofont); } } x++; @@ -1340,15 +1886,13 @@ public class AnnotationRenderer if (_aa.threshold != null) { g.setColor(_aa.threshold.colour); - Graphics2D g2 = (Graphics2D) g; - g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE, + Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND, 3f, new float[] - { 5f, 3f }, 0f)); + { 5f, 3f }, 0f); - y2 = (int) (y - ((_aa.threshold.value - min) / range) - * _aa.graphHeight); - g.drawLine(0, y2, (eRes - sRes) * charWidth, y2); - g2.setStroke(new BasicStroke()); + y2 = (int) (y + - ((_aa.threshold.value - min) / range) * _aa.graphHeight); + drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2); } } @@ -1358,7 +1902,7 @@ public class AnnotationRenderer { eRes = Math.min(eRes, aa_annotations.length); g.setColor(Color.white); - g.fillRect(0, 0, width, y); + fillRect(g, 0, 0, width, y); g.setColor(new Color(0, 0, 180)); int x = 0, height; @@ -1368,9 +1912,13 @@ public class AnnotationRenderer if (aa_annotations[j] != null) { if (aa_annotations[j].colour == null) + { g.setColor(Color.black); + } else + { g.setColor(aa_annotations[j].colour); + } height = (int) ((aa_annotations[j].value / _aa.graphMax) * y); if (height > y) @@ -1378,7 +1926,7 @@ public class AnnotationRenderer height = y; } - g.fillRect(x, y - height, charWidth, height); + fillRect(g, x, y - height, charWidth, height); } x += charWidth; } @@ -1505,9 +2053,105 @@ public class AnnotationRenderer return new Color(0, 80, 255); default: - System.out.println("This is not a interaction : " + lastss); + Console.info("This is not a interaction : " + lastss); return null; } } + + private void fillPolygon(Graphics g, int[] xpoints, int[] ypoints, int n) + { + setAntialias(g); + g.fillPolygon(xpoints, ypoints, n); + } + + /* + private void fillRect(Graphics g, int a, int b, int c, int d) + { + fillRect(g, false, a, b, c, d); + }*/ + + private void fillRect(Graphics g, int a, int b, int c, int d) + { + unsetAntialias(g); + g.fillRect(a, b, c, d); + } + + private void fillRoundRect(Graphics g, int a, int b, int c, int d, int e, + int f) + { + setAntialias(g); + g.fillRoundRect(a, b, c, d, e, f); + } + + private void fillArc(Graphics g, int a, int b, int c, int d, int e, int f) + { + setAntialias(g); + g.fillArc(a, b, c, d, e, f); + } + + private void drawLine(Graphics g, Stroke s, int a, int b, int c, int d) + { + Graphics2D g2d = (Graphics2D) g; + Stroke p = g2d.getStroke(); + g2d.setStroke(s); + drawLine(g, a, b, c, d); + g2d.setStroke(p); + } + + private void drawLine(Graphics g, int x1, int y1, int x2, int y2) + { + setAntialias(g); + g.drawLine(x1, y1, x2, y2); + } + + private void setAntialias(Graphics g) + { + setAntialias(g, false); + } + + private void setAntialias(Graphics g, boolean text) + { + if (isVectorRendering()) + { + // no need to antialias vector drawings + return; + } + if (Cache.getDefault("ANTI_ALIAS", true)) + { + Graphics2D g2d = (Graphics2D) g; + if (text) + { + g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, + this.textAntialiasMethod); + } + else + { + g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + } + } + } + + private void unsetAntialias(Graphics g) + { + if (isVectorRendering()) + { + // no need to antialias vector drawings + return; + } + Graphics2D g2d = (Graphics2D) g; + g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_OFF); + } + + public void setVectorRendering(boolean b) + { + renderingVectors = b; + } + + public boolean isVectorRendering() + { + return renderingVectors; + } }