--- /dev/null
+package jalview.renderer;
+
+import jalview.analysis.AAFrequency;
+import jalview.analysis.StructureFrequency;
+import jalview.api.AlignViewportI;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.ColumnSelection;
+import jalview.schemes.ColourSchemeI;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+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.Hashtable;
+
+import com.stevesoft.pat.Regex;
+
+public class AnnotationRenderer
+{
+
+ public AnnotationRenderer()
+ {
+ // TODO Auto-generated constructor stub
+ }
+
+ public void drawStemAnnot(Graphics g, AlignmentAnnotation row, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd)
+ {
+ g.setColor(STEM_COLOUR);
+ int sCol = (lastSSX / charWidth) + startRes;
+ int x1 = lastSSX;
+ int x2 = (x * charWidth);
+ Regex closeparen = new Regex("(\\))");
+
+ String dc = column == 0 ? ""
+ : row.annotations[column - 1].displayCharacter;
+
+ boolean diffupstream = sCol == 0 || row.annotations[sCol - 1] == null
+ || !dc.equals(row.annotations[sCol - 1].displayCharacter);
+ boolean diffdownstream = !validRes || !validEnd
+ || row.annotations[column] == null
+ || !dc.equals(row.annotations[column].displayCharacter);
+ // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
+ // If a closing base pair half of the stem, display a backward arrow
+ if (column > 0 && closeparen.search(dc))
+ {
+ if (diffupstream)
+ // if (validRes && column>1 && row.annotations[column-2]!=null &&
+ // dc.equals(row.annotations[column-2].displayCharacter))
+ {
+ g.fillPolygon(new int[]
+ { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
+ { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+ x1 += 5;
+ }
+ if (diffdownstream)
+ {
+ x2 -= 1;
+ }
+ }
+ else
+ {
+ // display a forward arrow
+ if (diffdownstream)
+ {
+ g.fillPolygon(new int[]
+ { x2 - 5, x2 - 5, x2 }, new int[]
+ { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+ x2 -= 5;
+ }
+ if (diffupstream)
+ {
+ x1 += 1;
+ }
+ }
+ // draw arrow body
+ g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ }
+ private int charWidth,endRes,charHeight;
+ private boolean validCharWidth, hasHiddenColumns;
+ private FontMetrics fm;
+ private 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 updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI av)
+ public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel, AlignViewportI av)
+ {
+ fm = annotPanel.getFontMetrics();
+ annotationPanel = annotPanel;
+ fadedImage=annotPanel.getFadedImage();
+ imgWidth=annotPanel.getFadedImageWidth();
+ updateFromAlignViewport(av);
+ }
+ public void updateFromAlignViewport(AlignViewportI av)
+ {
+ charWidth = av.getCharWidth();
+ endRes = av.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)
+ {
+ // 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();
+ }
+ columnSelection = av.getColumnSelection();
+ hconsensus = av.getSequenceConsensusHash();//hconsensus;
+ hStrucConsensus = av.getRnaStructureConsensusHash(); //hStrucConsensus;
+ av_ignoreGapsConsensus=av.getIgnoreGapsConsensus();
+ }
+ public 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.groupRef != null && aa.groupRef.consensusData != null
+ && aa.groupRef.isShowSequenceLogo())
+ {
+ return AAFrequency.extractProfile(
+ aa.groupRef.consensusData[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)
+ {
+ return AAFrequency.extractProfile(hconsensus[column], av_ignoreGapsConsensus);
+ }
+ }
+ else
+ {
+ if (aa.autoCalculated && aa.label.startsWith("StrucConsensus"))
+ {
+ if (aa.groupRef != null && aa.groupRef.consensusData != null
+ && aa.groupRef.isShowSequenceLogo())
+ {
+ //TODO check what happens for group selections
+ return StructureFrequency.extractProfile(
+ aa.groupRef.consensusData[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)
+ {
+ return StructureFrequency.extractProfile(hStrucConsensus[column],
+ av_ignoreGapsConsensus);
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param annotationPanel TODO
+ * @param g
+ * DOCUMENT ME!
+ * @param startRes
+ * DOCUMENT ME!
+ * @param endRes
+ * DOCUMENT ME!
+ */
+ public void drawComponent(AwtRenderPanelI annotPanel, AlignViewportI av, Graphics g, int activeRow, int startRes, int endRes)
+ {
+ // NOTES:
+ // AnnotationPanel needs to implement: ImageObserver, access to AlignViewport
+ updateFromAwtRenderPanel(annotPanel, av);
+ AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
+
+ int x = 0, y = 0;
+ int column = 0;
+ char lastSS;
+ int lastSSX;
+ int iconOffset = 0;
+ boolean validRes = false;
+ boolean validEnd = false;
+ boolean labelAllCols = false;
+ boolean centreColLabels, centreColLabelsDef = av
+ .getCentreColumnLabels();
+ boolean scaleColLabel = false;
+ boolean[] graphGroupDrawn = new boolean[aa.length];
+ 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
+ for (int i = 0; i < aa.length; i++)
+ {
+ AlignmentAnnotation row = aa[i];
+
+ if (!row.visible)
+ {
+ continue;
+ }
+ 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)
+ {
+ iconOffset = charHeight - fm.getDescent();
+ y -= charHeight;
+ }
+ }
+ else if (row.hasText)
+ {
+ iconOffset = charHeight - fm.getDescent();
+
+ }
+ else
+ {
+ iconOffset = 0;
+ }
+
+ if (aa[i].autoCalculated && av.isCalculationInProgress(aa[i]))
+ {
+ y += charHeight;
+
+ 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);
+
+ continue;
+ }
+
+/* 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;
+ }
+ }
+ else
+ {
+ column = startRes + x;
+ }
+
+ if ((row.annotations == null) || (row.annotations.length <= column)
+ || (row.annotations[column] == null))
+ {
+ validRes = false;
+ }
+ else
+ {
+ validRes = true;
+ }
+ if (x > -1)
+ {
+ if (activeRow == i)
+ {
+ g.setColor(Color.red);
+
+ if (columnSelection != null)
+ {
+ for (int n = 0; n < columnSelection.size(); n++)
+ {
+ int v = columnSelection.columnAt(n);
+
+ if (v == column)
+ {
+ g.fillRect(x * charWidth, y, charWidth,
+ charHeight);
+ }
+ }
+ }
+ }
+
+ if (validCharWidth
+ && validRes
+ && row.annotations[column].displayCharacter != null
+ && (row.annotations[column].displayCharacter.length() > 0))
+ {
+
+ if (centreColLabels || scaleColLabel)
+ {
+ fmWidth = (float) fm.charsWidth(
+ row.annotations[column].displayCharacter
+ .toCharArray(), 0,
+ row.annotations[column].displayCharacter.length());
+
+ 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 = (float) 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);
+ }
+ }
+ if (row.hasIcons)
+ {
+ char ss = validRes ? row.annotations[column].secondaryStructure
+ : ' ';
+ if (ss == 'S')
+ {
+ // distinguish between forward/backward base-pairing
+ if (row.annotations[column].displayCharacter.indexOf(')') > -1)
+ {
+ ss = 's';
+ }
+ }
+ if (!validRes || (ss != lastSS))
+ {
+ if (x > -1)
+ {
+ switch (lastSS)
+ {
+ case 'H':
+ drawHelixAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
+ column, validRes, validEnd);
+ break;
+
+ case 'E':
+ drawSheetAnnot(g, row, 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, 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;
+ }
+ }
+ 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;
+ }
+
+ // x ++;
+
+ if (row.hasIcons)
+ {
+ switch (lastSS)
+ {
+ case 'H':
+ drawHelixAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
+ column, validRes, validEnd);
+ break;
+
+ case 'E':
+ drawSheetAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
+ column, validRes, validEnd);
+ break;
+ case 's':
+ case 'S': // Stem case for RNA secondary structure
+ drawStemAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
+ column, validRes, validEnd);
+ break;
+ default:
+ drawGlyphLine(g, row, lastSSX, x, y, iconOffset, startRes,
+ column, validRes, validEnd);
+ break;
+ }
+ }
+
+ if (row.graph > 0 && row.graphHeight > 0)
+ {
+ if (row.graph == AlignmentAnnotation.LINE_GRAPH)
+ {
+ if (row.graphGroup > -1 && !graphGroupDrawn[row.graphGroup])
+ {
+ float groupmax = -999999, groupmin = 9999999;
+ for (int gg = 0; gg < aa.length; gg++)
+ {
+ 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].graphMin < groupmin)
+ {
+ groupmin = aa[gg].graphMin;
+ }
+ }
+
+ for (int gg = 0; gg < aa.length; gg++)
+ {
+ if (aa[gg].graphGroup == row.graphGroup)
+ {
+ drawLineGraph(g, aa[gg], startRes, endRes, y, groupmin,
+ groupmax, row.graphHeight);
+ }
+ }
+
+ graphGroupDrawn[row.graphGroup] = true;
+ }
+ else
+ {
+ drawLineGraph( g, row, startRes, endRes, y, row.graphMin,
+ row.graphMax, row.graphHeight);
+ }
+ }
+ else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
+ {
+ drawBarGraph(g, row, startRes, endRes, row.graphMin,
+ row.graphMax, y);
+ }
+ }
+
+ if (row.graph > 0 && row.hasText)
+ {
+ y += charHeight;
+ }
+
+ if (row.graph == 0)
+ {
+ y += aa[i].height;
+ }
+ }
+ }
+
+ private Color GLYPHLINE_COLOR=Color.gray;
+ private Color SHEET_COLOUR=Color.green;
+ private Color HELIX_COLOUR=Color.red;
+ private Color STEM_COLOUR=Color.blue;
+
+
+ public void drawGlyphLine(Graphics g, AlignmentAnnotation 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, AlignmentAnnotation 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.annotations[column] == null
+ || row.annotations[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) }, new int[]
+ { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
+ 3);
+ }
+ else
+ {
+ g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth
+ - lastSSX, 7);
+ }
+
+ }
+
+ public void drawHelixAnnot(Graphics g, AlignmentAnnotation 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 x1 = lastSSX;
+ int x2 = (x * charWidth);
+
+ if (MAC)
+ {
+ int ofs = charWidth / 2;
+ // Off by 1 offset when drawing rects and ovals
+ // to offscreen image on the MAC
+ g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
+ if (sCol == 0 || row.annotations[sCol - 1] == null
+ || row.annotations[sCol - 1].secondaryStructure != 'H')
+ {
+ }
+ else
+ {
+ // g.setColor(Color.orange);
+ g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
+ 0, 0);
+ }
+ if (!validRes || row.annotations[column] == null
+ || row.annotations[column].secondaryStructure != 'H')
+ {
+
+ }
+ else
+ {
+ // g.setColor(Color.magenta);
+ g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs
+ + 1, 8, 0, 0);
+
+ }
+
+ return;
+ }
+
+ if (sCol == 0 || row.annotations[sCol - 1] == null
+ || row.annotations[sCol - 1].secondaryStructure != 'H')
+ {
+ g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
+ x1 += charWidth / 2;
+ }
+
+ if (!validRes || row.annotations[column] == null
+ || row.annotations[column].secondaryStructure != 'H')
+ {
+ g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset,
+ charWidth, 8, 270, 180);
+ x2 -= charWidth / 2;
+ }
+
+ g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
+ }
+
+ public void drawLineGraph(Graphics g, AlignmentAnnotation aa, int sRes, int eRes, int y, float min, float max, int graphHeight)
+ {
+ if (sRes > aa.annotations.length)
+ {
+ return;
+ }
+
+ int x = 0;
+
+ // Adjustment for fastpaint to left
+ if (eRes < endRes)
+ {
+ eRes++;
+ }
+
+ eRes = Math.min(eRes, aa.annotations.length);
+
+ if (sRes == 0)
+ {
+ x++;
+ }
+
+ int y1 = y, y2 = y;
+ float range = max - min;
+
+ // //Draw origin
+ if (min < 0)
+ {
+ y2 = y - (int) ((0 - min / range) * graphHeight);
+ }
+
+ g.setColor(Color.gray);
+ g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
+
+ eRes = Math.min(eRes, aa.annotations.length);
+
+ int column;
+ int aaMax = aa.annotations.length - 1;
+
+ while (x < eRes - sRes)
+ {
+ column = sRes + x;
+ if (hasHiddenColumns)
+ {
+ column = columnSelection.adjustForHiddenColumns(column);
+ }
+
+ if (column > aaMax)
+ {
+ break;
+ }
+
+ if (aa.annotations[column] == null
+ || aa.annotations[column - 1] == null)
+ {
+ x++;
+ continue;
+ }
+
+ 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);
+
+ g.drawLine(x * charWidth - charWidth / 2, y1, x * charWidth
+ + charWidth / 2, y2);
+ x++;
+ }
+
+ if (aa.threshold != null)
+ {
+ g.setColor(aa.threshold.colour);
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
+ BasicStroke.JOIN_ROUND, 3f, new float[]
+ { 5f, 3f }, 0f));
+
+ y2 = (int) (y - ((aa.threshold.value - min) / range) * graphHeight);
+ g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
+ g2.setStroke(new BasicStroke());
+ }
+ }
+
+ public void drawBarGraph(Graphics g, AlignmentAnnotation aa, int sRes, int eRes, float min, float max, int y)
+ {
+ if (sRes > aa.annotations.length)
+ {
+ return;
+ }
+ Font ofont = g.getFont();
+ eRes = Math.min(eRes, aa.annotations.length);
+
+ int x = 0, y1 = y, y2 = y;
+
+ float range = max - min;
+
+ if (min < 0)
+ {
+ y2 = y - (int) ((0 - min / (range)) * aa.graphHeight);
+ }
+
+ g.setColor(Color.gray);
+
+ g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
+
+ 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);
+ }
+
+ if (column > aaMax)
+ {
+ break;
+ }
+
+ if (aa.annotations[column] == null)
+ {
+ x++;
+ 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);
+
+ if (renderHistogram)
+ {
+ if (y1 - y2 > 0)
+ {
+ g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
+ }
+ else
+ {
+ g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
+ }
+ }
+ // draw profile if available
+ if (renderProfile && aa.annotations[column].value != 0)
+ {
+
+ int profl[] = getProfileFor(aa, column);
+ // just try to draw the logo if profl is not null
+ if (profl != null)
+ {
+
+ float ht = normaliseProfile ? y-aa.graphHeight : y1;
+ double htn = normaliseProfile ? aa.graphHeight : (y2 - y1);// aa.graphHeight;
+ float wdth;
+ double ht2 = 0;
+ char[] dc;
+
+ /**
+ * profl.length == 52 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
+ */
+ if (profl.length == 52)
+ {
+ 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; profl != null && c < profl[0];)
+ {
+ dc[0] = (char) profl[c++];
+
+ if (aa.label.startsWith("StrucConsensus"))
+ {
+ dc[1] = (char) profl[c++];
+ }
+
+ wdth = charWidth;
+ wdth /= (float) fm.charsWidth(dc, 0, dc.length);
+
+ ht += scl;
+ {
+ // if (aa.annotations[column].value==0) {
+ // g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(wdth,
+ // (ht2=(aa.graphHeight*0.1/av.charHeight)))));
+ // ht = y2-(int)ht2;
+ // } else {
+ scl=((double)htn)*scale* ((double) 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);
+
+ // htn -=ht2;
+ // }
+ // ? );// try to get a
+ // colourscheme for the
+ // group(aa.groupRef.cs==null)
+ // ? av.textColour2 :
+ // cs.findColour(dc));
+ // System.out.println(dc[0]);
+ // 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]));
+ // (av.globalColourScheme!=null)
+ g.drawChars(dc, 0, dc.length, x * charWidth,
+ (int) (ht + (scl-lm.getDescent()-lm.getBaselineOffsets()[lm.getBaselineIndex()])));
+ // ht+=g.getFontMetrics().getAscent()-g.getFontMetrics().getDescent();
+ }
+ }
+ g.setFont(ofont);
+ }
+ }
+ x++;
+ }
+ if (aa.threshold != null)
+ {
+ g.setColor(aa.threshold.colour);
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
+ BasicStroke.JOIN_ROUND, 3f, new float[]
+ { 5f, 3f }, 0f));
+
+ y2 = (int) (y - ((aa.threshold.value - min) / range) * 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, int width,
+ int y, int sRes, int eRes)
+ {
+ eRes = Math.min(eRes, aa.annotations.length);
+ g.setColor(Color.white);
+ g.fillRect(0, 0, width, y);
+ g.setColor(new Color(0, 0, 180));
+
+ int x = 0, height;
+
+ for (int j = sRes; j < eRes; j++)
+ {
+ 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)
+ {
+ height = y;
+ }
+
+ g.fillRect(x, y - height, charWidth, height);
+ }
+ x += charWidth;
+ }
+ }
+}
git://source.jalview.org / jalview.git / commitdiff