--- /dev/null
+package jalview.datamodel.annotations;
+
+import java.awt.Color;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AnnotationColouringRanges extends AnnotationColouring
+{
+ private static List<Color> colours = new ArrayList<Color>();
+
+ private static List<Float> values = new ArrayList<Float>();
+
+ protected static void addValColour(float v, Color c)
+ {
+ values.add(v);
+ colours.add(c);
+ }
+
+ protected static void addFirstColour(Color c)
+ {
+ colours.add(0, c);
+ }
+
+ static
+ {
+ // e.g.
+ // addFirstColour(Color.black); -infty..25 = black
+ // addValColour(25,Color.darkGray); 25..50 = darkGray
+ // addValColour(50,Color.gray); 50..75 = gray
+ // addValColour(75,Color.lightGray); 75..100 = lightGray
+ // addValColour(100,Color.white); 100..infty = white
+ }
+
+ @Override
+ public Color valueToColour(float val)
+ {
+ Color col = null;
+ boolean set = false;
+ for (int i = 0; i < values.size(); i++)
+ {
+ float compareVal = values.get(i);
+ if (colours.size() > i)
+ {
+ col = colours.get(i);
+ }
+ if (val < compareVal)
+ {
+ set = true;
+ break;
+ }
+ }
+ if (!set && colours.size() > values.size())
+ {
+ col = colours.get(values.size());
+ }
+ return col;
+ }
+
+ @Override
+ public List<Map.Entry<Float, Color>> rangeColours(float val1, float val2)
+ {
+ String cacheKey = cacheKey(val1, val2);
+ if (!valColorsCache.containsKey(cacheKey))
+ {
+ List<Map.Entry<Float, Color>> valCols = new ArrayList<>();
+ float v1 = val1 <= val2 ? val1 : val2;
+ float v2 = val1 <= val2 ? val2 : val1;
+ boolean reversed = val1 > val2;
+ Color col = null;
+ boolean set1 = false;
+ boolean set2 = false;
+ int i = 0;
+ while (i < values.size() && (!set1 || !set2))
+ {
+ float compareVal = values.get(i);
+ if (colours.size() > i)
+ {
+ col = colours.get(i);
+ }
+
+ if (!set1 && v1 < compareVal)
+ {
+ // add the initial checkpoint
+ valCols.add(valCol(reversed ? 1f : 0f, col));
+ set1 = true;
+ }
+
+ if (!set2 && v2 < compareVal)
+ {
+ // add the final checkpoint
+ valCols.add(valCol(reversed ? 0f : 1f, col));
+ set2 = true;
+ break;
+ }
+
+ if (set1) // && !set2
+ {
+ // add an intermediate checkpoint
+ float v = (compareVal - v1) / (v2 - v1);
+ valCols.add(valCol(reversed ? 1f - v : v, col));
+ }
+
+ i++;
+ }
+ if (colours.size() > i)
+ {
+ col = colours.get(i);
+ }
+ // add above the final checkpoint colour(s) if not set
+ if (!set1)
+ {
+ valCols.add(valCol(reversed ? 1f : 0f, col));
+ set1 = true;
+ }
+ if (!set2)
+ {
+ // add the final checkpoint
+ valCols.add(valCol(reversed ? 0f : 1f, col));
+ set2 = true;
+ }
+ if (reversed)
+ {
+ Collections.reverse(valCols);
+ }
+ // put in the cache
+ valColorsCache.put(cacheKey, valCols);
+ }
+
+ return getFromCache(cacheKey);
+ }
+
+ private Map.Entry<Float, Color> valCol(Float v, Color c)
+ {
+ return new AbstractMap.SimpleEntry<Float, Color>(v, c);
+ }
+
+ private Map<String, List<Map.Entry<Float, Color>>> valColorsCache = new HashMap<String, List<Map.Entry<Float, Color>>>();
+
+ private List<Map.Entry<Float, Color>> getFromCache(String key)
+ {
+ // return a copy of the list in case of element order manipulation (e.g.
+ // valCols.remove(0))
+ return new ArrayList<Map.Entry<Float, Color>>(valColorsCache.get(key));
+ }
+
+ private static String cacheKey(float f1, float f2)
+ {
+ return new StringBuilder().append(Float.hashCode(f1)).append(' ')
+ .append(Float.hashCode(f2)).toString();
+ }
+}
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 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;
// 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 - charHeight, clipWidth,
- charHeight);
+ g2dCopy.setClip(0, (int) yPos - 2 * charHeight, clipWidth,
+ charHeight * 3);
/*
* translate to drawing position _before_ applying any scaling
*/
continue;
}
+ boolean individualColour = false;
if (aa_annotations[column].colour == null)
{
g.setColor(Color.black);
else
{
g.setColor(aa_annotations[column].colour);
+ individualColour = true;
}
- boolean previousValueExists = column > 0
+ boolean value1Exists = column > 0
&& aa_annotations[column - 1] != null;
- float previousValue = previousValueExists
- ? aa_annotations[column - 1].value
- : 0;
- float thisValue = aa_annotations[column].value;
+ 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;
- float nextValue = nextValueExists ? aa_annotations[column + 1].value
- : 0;
// check for standalone value
- if (!previousValueExists && !nextValueExists)
+ if (!value1Exists && !nextValueExists)
{
- y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
+ y2 = y - yValueToPixelHeight(value2, min, range, graphHeight);
drawLine(g, x * charWidth + charWidth / 4, y2,
x * charWidth + 3 * charWidth / 4, y2);
x++;
continue;
}
- if (!previousValueExists)
+ if (!value1Exists)
{
x++;
continue;
}
- y1 = y - yValueToPixelHeight(previousValue, min, range, graphHeight);
- y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
+ 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
- drawLine(g, x * charWidth, y1 + (y2 - y1) / 2,
- x * charWidth + charWidth / 2, y2);
-
+ 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 a half line
- drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
- x * charWidth - 1, y1 + (y2 - y1) / 2);
-
+ // 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, (x - 1) * charWidth + charWidth / 2, y1,
- x * charWidth + charWidth / 2, y2);
+ drawLine(g, a1, b1, a2, b2);
}
x++;
}
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)
{
g2d.setStroke(p);
}
- private void drawLine(Graphics g, int a, int b, int c, int d)
+ private void drawLine(Graphics g, int x1, int y1, int x2, int y2)
{
setAntialias(g);
- g.drawLine(a, b, c, d);
+ g.drawLine(x1, y1, x2, y2);
}
private void setAntialias(Graphics g)
git://source.jalview.org / jalview.git / commitdiff