*/
package jalview.renderer;
+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.RenderingHints;
+import java.awt.Stroke;
+import java.awt.geom.AffineTransform;
+import java.awt.image.ImageObserver;
+import java.util.BitSet;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import org.jfree.graphics2d.svg.SVGGraphics2D;
+import org.jibble.epsgraphics.EpsGraphics2D;
+
import jalview.analysis.AAFrequency;
import jalview.analysis.CodingUtils;
import jalview.analysis.Rna;
import jalview.analysis.StructureFrequency;
import jalview.api.AlignViewportI;
+import jalview.bin.Cache;
+import jalview.bin.Console;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.ProfilesI;
+import jalview.datamodel.annotations.AnnotationColouringI;
+import jalview.renderer.api.AnnotationRendererFactoryI;
+import jalview.renderer.api.AnnotationRowRendererI;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.NucleotideColourScheme;
import jalview.schemes.ResidueProperties;
import jalview.schemes.ZappoColourScheme;
import jalview.util.Platform;
-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.geom.AffineTransform;
-import java.awt.image.ImageObserver;
-import java.util.BitSet;
-import java.util.Hashtable;
-
public class AnnotationRenderer
{
private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32
private boolean av_ignoreGapsConsensus;
+ private boolean renderingVectors = false;
+
+ private boolean glyphLineDrawn = false;
+
/**
* attributes set from AwtRenderPanelI
*/
*/
private boolean canClip = false;
+ /**
+ * Property to set text antialiasing method
+ */
+ private static final String TEXT_ANTIALIAS_METHOD = "TEXT_ANTIALIAS_METHOD";
+
+ private static final Object textAntialiasMethod;
+
+ static
+ {
+ final String textAntialiasMethodPref = Cache
+ .getDefault(TEXT_ANTIALIAS_METHOD, "GASP");
+ switch (textAntialiasMethodPref)
+ {
+ case "ON":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
+ break;
+ case "GASP":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
+ break;
+ case "LCD_HBGR":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR;
+ break;
+ case "LCD_HRGB":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB;
+ break;
+ case "LCD_VBGR":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR;
+ break;
+ case "LCD_VRGB":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB;
+ break;
+ case "OFF":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
+ break;
+ case "DEFAULT":
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT;
+ break;
+ default:
+ jalview.bin.Console.warn(TEXT_ANTIALIAS_METHOD + " value '"
+ + textAntialiasMethodPref
+ + "' not recognised, defaulting to 'GASP'. See https://docs.oracle.com/javase/8/docs/api/java/awt/RenderingHints.html#KEY_TEXT_ANTIALIASING");
+ textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
+ }
+ }
+
public AnnotationRenderer()
{
this(false);
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)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
: row_annotations[column - 1].secondaryStructure;
boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
- || dc != row_annotations[sCol - 1].secondaryStructure;
+ || dc != row_annotations[sCol - 1].secondaryStructure
+ || !validEnd;
boolean diffdownstream = !validRes || !validEnd
|| row_annotations[column] == null
|| dc != row_annotations[column].secondaryStructure;
+ if (diffupstream || diffdownstream)
+ {
+ // draw glyphline under arrow
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
+ g.setColor(STEM_COLOUR);
+
if (column > 0 && Rna.isClosingParenthesis(dc))
{
if (diffupstream)
* if new annotation with a closing base pair half of the stem,
* display a backward arrow
*/
- g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
+ fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
new int[]
- { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
x1 += 5;
}
* 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 },
+ fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 },
new int[]
- { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
x2 -= 5;
}
}
}
// draw arrow body
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ unsetAntialias(g);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
}
void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
int iconOffset, int startRes, int column, boolean validRes,
boolean validEnd)
{
- // System.out.println(nonCanColor);
+ // Console.info(nonCanColor);
- g.setColor(nonCanColor);
int sCol = (lastSSX / charWidth)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
: row_annotations[column - 1].displayCharacter;
boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
- || !dc.equals(row_annotations[sCol - 1].displayCharacter);
+ || !dc.equals(row_annotations[sCol - 1].displayCharacter)
+ || !validEnd;
boolean diffdownstream = !validRes || !validEnd
|| row_annotations[column] == null
|| !dc.equals(row_annotations[column].displayCharacter);
- // System.out.println("Column "+column+" diff up: "+diffupstream+"
+ // Console.info("Column "+column+" diff up:
+ // "+diffupstream+"
// down:"+diffdownstream);
// If a closing base pair half of the stem, display a backward arrow
+ if (diffupstream || diffdownstream)
+ {
+ // draw glyphline under arrow
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
+ g.setColor(nonCanColor);
if (column > 0 && Rna.isClosingParenthesis(dc))
{
// 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 },
+ fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
new int[]
- { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
x1 += 5;
}
// display a forward arrow
if (diffdownstream)
{
- g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 },
+ fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 },
new int[]
- { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
x2 -= 5;
}
}
}
// draw arrow body
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ unsetAntialias(g);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
}
// public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
useClip = false;
}
+ rendererFactoryI = AnnotationRendererFactory.getRendererFactory();
updateFromAlignViewport(av);
}
return null;
}
+ boolean rna = false;
+
+ private AnnotationRendererFactoryI rendererFactoryI;
+
/**
* Render the annotation rows associated with an alignment.
*
AlignViewportI av, Graphics g, int activeRow, int startRes,
int endRes)
{
+ return drawComponent(annotPanel, av, g, activeRow, startRes, endRes,
+ false);
+ }
+
+ public boolean drawComponent(AwtRenderPanelI annotPanel,
+ AlignViewportI av, Graphics g, int activeRow, int startRes,
+ int endRes, boolean forExport)
+ {
+ if (g instanceof EpsGraphics2D || g instanceof SVGGraphics2D)
+ {
+ this.setVectorRendering(true);
+ }
+ Graphics2D g2d = (Graphics2D) g;
+
long stime = System.currentTimeMillis();
boolean usedFaded = false;
// NOTES:
.getComplementConsensusAnnotation();
BitSet graphGroupDrawn = new BitSet();
- int charOffset = 0; // offset for a label
// \u03B2 \u03B1
// debug ints
int yfrom = 0, f_i = 0, yto = 0, f_to = 0;
*
* continue; }
*/
+
// first pass sets up state for drawing continuation from left-hand
// column
// of startRes
+
+ // flag used for vector rendition
+ this.glyphLineDrawn = false;
x = (startRes == 0) ? 0 : -1;
+
while (x < endRes - startRes)
{
if (hasHiddenColumns)
: null;
if (x > -1)
{
+ unsetAntialias(g);
if (activeRow == i)
{
g.setColor(Color.red);
{
if (columnSelection.contains(column))
{
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
}
}
if (row.getInvalidStrucPos() > x)
{
g.setColor(Color.orange);
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
else if (row.getInvalidStrucPos() == x)
{
g.setColor(Color.orange.darker());
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
if (validCharWidth && validRes && displayChar != null
&& (displayChar.length() > 0))
{
- Graphics2D gg = ((Graphics2D) g);
- float fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
- displayChar.length());
+ float fmWidth = fm.stringWidth(displayChar);
/*
* shrink label width to fit in column, if that is
if (scaleColLabel && fmWidth > charWidth)
{
scaledToFit = true;
- fmScaling = charWidth;
- fmScaling /= fmWidth;
+ fmScaling = (float) charWidth / fmWidth;
// and update the label's width to reflect the scaling.
fmWidth = charWidth;
}
- charOffset = (int) ((charWidth - fmWidth) / 2f);
+ float charOffset = (charWidth - fmWidth) / 2f;
if (row_annotations[column].colour == null)
{
- gg.setColor(Color.black);
+ g2d.setColor(Color.black);
}
else
{
- gg.setColor(row_annotations[column].colour);
+ g2d.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;
-
+ final float xPos = (x * charWidth) + charOffset;
+ final float yPos = y + iconOffset;
+
+ // Act on a copy of the Graphics2d object
+ Graphics2D g2dCopy = (Graphics2D) g2d.create();
+ // Clip to this annotation line (particularly width).
+ // This removes artifacts from text when side scrolling
+ // (particularly in wrap format), but can result in clipped
+ // characters until a full paint is drawn.
+ // Add charHeight allowance above and below annotation for
+ // character overhang.
+ // If we're in an image export, set the clip width to be the
+ // entire width of the annotation.
+
+ int clipWidth = forExport
+ ? row_annotations.length * charWidth - 1
+ : imgWidth - 1;
+ g2dCopy.setClip(0, (int) yPos - 2 * charHeight, clipWidth,
+ charHeight * 3);
/*
* translate to drawing position _before_ applying any scaling
*/
- gg.translate(xPos, yPos);
+ g2dCopy.translate(xPos, yPos);
if (scaledToFit)
{
/*
* use a scaling transform to make the label narrower
* (JalviewJS doesn't have Font.deriveFont(AffineTransform))
*/
- gg.transform(
+ g2dCopy.transform(
AffineTransform.getScaleInstance(fmScaling, 1.0));
}
+ setAntialias(g2dCopy, true);
if (column == 0 || row.graph > 0)
{
- gg.drawString(displayChar, 0, 0);
+ g2dCopy.drawString(displayChar, 0, 0);
}
else if (row_annotations[column - 1] == null || (labelAllCols
|| !displayChar.equals(
|| (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));
+ g2dCopy.drawString(displayChar, 0, 0);
}
- gg.translate(-xPos, -yPos);
+ g2dCopy.dispose();
}
}
if (row.hasIcons)
if (!validRes || (ss != lastSS))
{
- if (x > -1)
+ if (x > 0)
{
// int nb_annot = x - temp;
- // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre
+ // Console.info("\t type :"+lastSS+"\t x
+ // :"+x+"\t nbre
// annot :"+nb_annot);
switch (lastSS)
{
// temp = x;
break;
default:
- g.setColor(Color.gray);
- g.fillRect(lastSSX, y + 6 + iconOffset,
- (x * charWidth) - lastSSX, 2);
- // temp = x;
+ if (isVectorRendering())
+ {
+ // draw single full width glyphline
+ drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
+ // disable more glyph lines
+ this.glyphLineDrawn = true;
+ }
+ else
+ {
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
break;
}
}
case 'y':
case 'Z':
case 'z':
- // System.out.println(lastSS);
+ // Console.info(lastSS);
Color nonCanColor = getNotCanonicalColor(lastSS);
drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX,
x, y, iconOffset, startRes, column, validRes, validEnd);
break;
default:
- drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
- startRes, column, validRes, validEnd);
+ if (isVectorRendering())
+ {
+ // draw single full width glyphline
+ drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
+ // disable more glyph lines
+ this.glyphLineDrawn = true;
+ }
+ else
+ {
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
break;
}
}
row.graphMin, row.graphMax, y, renderHistogram,
renderProfile, normaliseProfile);
}
+ else
+ {
+ AnnotationRowRendererI renderer = rendererFactoryI
+ .getRendererFor(row);
+ if (renderer != null)
+ {
+ renderer.renderRow(g, charWidth, charHeight, hasHiddenColumns,
+ av, hiddenColumns, columnSelection, row,
+ row_annotations, startRes, endRes, row.graphMin,
+ row.graphMax, y, isVectorRendering());
+ }
+ if (debugRedraw)
+ {
+ if (renderer == null)
+ {
+ System.err
+ .println("No renderer found for " + row.toString());
+ }
+ else
+ {
+ Console.warn(
+ "rendered with " + renderer.getClass().toString());
+ }
+ }
+
+ }
}
}
else
{
if (clipst)
{
- System.err.println(
- "Start clip at : " + yfrom + " (index " + f_i + ")");
+ Console.warn("Start clip at : " + yfrom + " (index " + f_i + ")");
}
if (clipend)
{
- System.err.println(
- "End clip at : " + yto + " (index " + f_to + ")");
+ Console.warn("End clip at : " + yto + " (index " + f_to + ")");
}
}
;
- System.err.println("Annotation Rendering time:"
+ Console.warn("Annotation Rendering time:"
+ (System.currentTimeMillis() - stime));
}
;
// 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)
+ void drawGlyphLine(Graphics g, int lastSSX, int x, int y, int iconOffset)
{
+ if (glyphLineDrawn)
+ {
+ // if we've drawn a single long glyphline for an export, don't draw the
+ // bits
+ return;
+ }
+ unsetAntialias(g);
g.setColor(GLYPHLINE_COLOR);
g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
}
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(
+ // draw the glyphline underneath
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+
+ g.setColor(SHEET_COLOUR);
+ fillRect(g, lastSSX, y + 4 + iconOffset,
+ (x * charWidth) - lastSSX - 4, 6);
+ fillPolygon(g,
new int[]
- { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
+ { (x * charWidth) - 6, (x * charWidth) - 6,
+ (x * charWidth - 1) },
new int[]
- { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
}
else
{
- g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth - lastSSX,
- 7);
+ g.setColor(SHEET_COLOUR);
+ fillRect(g, lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX,
+ 6);
}
-
}
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)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
int x2 = (x * charWidth);
- if (USE_FILL_ROUND_RECT)
+ if (USE_FILL_ROUND_RECT || isVectorRendering())
{
+ // draw glyph line behind helix (visible in EPS or SVG output)
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+
+ g.setColor(HELIX_COLOUR);
+ setAntialias(g);
int ofs = charWidth / 2;
// Off by 1 offset when drawing rects and ovals
// to offscreen image on the MAC
- g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
+ fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - 1, 8, 8, 8);
if (sCol == 0 || row[sCol - 1] == null
|| row[sCol - 1].secondaryStructure != 'H')
{
}
else
{
- // g.setColor(Color.orange);
- g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
- 0, 0);
+ fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - ofs, 8, 0,
+ 0);
}
if (!validRes || row[column] == null
|| row[column].secondaryStructure != 'H')
}
else
{
- // g.setColor(Color.magenta);
- g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset,
- x2 - x1 - ofs + 1, 8, 0, 0);
-
+ fillRoundRect(g, lastSSX + ofs, y + 3 + iconOffset, x2 - x1 - ofs,
+ 8, 0, 0);
}
return;
}
- if (sCol == 0 || row[sCol - 1] == null
- || row[sCol - 1].secondaryStructure != 'H')
+ boolean leftEnd = sCol == 0 || row[sCol - 1] == null
+ || row[sCol - 1].secondaryStructure != 'H';
+ boolean rightEnd = !validRes || row[column] == null
+ || row[column].secondaryStructure != 'H';
+
+ if (leftEnd || rightEnd)
{
- g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
+ g.setColor(HELIX_COLOUR);
+
+ if (leftEnd)
+ {
+ fillArc(g, lastSSX, y + 3 + iconOffset, charWidth, 8, 90, 180);
x1 += charWidth / 2;
}
- if (!validRes || row[column] == null
- || row[column].secondaryStructure != 'H')
+ if (rightEnd)
{
- g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
- 8, 270, 180);
+ fillArc(g, ((x - 1) * charWidth), y + 3 + iconOffset, charWidth, 8,
+ 270, 180);
x2 -= charWidth / 2;
}
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
+ fillRect(g, x1, y + 3 + iconOffset, x2 - x1, 8);
}
void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
{
return;
}
+ Stroke roundStroke = new BasicStroke(1, BasicStroke.CAP_ROUND,
+ BasicStroke.JOIN_ROUND);
+ Stroke squareStroke = new BasicStroke(1, BasicStroke.CAP_SQUARE,
+ BasicStroke.JOIN_MITER);
+ Graphics2D g2d = (Graphics2D) g;
+ Stroke prevStroke = g2d.getStroke();
+ g2d.setStroke(roundStroke);
int x = 0;
eRes = Math.min(eRes, aa_annotations.length);
- if (sRes == 0)
- {
- x++;
- }
-
int y1 = y, y2 = y;
float range = max - min;
}
g.setColor(Color.gray);
- g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
+ drawLine(g, squareStroke, x * charWidth, y2, (eRes - sRes) * charWidth,
+ y2);
+
+ if (sRes == 0)
+ {
+ x++;
+ }
eRes = Math.min(eRes, aa_annotations.length);
int column;
int aaMax = aa_annotations.length - 1;
- while (x < eRes - sRes)
+ while (x <= eRes - sRes)
{
column = sRes + x;
if (hasHiddenColumns)
break;
}
- if (aa_annotations[column] == null
- || aa_annotations[column - 1] == null)
+ if (aa_annotations[column] == null)
{
x++;
continue;
}
+ boolean individualColour = false;
if (aa_annotations[column].colour == null)
{
g.setColor(Color.black);
else
{
g.setColor(aa_annotations[column].colour);
+ individualColour = true;
+ }
+
+ boolean value1Exists = column > 0
+ && aa_annotations[column - 1] != null;
+ float value1 = 0f;
+ Color color1 = null;
+ if (value1Exists)
+ {
+ value1 = aa_annotations[column - 1].value;
+ color1 = aa_annotations[column - 1].colour;
}
+ float value2 = aa_annotations[column].value;
+ boolean nextValueExists = aa_annotations.length > column + 1
+ && aa_annotations[column + 1] != null;
- y1 = y - (int) (((aa_annotations[column - 1].value - min) / range)
- * graphHeight);
- y2 = y - (int) (((aa_annotations[column].value - min) / range)
- * graphHeight);
+ // check for standalone value
+ if (!value1Exists && !nextValueExists)
+ {
+ y2 = y - yValueToPixelHeight(value2, min, range, graphHeight);
+ drawLine(g, x * charWidth + charWidth / 4, y2,
+ x * charWidth + 3 * charWidth / 4, y2);
+ x++;
+ continue;
+ }
+
+ if (!value1Exists)
+ {
+ x++;
+ continue;
+ }
- g.drawLine(x * charWidth - charWidth / 2, y1,
- x * charWidth + charWidth / 2, y2);
+ y1 = y - yValueToPixelHeight(value1, min, range, graphHeight);
+ y2 = y - yValueToPixelHeight(value2, min, range, graphHeight);
+
+ float v1 = value1;
+ float v2 = value2;
+ int a1 = (x - 1) * charWidth + charWidth / 2;
+ int b1 = y1;
+ int a2 = x * charWidth + charWidth / 2;
+ int b2 = y2;
+ if (x == 0)
+ {
+ // only draw an initial half-line
+ a1 = x * charWidth;
+ b1 = y1 + (y2 - y1) / 2;
+ v1 = value1 + (value2 - value1) / 2;
+ }
+ else if (x == eRes - sRes)
+ {
+ // this is one past the end to draw -- only draw the first half of the
+ // line
+ a2 = x * charWidth - 1;
+ b2 = y1 + (y2 - y1) / 2;
+ v2 = value1 + (value2 - value1) / 2;
+ }
+ else
+ {
+ }
+ AnnotationColouringI ac = aa_annotations[column]
+ .getAnnotationColouring();
+ List<Map.Entry<Float, Color>> valCols = ac == null ? null
+ : ac.rangeColours(v1, v2);
+ if (valCols != null)
+ {
+ drawSegmentedLine(g, valCols, a1, b1, a2, b2);
+ }
+ else
+ {
+ drawLine(g, a1, b1, a2, b2);
+ }
x++;
}
{
g.setColor(_aa.threshold.colour);
Graphics2D g2 = (Graphics2D) g;
- g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
- BasicStroke.JOIN_ROUND, 3f, new float[]
- { 5f, 3f }, 0f));
-
y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
- g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
- g2.setStroke(new BasicStroke());
+ drawLine(g, dashedLine(charWidth), 0, y2, (eRes - sRes) * charWidth,
+ y2);
}
+ g2d.setStroke(prevStroke);
+ }
+
+ private static double log2 = Math.log(2);
+
+ // Cached dashed line Strokes
+ private static Map<Integer, Stroke> dashedLineLookup = new HashMap<>();
+
+ /**
+ * Returns a dashed line stroke as close to 6-4 pixels as fits within the
+ * charWidth. This allows translations of multiples of charWidth without
+ * disrupting the dashed line. The exact values are 0.6-0.4 proportions of
+ * charWidth for charWidth under 16. For charWidth 16 or over, the number of
+ * dashes doubles as charWidth doubles.
+ *
+ * @param charWidth
+ * @return Stroke with appropriate dashed line fitting exactly within the
+ * charWidth
+ */
+ private static Stroke dashedLine(int charWidth)
+ {
+ if (!dashedLineLookup.containsKey(charWidth))
+ {
+ int power2 = charWidth >= 8 ? (int) (Math.log(charWidth) / log2) : 2;
+ float width = ((float) charWidth) / ((float) Math.pow(2, power2 - 3));
+ float segment1 = width * 0.6f;
+ float segment2 = width - segment1;
+ dashedLineLookup.put(charWidth, new BasicStroke(1,
+ BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 3f, new float[]
+ { segment1, segment2 }, 0f));
+ }
+ return dashedLineLookup.get(charWidth);
+ }
+
+ private void drawSegmentedLine(Graphics g,
+ List<Map.Entry<Float, Color>> valCols, int x1, int y1, int x2,
+ int y2)
+ {
+ if (valCols == null || valCols.size() == 0)
+ {
+ return;
+ }
+ // let's only go forwards+up|down -- try and avoid providing right to left
+ // x values
+ if (x2 < x1)
+ {
+ int tmp = y2;
+ y2 = y1;
+ y1 = tmp;
+ tmp = x2;
+ x2 = x1;
+ x1 = tmp;
+ Collections.reverse(valCols);
+ }
+ Graphics2D g2d = (Graphics2D) g.create();
+ float yd = y2 - y1;
+ boolean reverse = yd > 0; // reverse => line going DOWN (y increasing)
+ Map.Entry<Float, Color> firstValCol = valCols.remove(0);
+ float firstVal = firstValCol.getKey();
+ Color firstCol = firstValCol.getValue();
+ int yy1 = 0;
+ yy1 = reverse ? (int) Math.ceil(y1 + firstVal * yd)
+ : (int) Math.floor(y1 + firstVal * yd);
+ Color thisCol = firstCol;
+ for (int i = 0; i < valCols.size(); i++)
+ {
+ Map.Entry<Float, Color> valCol = valCols.get(i);
+ float val = valCol.getKey();
+ Color col = valCol.getValue();
+ int clipX = x1 - 1;
+ int clipW = x2 - x1 + 2;
+ int clipY = 0;
+ int clipH = 0;
+ int yy2 = 0;
+ if (reverse) // line going down
+ {
+ yy2 = (int) Math.ceil(y1 + val * yd);
+ g2d.setColor(thisCol);
+ clipY = yy1 - 1;
+ clipH = yy2 - yy1;
+ if (i == 0)
+ {
+ // highest segment, don't clip at the top
+ clipY -= 2;
+ clipH += 2;
+ }
+ if (i == valCols.size() - 1)
+ {
+ // lowest segment, don't clip at the bottom
+ clipH += 2;
+ }
+ }
+ else // line going up (or level)
+ {
+ yy2 = (int) Math.floor(y1 + val * yd);
+ // g2d.setColor(Color.cyan); g2d.drawRect(x1 - 1, yy1, x2 - x1 + 1, yy2
+ // -
+ // yy1 + 1);
+ g2d.setColor(col);
+ clipY = yy2;
+ clipH = yy1 - yy2;
+ if (i == 0)
+ {
+ // lowest segment, don't clip at the bottom
+ clipH += 2;
+ }
+ if (i == valCols.size() - 1)
+ {
+ // highest segment, don't clip at the top
+ clipY -= 2;
+ clipH += 2;
+ }
+ }
+ g2d.setClip(clipX, clipY, clipW, clipH);
+ drawLine(g2d, x1, y1, x2, y2);
+ yy1 = yy2;
+ thisCol = col;
+ }
+ g2d.dispose();
+ }
+
+ private static int yValueToPixelHeight(float value, float min,
+ float range, int graphHeight)
+ {
+ return (int) (((value - min) / range) * graphHeight);
}
@SuppressWarnings("unused")
g.setColor(Color.gray);
- g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
+ drawLine(g, x, y2, (eRes - sRes) * charWidth, y2);
int column;
int aaMax = aa_annotations.length - 1;
{
if (y1 - y2 > 0)
{
- g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
+ fillRect(g, x * charWidth, y2, charWidth, y1 - y2);
}
else
{
- g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
+ fillRect(g, x * charWidth, y1, charWidth, y2 - y1);
}
}
// draw profile if available
// 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())
+ // Console.info(asc + " " + dec + " " + (asc -
+ // lm.getAscent())
// + " " + (dec - lm.getDescent()));
double asc = fm.getAscent();
}
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;
if (_aa.threshold != null)
{
g.setColor(_aa.threshold.colour);
- Graphics2D g2 = (Graphics2D) g;
- g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
+ Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_ROUND, 3f, new float[]
- { 5f, 3f }, 0f));
+ { 5f, 3f }, 0f);
y2 = (int) (y
- ((_aa.threshold.value - min) / range) * _aa.graphHeight);
- g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
- g2.setStroke(new BasicStroke());
+ drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2);
}
}
{
eRes = Math.min(eRes, aa_annotations.length);
g.setColor(Color.white);
- g.fillRect(0, 0, width, y);
+ fillRect(g, 0, 0, width, y);
g.setColor(new Color(0, 0, 180));
int x = 0, height;
height = y;
}
- g.fillRect(x, y - height, charWidth, height);
+ fillRect(g, x, y - height, charWidth, height);
}
x += charWidth;
}
return new Color(0, 80, 255);
default:
- System.out.println("This is not a interaction : " + lastss);
+ Console.info("This is not a interaction : " + lastss);
return null;
}
}
+
+ private void fillPolygon(Graphics g, int[] xpoints, int[] ypoints, int n)
+ {
+ setAntialias(g);
+ g.fillPolygon(xpoints, ypoints, n);
+ }
+
+ /*
+ private void fillRect(Graphics g, int a, int b, int c, int d)
+ {
+ fillRect(g, false, a, b, c, d);
+ }*/
+
+ private void fillRect(Graphics g, int a, int b, int c, int d)
+ {
+ unsetAntialias(g);
+ g.fillRect(a, b, c, d);
+ }
+
+ private void fillRoundRect(Graphics g, int a, int b, int c, int d, int e,
+ int f)
+ {
+ setAntialias(g);
+ g.fillRoundRect(a, b, c, d, e, f);
+ }
+
+ private void fillArc(Graphics g, int a, int b, int c, int d, int e, int f)
+ {
+ setAntialias(g);
+ g.fillArc(a, b, c, d, e, f);
+ }
+
+ private void drawLine(Graphics g, Stroke s, int a, int b, int c, int d)
+ {
+ Graphics2D g2d = (Graphics2D) g;
+ Stroke p = g2d.getStroke();
+ g2d.setStroke(s);
+ drawLine(g, a, b, c, d);
+ g2d.setStroke(p);
+ }
+
+ private void drawLine(Graphics g, int x1, int y1, int x2, int y2)
+ {
+ setAntialias(g);
+ g.drawLine(x1, y1, x2, y2);
+ }
+
+ private void setAntialias(Graphics g)
+ {
+ setAntialias(g, false);
+ }
+
+ private void setAntialias(Graphics g, boolean text)
+ {
+ if (isVectorRendering())
+ {
+ // no need to antialias vector drawings
+ return;
+ }
+ if (Cache.getDefault("ANTI_ALIAS", true))
+ {
+ Graphics2D g2d = (Graphics2D) g;
+ if (text)
+ {
+ g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+ this.textAntialiasMethod);
+ }
+ else
+ {
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_ON);
+ }
+ }
+ }
+
+ private void unsetAntialias(Graphics g)
+ {
+ if (isVectorRendering())
+ {
+ // no need to antialias vector drawings
+ return;
+ }
+ Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_OFF);
+ }
+
+ public void setVectorRendering(boolean b)
+ {
+ renderingVectors = b;
+ }
+
+ public boolean isVectorRendering()
+ {
+ return renderingVectors;
+ }
}