import java.awt.geom.AffineTransform;
import java.awt.image.ImageObserver;
import java.util.BitSet;
+import java.util.HashMap;
import java.util.Hashtable;
+import java.util.Map;
import org.jfree.graphics2d.svg.SVGGraphics2D;
import org.jibble.epsgraphics.EpsGraphics2D;
private boolean av_ignoreGapsConsensus;
- private boolean vectorRendition = false;
+ private boolean renderingVectors = false;
private boolean glyphLineDrawn = false;
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)
*/
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
*/
- fillPolygon(g, 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
- fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 7);
+ unsetAntialias(g);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
}
void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
: 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);
{
if (g instanceof EpsGraphics2D || g instanceof SVGGraphics2D)
{
- this.setVectorRendition(true);
+ this.setVectorRendering(true);
}
Graphics2D g2d = (Graphics2D) g;
if (!validRes || (ss != lastSS))
{
- if (x > -1)
+ if (x > 0)
{
// int nb_annot = x - temp;
// temp = x;
break;
default:
- if (isVectorRendition())
+ if (isVectorRendering())
{
// draw single full width glyphline
drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
x, y, iconOffset, startRes, column, validRes, validEnd);
break;
default:
- if (isVectorRendition())
+ if (isVectorRendering())
{
// draw single full width glyphline
drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
renderer.renderRow(g, charWidth, charHeight, hasHiddenColumns,
av, hiddenColumns, columnSelection, row,
row_annotations, startRes, endRes, row.graphMin,
- row.graphMax, y);
+ row.graphMax, y, isVectorRendering());
}
if (debugRedraw)
{
int x1 = lastSSX;
int x2 = (x * charWidth);
- if (USE_FILL_ROUND_RECT || isVectorRendition())
+ if (USE_FILL_ROUND_RECT || isVectorRendering())
{
// draw glyph line behind helix (visible in EPS or SVG output)
drawGlyphLine(g, lastSSX, x, y, iconOffset);
}
else
{
- // g.setColor(Color.orange);
fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - ofs, 8, 0,
0);
}
}
else
{
- // g.setColor(Color.magenta);
fillRoundRect(g, lastSSX + ofs, y + 3 + iconOffset, x2 - x1 - ofs,
8, 0, 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);
- drawLine(g, squareStroke, x * charWidth - charWidth, y2,
- (eRes - sRes) * 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)
g.setColor(aa_annotations[column].colour);
}
- if (aa_annotations[column - 1] == null
- && aa_annotations.length > column + 1
- && aa_annotations[column + 1] == null)
+ boolean previousValueExists = column > 0
+ && aa_annotations[column - 1] != null;
+ float previousValue = previousValueExists
+ ? aa_annotations[column - 1].value
+ : 0;
+ float thisValue = aa_annotations[column].value;
+ boolean nextValueExists = aa_annotations.length > column + 1
+ && aa_annotations[column + 1] != null;
+ float nextValue = nextValueExists ? aa_annotations[column + 1].value
+ : 0;
+
+ // check for standalone value
+ if (!previousValueExists && !nextValueExists)
{
- // standalone value
- y1 = y - (int) (((aa_annotations[column].value - min) / range)
- * graphHeight);
- drawLine(g, x * charWidth + charWidth / 4, y1,
- x * charWidth + 3 * charWidth / 4, y1);
+ y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
+ drawLine(g, x * charWidth + charWidth / 4, y2,
+ x * charWidth + 3 * charWidth / 4, y2);
x++;
continue;
}
- if (aa_annotations[column - 1] == null)
+ if (!previousValueExists)
{
x++;
continue;
}
- y1 = y - (int) (((aa_annotations[column - 1].value - min) / range)
- * graphHeight);
- y2 = y - (int) (((aa_annotations[column].value - min) / range)
- * graphHeight);
+ y1 = y - yValueToPixelHeight(previousValue, min, range, graphHeight);
+ y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
- drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
- x * charWidth + charWidth / 2, y2);
+ if (x == 0)
+ {
+ // only draw an initial half-line
+ drawLine(g, x * charWidth, y1 + (y2 - y1) / 2,
+ x * charWidth + charWidth / 2, y2);
+
+ }
+ else if (x == eRes - sRes)
+ {
+ // this is one past the end to draw -- only draw a half line
+ drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
+ x * charWidth - 1, y1 + (y2 - y1) / 2);
+
+ }
+ else
+ {
+ drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
+ x * charWidth + charWidth / 2, y2);
+ }
x++;
}
{
g.setColor(_aa.threshold.colour);
Graphics2D g2 = (Graphics2D) g;
- Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE,
- BasicStroke.JOIN_ROUND, 3f, new float[]
- { 5f, 3f }, 0f);
-
y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
- drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2);
+ 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 static int yValueToPixelHeight(float value, float min,
+ float range, int graphHeight)
+ {
+ return (int) (((value - min) / range) * graphHeight);
+ }
+
@SuppressWarnings("unused")
void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
Annotation[] aa_annotations, int sRes, int eRes, float min,
}
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;
private void setAntialias(Graphics g)
{
- if (isVectorRendition())
+ if (isVectorRendering())
{
// no need to antialias vector drawings
return;
private void unsetAntialias(Graphics g)
{
- if (isVectorRendition())
+ if (isVectorRendering())
{
// no need to antialias vector drawings
return;
RenderingHints.VALUE_ANTIALIAS_OFF);
}
- public void setVectorRendition(boolean b)
+ public void setVectorRendering(boolean b)
{
- vectorRendition = b;
+ renderingVectors = b;
}
- public boolean isVectorRendition()
+ public boolean isVectorRendering()
{
- return vectorRendition;
+ return renderingVectors;
}
}
git://source.jalview.org / jalview.git / blobdiff