X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Frenderer%2FAnnotationRenderer.java;h=eb83f31945e3cc5f6f0f61a253cb8bd4dbd7ba1a;hb=fbfbbe26bee37143d5279fe4d254a5a89c96b021;hp=90808def4fed87ef0f60554585ca59fb30096732;hpb=3e7ebcfda0bc54b3b91905e21835142bfd1fe8a0;p=jalview.git diff --git a/src/jalview/renderer/AnnotationRenderer.java b/src/jalview/renderer/AnnotationRenderer.java index 90808de..eb83f31 100644 --- a/src/jalview/renderer/AnnotationRenderer.java +++ b/src/jalview/renderer/AnnotationRenderer.java @@ -1,29 +1,42 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8) - * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.renderer; import jalview.analysis.AAFrequency; +import jalview.analysis.CodingUtils; +import jalview.analysis.Rna; import jalview.analysis.StructureFrequency; import jalview.api.AlignViewportI; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.Annotation; import jalview.datamodel.ColumnSelection; +import jalview.datamodel.HiddenColumns; +import jalview.datamodel.ProfilesI; +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; import java.awt.BasicStroke; import java.awt.Color; @@ -32,51 +45,154 @@ import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; -import java.awt.font.LineMetrics; import java.awt.geom.AffineTransform; import java.awt.image.ImageObserver; +import java.util.BitSet; import java.util.Hashtable; -import com.stevesoft.pat.Regex; - public class AnnotationRenderer { + private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32 + + private static final int CHAR_A = 'A'; // 65 + + private static final int CHAR_Z = 'Z'; // 90 + + /** + * flag indicating if timing and redraw parameter info should be output + */ + private final boolean debugRedraw; + + private int charWidth, endRes, charHeight; + + private boolean validCharWidth, hasHiddenColumns; + + private FontMetrics fm; + + private final boolean USE_FILL_ROUND_RECT = Platform.isAMacAndNotJS(); + + boolean av_renderHistogram = true, av_renderProfile = true, + av_normaliseProfile = false; + + ResidueShaderI profcolour = null; + + private ColumnSelection columnSelection; + + private HiddenColumns hiddenColumns; + + private ProfilesI hconsensus; + + private Hashtable[] complementConsensus; + + private Hashtable[] hStrucConsensus; + + private boolean av_ignoreGapsConsensus; + + /** + * attributes set from AwtRenderPanelI + */ + /** + * old image used when data is currently being calculated and cannot be + * rendered + */ + private Image fadedImage; + + /** + * panel being rendered into + */ + private ImageObserver annotationPanel; + + /** + * width of image to render in panel + */ + private int imgWidth; + + /** + * offset to beginning of visible area + */ + private int sOffset; + + /** + * offset to end of visible area + */ + private int visHeight; + + /** + * indicate if the renderer should only render the visible portion of the + * annotation given the current view settings + */ + private boolean useClip = true; + + /** + * master flag indicating if renderer should ever try to clip. not enabled for + * jalview 2.8.1 + */ + private boolean canClip = false; public AnnotationRenderer() { - // TODO Auto-generated constructor stub + this(false); } - public void drawStemAnnot(Graphics g, Annotation[] row_annotations, - int lastSSX, int x, int y, int iconOffset, int startRes, - int column, boolean validRes, boolean validEnd) + /** + * 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) { g.setColor(STEM_COLOUR); - int sCol = (lastSSX / charWidth) + startRes; + int sCol = (lastSSX / charWidth) + + hiddenColumns.visibleToAbsoluteColumn(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; + char dc = (column == 0 || row_annotations[column - 1] == null) ? ' ' + : row_annotations[column - 1].secondaryStructure; boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null - || !dc.equals(row_annotations[sCol - 1].displayCharacter); + || dc != row_annotations[sCol - 1].secondaryStructure; 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)) + || dc != row_annotations[column].secondaryStructure; + + 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); + /* + * if new annotation with a closing base pair half of the stem, + * display a backward arrow + */ + g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX }, + new int[] + { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, + 3); x1 += 5; } if (diffdownstream) @@ -86,13 +202,17 @@ public class AnnotationRenderer } 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); + /* + * if annotation ending with an opeing base pair half of the stem, + * display a forward arrow + */ + g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 }, + new int[] + { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, + 3); x2 -= 5; } if (diffupstream) @@ -104,59 +224,19 @@ public class AnnotationRenderer g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7); } - private int charWidth, endRes, charHeight; - - private boolean validCharWidth, hasHiddenColumns; - - private FontMetrics fm; - - private final boolean MAC = new jalview.util.Platform().isAMac(); - - boolean av_renderHistogram = true, av_renderProfile = true, - av_normaliseProfile = false; - - ColourSchemeI profcolour = null; - - private ColumnSelection columnSelection; - - private Hashtable[] hconsensus; - - private Hashtable[] hStrucConsensus; - - private boolean av_ignoreGapsConsensus; - - /** - * attributes set from AwtRenderPanelI - */ - /** - * old image used when data is currently being calculated and cannot be - * rendered - */ - private Image fadedImage; - - /** - * panel being rendered into - */ - private ImageObserver annotationPanel; - - /** - * width of image to render in panel - */ - private int imgWidth; - - - public 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) + 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); - + // System.out.println(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|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z"); - + String dc = (column == 0 || row_annotations[column - 1] == null) ? "" : row_annotations[column - 1].displayCharacter; @@ -165,18 +245,20 @@ public class AnnotationRenderer boolean diffdownstream = !validRes || !validEnd || row_annotations[column] == null || !dc.equals(row_annotations[column].displayCharacter); - // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream); + // 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))// closeletter_b.search(dc)||closeletter_c.search(dc)||closeletter_d.search(dc)||closecrochet.search(dc)) ) + 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); + g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX }, + new int[] + { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, + 3); x1 += 5; } if (diffdownstream) @@ -186,13 +268,14 @@ public class AnnotationRenderer } 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); + g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 }, + new int[] + { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, + 3); x2 -= 5; } if (diffupstream) @@ -203,6 +286,7 @@ public class AnnotationRenderer // draw arrow body g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7); } + // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI // av) public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel, @@ -212,54 +296,102 @@ public class AnnotationRenderer annotationPanel = annotPanel; fadedImage = annotPanel.getFadedImage(); imgWidth = annotPanel.getFadedImageWidth(); + // visible area for rendering + int[] bounds = annotPanel.getVisibleVRange(); + if (bounds != null) + { + sOffset = bounds[0]; + visHeight = bounds[1]; + if (visHeight == 0) + { + useClip = false; + } + else + { + useClip = canClip; + } + } + else + { + 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 && av_renderProfile) + 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 @@ -278,7 +410,7 @@ public class AnnotationRenderer // to // be stored if (aa.groupRef == null && aa.sequenceRef == null - && av_renderProfile && hStrucConsensus != null + && hStrucConsensus != null && hStrucConsensus.length > column) { return StructureFrequency.extractProfile(hStrucConsensus[column], @@ -289,6 +421,10 @@ public class AnnotationRenderer return null; } + boolean rna = false; + + private AnnotationRendererFactoryI rendererFactoryI; + /** * Render the annotation rows associated with an alignment. * @@ -311,6 +447,7 @@ public class AnnotationRenderer AlignViewportI av, Graphics g, int activeRow, int startRes, int endRes) { + long stime = System.currentTimeMillis(); boolean usedFaded = false; // NOTES: // AnnotationPanel needs to implement: ImageObserver, access to @@ -318,7 +455,11 @@ public class AnnotationRenderer updateFromAwtRenderPanel(annotPanel, av); fm = g.getFontMetrics(); AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation(); - + // int temp = 0; + if (aa == null) + { + return false; + } int x = 0, y = 0; int column = 0; char lastSS; @@ -327,751 +468,644 @@ 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; - boolean[] graphGroupDrawn = new boolean[aa.length]; + final AlignmentAnnotation consensusAnnot = av + .getAlignmentConsensusAnnotation(); + final AlignmentAnnotation structConsensusAnnot = av + .getAlignmentStrucConsensusAnnotation(); + 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; + boolean clipst = false, clipend = false; 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()) + { + 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 (row.graph > 0) - { - if (row.graphGroup > -1 && graphGroupDrawn[row.graphGroup]) - { - continue; - } - - // this is so that we draw the characters below the graph - y += row.height; - if (row.hasText) + if (!useClip || ((y - charHeight) < visHeight + && (y + row.height + charHeight * 2) >= sOffset)) + {// if_in_visible_region + if (!clipst) { - iconOffset = charHeight - fm.getDescent(); - y -= charHeight; + clipst = true; + yfrom = y; + f_i = i; } - } - else if (row.hasText) - { - iconOffset = charHeight - fm.getDescent(); - - } - else - { - iconOffset = 0; - } - - if (row.autoCalculated && av.isCalculationInProgress(row)) - { - y += charHeight; - usedFaded = true; - 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); + yto = y; + f_to = i; + if (row.graph > 0) + { + if (row.graphGroup > -1 && graphGroupDrawn.get(row.graphGroup)) + { + continue; + } - continue; - } + // this is so that we draw the characters below the graph + y += row.height; - /* - * else if (annotationPanel.av.updatingConservation && - * aa[i].label.equals("Conservation")) { - * - * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y - - * row.height, annotationPanel.imgWidth, y, 0, y - row.height, - * annotationPanel.imgWidth, y, annotationPanel); - * - * g.setColor(Color.black); // - * g.drawString("Calculating Conservation.....",20, y-row.height/2); - * - * continue; } else if (annotationPanel.av.updatingConservation && - * aa[i].label.equals("Quality")) { - * - * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y - - * row.height, annotationPanel.imgWidth, y, 0, y - row.height, - * annotationPanel.imgWidth, y, annotationPanel); g.setColor(Color.black); - * // / g.drawString("Calculating Quality....",20, y-row.height/2); - * - * continue; } - */ - // first pass sets up state for drawing continuation from left-hand column - // of startRes - x = (startRes == 0) ? 0 : -1; - while (x < endRes - startRes) - { - if (hasHiddenColumns) - { - column = columnSelection.adjustForHiddenColumns(startRes + x); - if (column > row_annotations.length - 1) + if (row.hasText) { - break; + iconOffset = charHeight - fm.getDescent(); + y -= charHeight; } } - else + else if (row.hasText) { - column = startRes + x; - } + iconOffset = charHeight - fm.getDescent(); - if ((row_annotations == null) || (row_annotations.length <= column) - || (row_annotations[column] == null)) - { - validRes = false; } else { - validRes = true; + iconOffset = 0; } - if (x > -1) + + if (row.autoCalculated && av.isCalculationInProgress(row)) { - if (activeRow == i) - { - g.setColor(Color.red); + y += charHeight; + usedFaded = true; + 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); - if (columnSelection != null) - { - for (int n = 0; n < columnSelection.size(); n++) - { - int v = columnSelection.columnAt(n); + continue; + } - if (v == column) - { - g.fillRect(x * charWidth, y, charWidth, charHeight); - } - } + /* + * else if (annotationPanel.av.updatingConservation && + * aa[i].label.equals("Conservation")) { + * + * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y - + * row.height, annotationPanel.imgWidth, y, 0, y - row.height, + * annotationPanel.imgWidth, y, annotationPanel); + * + * g.setColor(Color.black); // + * g.drawString("Calculating Conservation.....",20, y-row.height/2); + * + * continue; } else if (annotationPanel.av.updatingConservation && + * aa[i].label.equals("Quality")) { + * + * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y - + * row.height, annotationPanel.imgWidth, y, 0, y - row.height, + * annotationPanel.imgWidth, y, annotationPanel); + * g.setColor(Color.black); // / + * g.drawString("Calculating Quality....",20, y-row.height/2); + * + * continue; } + */ + // first pass sets up state for drawing continuation from left-hand + // column + // of startRes + x = (startRes == 0) ? 0 : -1; + while (x < endRes - startRes) + { + if (hasHiddenColumns) + { + column = hiddenColumns.visibleToAbsoluteColumn(startRes + x); + if (column > row_annotations.length - 1) + { + break; } } - if (!row.isValidStruc()) + else { - g.setColor(Color.orange); - g.fillRect((int) row.getInvalidStrucPos() * charWidth, y, - charWidth, charHeight); + column = startRes + x; } - if (validCharWidth - && validRes - && row_annotations[column].displayCharacter != null - && (row_annotations[column].displayCharacter.length() > 0)) - { - if (centreColLabels || scaleColLabel) + if ((row_annotations == null) + || (row_annotations.length <= column) + || (row_annotations[column] == null)) + { + validRes = false; + } + else + { + validRes = true; + } + final String displayChar = validRes + ? row_annotations[column].displayCharacter + : null; + if (x > -1) + { + if (activeRow == i) { - fmWidth = fm.charsWidth( - row_annotations[column].displayCharacter - .toCharArray(), 0, - row_annotations[column].displayCharacter.length()); + g.setColor(Color.red); - if (scaleColLabel) + if (columnSelection != null) { - // justify the label and scale to fit in column - if (fmWidth > charWidth) + if (columnSelection.contains(column)) { - // 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; + g.fillRect(x * charWidth, y, charWidth, charHeight); } } } - else + if (row.getInvalidStrucPos() > x) { - fmWidth = fm - .charWidth(row_annotations[column].displayCharacter - .charAt(0)); + g.setColor(Color.orange); + g.fillRect(x * charWidth, y, charWidth, charHeight); } - charOffset = (int) ((charWidth - fmWidth) / 2f); - - if (row_annotations[column].colour == null) - g.setColor(Color.black); - else - g.setColor(row_annotations[column].colour); - - if (column == 0 || row.graph > 0) + else if (row.getInvalidStrucPos() == x) { - g.drawString(row_annotations[column].displayCharacter, - (x * charWidth) + charOffset, y + iconOffset); + g.setColor(Color.orange.darker()); + g.fillRect(x * charWidth, y, charWidth, charHeight); } - 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 == ' '))) + if (validCharWidth && validRes && displayChar != null + && (displayChar.length() > 0)) { - g.drawString(row_annotations[column].displayCharacter - , x - * charWidth + charOffset, y + iconOffset); + Graphics2D gg = ((Graphics2D) g); + float fmWidth = fm.charsWidth(displayChar.toCharArray(), 0, + displayChar.length()); + + /* + * shrink label width to fit in column, if that is + * both configured and necessary + */ + boolean scaledToFit = false; + float fmScaling = 1f; + if (scaleColLabel && fmWidth > charWidth) + { + scaledToFit = true; + fmScaling = charWidth; + fmScaling /= fmWidth; + // and update the label's width to reflect the scaling. + fmWidth = charWidth; + } + + charOffset = (int) ((charWidth - fmWidth) / 2f); + + if (row_annotations[column].colour == null) + { + gg.setColor(Color.black); + } + else + { + gg.setColor(row_annotations[column].colour); + } + + /* + * draw the label, unless it is the same secondary structure + * symbol (excluding RNA Helix) as the previous column + */ + final int xPos = (x * charWidth) + charOffset; + final int yPos = y + iconOffset; + + /* + * translate to drawing position _before_ applying any scaling + */ + gg.translate(xPos, yPos); + if (scaledToFit) + { + /* + * use a scaling transform to make the label narrower + * (JalviewJS doesn't have Font.deriveFont(AffineTransform)) + */ + gg.transform( + AffineTransform.getScaleInstance(fmScaling, 1.0)); + } + if (column == 0 || row.graph > 0) + { + gg.drawString(displayChar, 0, 0); + } + else if (row_annotations[column - 1] == null || (labelAllCols + || !displayChar.equals( + row_annotations[column - 1].displayCharacter) + || (displayChar.length() < 2 + && row_annotations[column].secondaryStructure == ' '))) + { + gg.drawString(displayChar, 0, 0); + } + if (scaledToFit) + { + /* + * undo scaling before translating back + * (restoring saved transform does NOT work in JS PDFGraphics!) + */ + gg.transform(AffineTransform + .getScaleInstance(1D / fmScaling, 1.0)); + } + gg.translate(-xPos, -yPos); } - g.setFont(ofont); } - } - if (row.hasIcons) - { - char ss = validRes ? row_annotations[column].secondaryStructure - : '-'; - - if (ss == '(') + if (row.hasIcons) { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf(')') > -1) + char ss = validRes ? row_annotations[column].secondaryStructure + : '-'; + + if (ss == '(') { - - ss = ')'; - + // distinguish between forward/backward base-pairing + if (displayChar.indexOf(')') > -1) + { + + ss = ')'; + + } } - } - if (ss == '[') - { - if ((row_annotations[column].displayCharacter.indexOf(']') > -1)) + if (ss == '[') { + if ((displayChar.indexOf(']') > -1)) + { ss = ']'; - - + + } } - } - if (ss == '{') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('}') > -1) - { - ss = '}'; - - - } - } - if (ss == '<') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('<') > -1) - { - ss = '>'; - - - } - } - if (ss == 'A') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('a') > -1) - { - ss = 'a'; - - - } - } - - if (ss == 'B') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('b') > -1) - { - ss = 'b'; - - } - } - - if (ss == 'C') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('c') > -1) - { - ss = 'c'; - - } - } - if (ss == 'D') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('d') > -1) - { - ss = 'd'; - - } - } - if (ss == '1') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('e') > -1) - { - ss = 'e'; - - } - } - if (ss == 'F') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('f') > -1) - { - ss = 'f'; - - } - } - if (ss == 'G') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('g') > -1) - { - ss = 'g'; - - } - } - if (ss == '2') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('h') > -1) - { - ss = 'h'; - - } - } - if (ss == 'I') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('i') > -1) - { - ss = 'i'; - - } - } - if (ss == 'J') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('j') > -1) - { - ss = 'j'; - - } - } - if (ss == 'K') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('k') > -1) - { - ss = 'k'; - - } - } - if (ss == 'L') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('l') > -1) - { - ss = 'l'; - - } - } - if (ss == 'M') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('m') > -1) - { - ss = 'm'; - - } - } - if (ss == 'N') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('n') > -1) - { - ss = 'n'; - - } - } - if (ss == 'O') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('o') > -1) - { - ss = 'o'; - - } - } - if (ss == 'P') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('p') > -1) - { - ss = 'p'; - - } - } - if (ss == 'Q') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('q') > -1) - { - ss = 'q'; - - } - } - if (ss == 'R') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('r') > -1) - { - ss = 'r'; - - } - } - if (ss == 'S') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('s') > -1) - { - ss = 's'; - - } - } - if (ss == 'T') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('t') > -1) - { - ss = 't'; - - } - } - if (ss == 'U') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('u') > -1) - { - ss = 'u'; - - } - } - if (ss == 'V') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('v') > -1) - { - ss = 'v'; - - } - } - if (ss == 'W') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('w') > -1) - { - ss = 'w'; - - } - } - if (ss == 'X') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('x') > -1) - { - ss = 'x'; - - } - } - if (ss == 'Y') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('y') > -1) - { - ss = 'y'; - - } - } - if (ss == 'Z') - { - // distinguish between forward/backward base-pairing - if (row_annotations[column].displayCharacter.indexOf('z') > -1) - { - ss = 'z'; - - } - } - if (!validRes || (ss != lastSS)) - { - if (x > -1) + if (ss == '{') { - switch (lastSS) + // distinguish between forward/backward base-pairing + if (displayChar.indexOf('}') > -1) { - case 'H': - drawHelixAnnot(g, row_annotations, lastSSX, x, y, - iconOffset, startRes, column, validRes, validEnd); - break; - - case 'E': - 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); -// case 'S': // Stem case for RNA secondary structure -// case 's': // and opposite direction -// drawStemAnnot(g, row_annotations, lastSSX, x, y, -// iconOffset, startRes, column, validRes, validEnd); - break; - case '{': - case '}': - case '[': - case ']': - case '>': - case '<': - case 'A': - case 'a': - case 'B': - case 'b': - case 'C': - case 'c': - case 'D': - case 'd': - case '1': - case 'e': - case 'F': - case 'f': - case 'G': - case 'g': - case '2': - case 'h': - case 'I': - case 'i': - case 'J': - case 'j': - case 'K': - case 'k': - case 'L': - case 'l': - case 'M': - case 'm': - case 'N': - case 'n': - case 'O': - case 'o': - case 'P': - case 'p': - case 'Q': - case 'q': - case 'R': - case 'r': - case 'S': - case 's': - case 'T': - case 't': - case 'U': - case 'u': - case 'V': - case 'v': - case 'W': - case 'w': - case 'X': - case 'x': - case 'Y': - case 'y': - case 'Z': - case 'z': - //System.out.println(lastSS); - Color nonCanColor= getNotCanonicalColor(lastSS); - drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX, x, y, iconOffset, startRes, - column, validRes, validEnd); - break; - default: - g.setColor(Color.gray); - g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - - lastSSX, 2); - - break; + ss = '}'; + } } - if (validRes) + if (ss == '<') { - lastSS = ss; + // distinguish between forward/backward base-pairing + if (displayChar.indexOf('<') > -1) + { + ss = '>'; + + } } - else + if (isRNA && (ss >= CHAR_A) && (ss <= CHAR_Z)) { - lastSS = ' '; + // distinguish between forward/backward base-pairing + int ssLowerCase = ss + UPPER_TO_LOWER; + // TODO would .equals() be safer here? or charAt(0)? + if (displayChar.indexOf(ssLowerCase) > -1) + { + ss = (char) ssLowerCase; + } } - if (x > -1) + + if (!validRes || (ss != lastSS)) { - lastSSX = (x * charWidth); + + if (x > -1) + { + + // int nb_annot = x - temp; + // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre + // annot :"+nb_annot); + switch (lastSS) + { + 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; + 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 '[': + case ']': + case '>': + case '<': + case 'A': + case 'a': + case 'B': + case 'b': + case 'C': + case 'c': + case 'D': + case 'd': + case 'e': + case 'F': + case 'f': + case 'G': + case 'g': + case 'h': + case 'I': + case 'i': + case 'J': + case 'j': + case 'K': + case 'k': + case 'L': + case 'l': + case 'M': + case 'm': + case 'N': + case 'n': + case 'O': + case 'o': + case 'P': + case 'p': + case 'Q': + case 'q': + case 'R': + case 'r': + case 'S': + case 's': + case 'T': + case 't': + case 'U': + case 'u': + case 'V': + case 'v': + case 'W': + case 'w': + case 'X': + case 'x': + case 'Y': + case 'y': + case 'Z': + case 'z': + + Color nonCanColor = getNotCanonicalColor(lastSS); + drawNotCanonicalAnnot(g, nonCanColor, row_annotations, + lastSSX, x, y, iconOffset, startRes, column, + validRes, validEnd); + // temp = x; + break; + default: + g.setColor(Color.gray); + g.fillRect(lastSSX, y + 6 + iconOffset, + (x * charWidth) - lastSSX, 2); + // temp = x; + break; + } + } + if (validRes) + { + lastSS = ss; + } + else + { + lastSS = ' '; + } + if (x > -1) + { + lastSSX = (x * charWidth); + } } } + column++; + x++; } - column++; - x++; - } - if (column >= row_annotations.length) - { - column = row_annotations.length - 1; - validEnd = false; - } - else - { - validEnd = true; - } - if ((row_annotations == null) || (row_annotations.length <= column) - || (row_annotations[column] == null)) - { - validRes = false; - } - else - { - validRes = true; - } - - // x ++; + if (column >= row_annotations.length) + { + column = row_annotations.length - 1; + validEnd = false; + } + else + { + validEnd = true; + } + if ((row_annotations == null) || (row_annotations.length <= column) + || (row_annotations[column] == null)) + { + validRes = false; + } + else + { + validRes = true; + } + // x ++; - if (row.hasIcons) - { - switch (lastSS) + if (row.hasIcons) { - case 'H': - drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); - break; - - case 'E': - drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); - break; - case 's': - case 'S': // Stem case for RNA secondary structure - drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset, - startRes, column, validRes, validEnd); - break; - case '{': - case '}': - case '[': - case ']': - case '>': - case '<': - case 'A': - case 'a': - case 'B': - case 'b': - case 'C': - case 'c': - case 'D': - case 'd': - case '1': - case 'e': - case 'F': - case 'f': - case 'G': - case 'g': - case '2': - case 'h': - case 'I': - case 'i': - case 'J': - case 'j': - case 'K': - case 'k': - case 'L': - case 'l': - case 'M': - case 'm': - case 'N': - case 'n': - case 'O': - case 'o': - case 'P': - case 'p': - case 'Q': - case 'q': - case 'R': - case 'r': - case 'T': - case 't': - case 'U': - case 'u': - case 'V': - case 'v': - case 'W': - case 'w': - case 'X': - case 'x': - case 'Y': - case 'y': - case 'Z': - case 'z': - //System.out.println(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); - break; + switch (lastSS) + { + + 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); + + break; + case '{': + case '}': + case '[': + case ']': + case '>': + case '<': + case 'A': + case 'a': + case 'B': + case 'b': + case 'C': + case 'c': + case 'D': + case 'd': + case 'e': + case 'F': + case 'f': + case 'G': + case 'g': + case 'h': + case 'I': + case 'i': + case 'J': + case 'j': + case 'K': + case 'k': + case 'L': + case 'l': + case 'M': + case 'm': + case 'N': + case 'n': + case 'O': + case 'o': + case 'P': + case 'p': + case 'Q': + case 'q': + case 'R': + case 'r': + case 'T': + case 't': + case 'U': + case 'u': + case 'V': + case 'v': + case 'W': + case 'w': + case 'X': + case 'x': + case 'Y': + case 'y': + case 'Z': + case 'z': + // System.out.println(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); + break; + } } - } - if (row.graph > 0 && row.graphHeight > 0) - { - if (row.graph == AlignmentAnnotation.LINE_GRAPH) + if (row.graph > 0 && row.graphHeight > 0) { - if (row.graphGroup > -1 && !graphGroupDrawn[row.graphGroup]) + if (row.graph == AlignmentAnnotation.LINE_GRAPH) { - float groupmax = -999999, groupmin = 9999999; - for (int gg = 0; gg < aa.length; gg++) + if (row.graphGroup > -1 && !graphGroupDrawn.get(row.graphGroup)) { - if (aa[gg].graphGroup != row.graphGroup) + // TODO: JAL-1291 revise rendering model so the graphGroup map is + // computed efficiently for all visible labels + float groupmax = -999999, groupmin = 9999999; + for (int gg = 0; gg < aa.length; gg++) { - continue; - } + if (aa[gg].graphGroup != row.graphGroup) + { + continue; + } - if (aa[gg] != row) - { - aa[gg].visible = false; - } - if (aa[gg].graphMax > groupmax) - { - groupmax = aa[gg].graphMax; + if (aa[gg] != row) + { + aa[gg].visible = false; + } + if (aa[gg].graphMax > groupmax) + { + groupmax = aa[gg].graphMax; + } + if (aa[gg].graphMin < groupmin) + { + groupmin = aa[gg].graphMin; + } } - if (aa[gg].graphMin < groupmin) + + for (int gg = 0; gg < aa.length; gg++) { - groupmin = aa[gg].graphMin; + if (aa[gg].graphGroup == row.graphGroup) + { + drawLineGraph(g, aa[gg], aa[gg].annotations, startRes, + endRes, y, groupmin, groupmax, row.graphHeight); + } } - } - for (int gg = 0; gg < aa.length; gg++) + graphGroupDrawn.set(row.graphGroup); + } + else { - if (aa[gg].graphGroup == row.graphGroup) - { - drawLineGraph(g, aa[gg], aa[gg].annotations, startRes, - endRes, y, groupmin, groupmax, row.graphHeight); - } + drawLineGraph(g, row, row_annotations, startRes, endRes, y, + row.graphMin, row.graphMax, row.graphHeight); } - - graphGroupDrawn[row.graphGroup] = true; + } + else if (row.graph == AlignmentAnnotation.BAR_GRAPH) + { + drawBarGraph(g, row, row_annotations, startRes, endRes, + row.graphMin, row.graphMax, y, renderHistogram, + renderProfile, normaliseProfile); } else { - drawLineGraph(g, row, row_annotations, startRes, endRes, y, - row.graphMin, row.graphMax, row.graphHeight); + 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); + } + if (debugRedraw) + { + if (renderer == null) + { + System.err.println("No renderer found for " + + row.toString()); + } + else + { + System.err.println("rendered with " + + renderer.getClass().toString()); + } + } + } } - else if (row.graph == AlignmentAnnotation.BAR_GRAPH) + } + else + { + if (clipst && !clipend) { - drawBarGraph(g, row, row_annotations, startRes, endRes, - row.graphMin, row.graphMax, y); + clipend = true; } - } - + } // end if_in_visible_region if (row.graph > 0 && row.hasText) { y += charHeight; @@ -1082,63 +1116,87 @@ public class AnnotationRenderer y += aa[i].height; } } + if (debugRedraw) + { + if (canClip) + { + if (clipst) + { + System.err.println( + "Start clip at : " + yfrom + " (index " + f_i + ")"); + } + if (clipend) + { + System.err.println( + "End clip at : " + yto + " (index " + f_to + ")"); + } + } + ; + System.err.println("Annotation Rendering time:" + + (System.currentTimeMillis() - stime)); + } + ; + 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; - - private Color sdNOTCANONICAL_COLOUR; + public static final Color STEM_COLOUR = Color.blue; - public void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, - int x, int y, int iconOffset, int startRes, int column, - boolean validRes, boolean validEnd) + // private Color sdNOTCANONICAL_COLOUR; + + void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, int x, + int y, int iconOffset, int startRes, int column, boolean validRes, + boolean validEnd) { g.setColor(GLYPHLINE_COLOR); g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2); } - public void drawSheetAnnot(Graphics g, Annotation[] row, int lastSSX, - int x, int y, int iconOffset, int startRes, int column, - boolean validRes, boolean validEnd) + void drawSheetAnnot(Graphics g, Annotation[] row, + + 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) }, + g.fillRect(lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX - 4, + 7); + g.fillPolygon( + new int[] + { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) }, new int[] { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset }, 3); } else { - g.fillRect(lastSSX, y + 4 + iconOffset, - (x + 1) * charWidth - lastSSX, 7); + g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth - lastSSX, + 7); } } - 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) { int ofs = charWidth / 2; // Off by 1 offset when drawing rects and ovals @@ -1162,8 +1220,8 @@ public class AnnotationRenderer else { // g.setColor(Color.magenta); - g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs - + 1, 8, 0, 0); + g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, + x2 - x1 - ofs + 1, 8, 0, 0); } @@ -1188,9 +1246,9 @@ public class AnnotationRenderer g.fillRect(x1, y + 4 + 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) { @@ -1234,7 +1292,7 @@ public class AnnotationRenderer column = sRes + x; if (hasHiddenColumns) { - column = columnSelection.adjustForHiddenColumns(column); + column = hiddenColumns.visibleToAbsoluteColumn(column); } if (column > aaMax) @@ -1250,17 +1308,21 @@ public class AnnotationRenderer } if (aa_annotations[column].colour == null) + { g.setColor(Color.black); + } else + { g.setColor(aa_annotations[column].colour); + } - y1 = y - - (int) (((aa_annotations[column - 1].value - min) / range) * graphHeight); - y2 = y - - (int) (((aa_annotations[column].value - min) / range) * graphHeight); + y1 = y - (int) (((aa_annotations[column - 1].value - min) / range) + * graphHeight); + y2 = y - (int) (((aa_annotations[column].value - min) / range) + * graphHeight); - g.drawLine(x * charWidth - charWidth / 2, y1, x * charWidth - + charWidth / 2, y2); + g.drawLine(x * charWidth - charWidth / 2, y1, + x * charWidth + charWidth / 2, y2); x++; } @@ -1278,9 +1340,11 @@ public class AnnotationRenderer } } - public void drawBarGraph(Graphics g, AlignmentAnnotation _aa, + @SuppressWarnings("unused") + void drawBarGraph(Graphics g, AlignmentAnnotation _aa, Annotation[] aa_annotations, int sRes, int eRes, float min, - float max, int y) + float max, int y, boolean renderHistogram, boolean renderProfile, + boolean normaliseProfile) { if (sRes > aa_annotations.length) { @@ -1304,29 +1368,12 @@ public class AnnotationRenderer int column; int aaMax = aa_annotations.length - 1; - boolean renderHistogram = true, renderProfile = true, normaliseProfile = false; - // if (aa.autoCalculated && aa.label.startsWith("Consensus")) - { - // TODO: generalise this to have render styles for consensus/profile data - if (_aa.groupRef != null) - { - renderHistogram = _aa.groupRef.isShowConsensusHistogram(); - renderProfile = _aa.groupRef.isShowSequenceLogo(); - normaliseProfile = _aa.groupRef.isNormaliseSequenceLogo(); - } - else - { - renderHistogram = av_renderHistogram; - renderProfile = av_renderProfile; - normaliseProfile = av_normaliseProfile; - } - } while (x < eRes - sRes) { column = sRes + x; if (hasHiddenColumns) { - column = columnSelection.adjustForHiddenColumns(column); + column = hiddenColumns.visibleToAbsoluteColumn(column); } if (column > aaMax) @@ -1340,12 +1387,16 @@ 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) { @@ -1362,69 +1413,148 @@ public class AnnotationRenderer 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); + // System.out.println(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); + + // 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()); + + 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++; @@ -1437,8 +1567,8 @@ public class AnnotationRenderer BasicStroke.JOIN_ROUND, 3f, new float[] { 5f, 3f }, 0f)); - y2 = (int) (y - ((_aa.threshold.value - min) / range) - * _aa.graphHeight); + y2 = (int) (y + - ((_aa.threshold.value - min) / range) * _aa.graphHeight); g.drawLine(0, y2, (eRes - sRes) * charWidth, y2); g2.setStroke(new BasicStroke()); } @@ -1460,9 +1590,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) @@ -1476,134 +1610,130 @@ public class AnnotationRenderer } } - Color getNotCanonicalColor(char lastss) - { - switch (lastss) - { - case '{': - case '}': - return Color.cyan; - - case '[': - case ']': - return Color.green; - - case '>': - case '<': - return Color.magenta; - - case 'A': - case 'a': - return Color.orange; - - case 'B': - case 'b': - return Color.pink; - - case 'C': - case 'c': - return Color.red; - - case 'D': - case 'd': - return Color.yellow; - - case '1': - case 'e': - return Color.black; - - case 'F': - case 'f': - return Color.darkGray; - - case 'G': - case 'g': - return Color.gray; - - case '2': - case 'h': - return Color.lightGray; - - case 'I': - case 'i': - return Color.white; - - case 'J': - case 'j': - return Color.cyan; - - case 'K': - case 'k': - return Color.magenta; - - case 'L': - case 'l': - return Color.orange; - - case 'M': - case 'm': - return Color.red; - - case 'N': - case 'n': - return Color.yellow; - - case 'O': - case 'o': - return Color.pink; - - case 'P': - case 'p': - return Color.black; - - case 'Q': - case 'q': - return Color.blue; - - case 'R': - case 'r': - return Color.cyan; - - case 'S': - case 's': - return Color.magenta; - - case 'T': - case 't': - return Color.darkGray; - - case 'U': - case 'u': - return Color.yellow; - - case 'V': - case 'v': - return Color.blue; - - case 'W': - case 'w': - return Color.orange; - - case 'X': - case 'x': - return Color.magenta; - - case 'Y': - case 'y': - return Color.blue; - - case 'Z': - case 'z': - return Color.blue; - - default : - System.out.println("This is not a interaction"); - return null; - - } - } -} + { + switch (lastss) + { + case '{': + case '}': + return new Color(255, 125, 5); + + case '[': + case ']': + return new Color(245, 115, 10); + + case '>': + case '<': + return new Color(235, 135, 15); + + case 'A': + case 'a': + return new Color(225, 105, 20); - - + case 'B': + case 'b': + return new Color(215, 145, 30); + + case 'C': + case 'c': + return new Color(205, 95, 35); + + case 'D': + case 'd': + return new Color(195, 155, 45); + + case 'E': + case 'e': + return new Color(185, 85, 55); + + case 'F': + case 'f': + return new Color(175, 165, 65); + + case 'G': + case 'g': + return new Color(170, 75, 75); + + case 'H': + case 'h': + return new Color(160, 175, 85); + + case 'I': + case 'i': + return new Color(150, 65, 95); + + case 'J': + case 'j': + return new Color(140, 185, 105); + + case 'K': + case 'k': + return new Color(130, 55, 110); + + case 'L': + case 'l': + return new Color(120, 195, 120); + + case 'M': + case 'm': + return new Color(110, 45, 130); + + case 'N': + case 'n': + return new Color(100, 205, 140); + + case 'O': + case 'o': + return new Color(90, 35, 150); + + case 'P': + case 'p': + return new Color(85, 215, 160); + + case 'Q': + case 'q': + return new Color(75, 25, 170); + + case 'R': + case 'r': + return new Color(65, 225, 180); + + case 'S': + case 's': + return new Color(55, 15, 185); + + case 'T': + case 't': + return new Color(45, 235, 195); + + case 'U': + case 'u': + return new Color(35, 5, 205); + + case 'V': + case 'v': + return new Color(25, 245, 215); + + case 'W': + case 'w': + return new Color(15, 0, 225); + + case 'X': + case 'x': + return new Color(10, 255, 235); + + case 'Y': + case 'y': + return new Color(5, 150, 245); + + case 'Z': + case 'z': + return new Color(0, 80, 255); + + default: + System.out.println("This is not a interaction : " + lastss); + return null; + + } + } +}