X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Frenderer%2FAnnotationRenderer.java;h=06014c5e3d9fa6c96bf98a17fef82d5a6b7af384;hb=0c0bbd65f29e9dcd63ec0f37427b6000fa1999f8;hp=8588bf2294d1ba18a4e667f321f507f290814458;hpb=3ee6dca1b1d8e60397f494c48f963cadf206567a;p=jalview.git diff --git a/src/jalview/renderer/AnnotationRenderer.java b/src/jalview/renderer/AnnotationRenderer.java index 8588bf2..06014c5 100644 --- a/src/jalview/renderer/AnnotationRenderer.java +++ b/src/jalview/renderer/AnnotationRenderer.java @@ -1,3 +1,23 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) + * Copyright (C) 2014 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. + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.renderer; import jalview.analysis.AAFrequency; @@ -18,16 +38,33 @@ 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 { + /** + * flag indicating if timing and redraw parameter info should be output + */ + private final boolean debugRedraw; public AnnotationRenderer() { - // TODO Auto-generated constructor stub + 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; } public void drawStemAnnot(Graphics g, Annotation[] row_annotations, @@ -52,6 +89,7 @@ public class AnnotationRenderer // 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)) @@ -68,6 +106,7 @@ public class AnnotationRenderer } else { + // display a forward arrow if (diffdownstream) { @@ -125,6 +164,89 @@ public class AnnotationRenderer */ 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 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); + + g.setColor(nonCanColor); + int sCol = (lastSSX / charWidth) + 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); + 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))// closeletter_b.search(dc)||closeletter_c.search(dc)||closeletter_d.search(dc)||closecrochet.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); + } + // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI // av) public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel, @@ -134,6 +256,26 @@ 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; + } + updateFromAlignViewport(av); } @@ -178,7 +320,7 @@ public class AnnotationRenderer } // 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); @@ -200,7 +342,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], @@ -213,6 +355,7 @@ public class AnnotationRenderer /** * Render the annotation rows associated with an alignment. + * * @param annotPanel * container frame * @param av @@ -225,19 +368,26 @@ public class AnnotationRenderer * first column that will be drawn * @param endRes * last column that will be drawn - * @return true if the fadedImage was used for any alignment annotation rows currently being calculated + * @return true if the fadedImage was used for any alignment annotation rows + * currently being calculated */ - public boolean drawComponent(AwtRenderPanelI annotPanel, AlignViewportI av, - Graphics g, int activeRow, int startRes, int endRes) + public boolean drawComponent(AwtRenderPanelI annotPanel, + AlignViewportI av, Graphics g, int activeRow, int startRes, + int endRes) { - boolean usedFaded=false; + long stime = System.currentTimeMillis(); + boolean usedFaded = false; // NOTES: // AnnotationPanel needs to implement: ImageObserver, access to // AlignViewport 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; @@ -249,16 +399,48 @@ public class AnnotationRenderer boolean centreColLabels, centreColLabelsDef = av .getCentreColumnLabels(); boolean scaleColLabel = false; - boolean[] graphGroupDrawn = new boolean[aa.length]; + AlignmentAnnotation consensusAnnot = av + .getAlignmentConsensusAnnotation(), structConsensusAnnot = av + .getAlignmentStrucConsensusAnnotation(); + boolean renderHistogram = true, renderProfile = true, normaliseProfile = false; + + 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]; - Annotation[] row_annotations=row.annotations; + { + // 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 + } + } + Annotation[] row_annotations = row.annotations; if (!row.visible) { continue; @@ -268,333 +450,530 @@ public class AnnotationRenderer 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 = columnSelection.adjustForHiddenColumns(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; + } + 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) + for (int n = 0; n < columnSelection.size(); n++) { - // 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; + int v = columnSelection.columnAt(n); + + if (v == column) + { + g.fillRect(x * charWidth, y, charWidth, charHeight); + } } } } - else + if (!row.isValidStruc()) { - fmWidth = fm - .charWidth(row_annotations[column].displayCharacter - .charAt(0)); + g.setColor(Color.orange); + g.fillRect((int) row.getInvalidStrucPos() * charWidth, y, + charWidth, charHeight); } - charOffset = (int) ((charWidth - fmWidth) / 2f); + if (validCharWidth + && validRes + && row_annotations[column].displayCharacter != null + && (row_annotations[column].displayCharacter.length() > 0)) + { - if (row_annotations[column].colour == null) - g.setColor(Color.black); - else - g.setColor(row_annotations[column].colour); + if (centreColLabels || scaleColLabel) + { + fmWidth = fm.charsWidth( + row_annotations[column].displayCharacter + .toCharArray(), 0, + row_annotations[column].displayCharacter.length()); - if (column == 0 || row.graph > 0) - { - g.drawString(row_annotations[column].displayCharacter, - (x * charWidth) + charOffset, y + iconOffset); - } - 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 == ' '))) - { - g.drawString(row_annotations[column].displayCharacter, x - * charWidth + charOffset, y + iconOffset); + 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; + } + } + } + else + { + fmWidth = fm + .charWidth(row_annotations[column].displayCharacter + .charAt(0)); + } + 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) + { + g.drawString(row_annotations[column].displayCharacter, + (x * charWidth) + charOffset, y + iconOffset); + } + 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 == ' '))) + { + g.drawString(row_annotations[column].displayCharacter, x + * charWidth + charOffset, y + iconOffset); + } + g.setFont(ofont); } - g.setFont(ofont); } - } - if (row.hasIcons) - { - char ss = validRes ? row_annotations[column].secondaryStructure - : ' '; - if (ss == 'S') + 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 = 's'; + // distinguish between forward/backward base-pairing + if (row_annotations[column].displayCharacter.indexOf(')') > -1) + { + + ss = ')'; + + } } - } - if (!validRes || (ss != lastSS)) - { - if (x > -1) + if (ss == '[') { - switch (lastSS) + if ((row_annotations[column].displayCharacter.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 '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; - - 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 (row_annotations[column].displayCharacter.indexOf('}') > -1) + { + ss = '}'; + + } } - else + if (ss == '<') + { + // distinguish between forward/backward base-pairing + if (row_annotations[column].displayCharacter.indexOf('<') > -1) + { + ss = '>'; + + } + } + if (ss >= 65) { - lastSS = ' '; + // distinguish between forward/backward base-pairing + if (row_annotations[column].displayCharacter.indexOf(ss + 32) > -1) + { + + ss = (char) (ss + 32); + + } } - 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 '$': + 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; + 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 'e': + case 'F': + case 'f': + case 'G': + case 'g': + case 'H': + 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++; + } + 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; } - 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 ++; + // 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; - default: - drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset, startRes, - column, validRes, validEnd); - break; + switch (lastSS) + { + case '$': + drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset, + startRes, column, validRes, validEnd); + break; + + case '�': + 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 'E': + case 'e': + case 'F': + case 'f': + case 'G': + case 'g': + case 'H': + 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] != 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].graphMax > groupmax) + for (int gg = 0; gg < aa.length; gg++) { - groupmax = aa[gg].graphMax; - } - if (aa[gg].graphMin < groupmin) - { - 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 + else if (row.graph == AlignmentAnnotation.BAR_GRAPH) { - drawLineGraph(g, row, row_annotations, startRes, endRes, y, row.graphMin, - row.graphMax, row.graphHeight); + drawBarGraph(g, row, row_annotations, startRes, endRes, + row.graphMin, row.graphMax, y, renderHistogram, + renderProfile, normaliseProfile); } } - 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; @@ -605,6 +984,27 @@ 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; } @@ -616,21 +1016,24 @@ public class AnnotationRenderer private 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; + + public 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) + + 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 + if (!validEnd || !validRes || row == null || row[column] == null || row[column].secondaryStructure != 'E') { g.fillRect(lastSSX, y + 4 + iconOffset, @@ -649,9 +1052,9 @@ public class AnnotationRenderer } - public void drawHelixAnnot(Graphics g, Annotation[] row, - int lastSSX, int x, int y, int iconOffset, int startRes, - int column, boolean validRes, boolean validEnd) + public 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); @@ -709,8 +1112,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) + public 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) { @@ -798,8 +1202,10 @@ public class AnnotationRenderer } } - public void drawBarGraph(Graphics g, AlignmentAnnotation _aa, Annotation[] aa_annotations, int sRes, - int eRes, float min, float max, int y) + public 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) { if (sRes > aa_annotations.length) { @@ -823,23 +1229,6 @@ 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; @@ -935,7 +1324,7 @@ public class AnnotationRenderer // 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)); + g.setColor(profcolour.findColour(dc[0], column, null)); hght = (ht + (scl - lm.getDescent() - lm.getBaselineOffsets()[lm .getBaselineIndex()])); @@ -956,15 +1345,16 @@ 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()); } } // used by overview window - public void drawGraph(Graphics g, AlignmentAnnotation _aa, Annotation[] aa_annotations, int width, - int y, int sRes, int eRes) + public void drawGraph(Graphics g, AlignmentAnnotation _aa, + Annotation[] aa_annotations, int width, int y, int sRes, int eRes) { eRes = Math.min(eRes, aa_annotations.length); g.setColor(Color.white); @@ -993,4 +1383,131 @@ public class AnnotationRenderer x += charWidth; } } + + Color getNotCanonicalColor(char lastss) + { + 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; + + } + } }