JAL-3215 refactored ScoreColourScheme construction for scriptability

[jalview.git] / src / jalview / schemes / ScoreColourScheme.java

diff --git a/src/jalview/schemes/ScoreColourScheme.java b/src/jalview/schemes/ScoreColourScheme.java
index 57e8458..66bb5b4 100755 (executable)
--- a/src/jalview/schemes/ScoreColourScheme.java
+++ b/src/jalview/schemes/ScoreColourScheme.java
@@ -20,119 +20,138 @@
  */
 package jalview.schemes;
 
+import jalview.api.AlignViewportI;
+import jalview.datamodel.AnnotatedCollectionI;
 import jalview.datamodel.SequenceI;
+import jalview.util.Comparison;
 
 import java.awt.Color;
 
 /**
- * DOCUMENT ME!
- * 
- * @author $author$
- * @version $Revision$
+ * A base class for colour schemes which define a graduated colour range based
+ * on
+ * <ul>
+ * <li>a minimum colour</li>
+ * <li>a maximum colour</li>
+ * <li>a score assigned to each residue</li>
+ * </ul>
  */
 public class ScoreColourScheme extends ResidueColourScheme
 {
-  /** DOCUMENT ME!! */
-  public double min;
+  String schemeName;
+
+  double min;
+
+  double max;
+
+  Color minColour;
 
-  /** DOCUMENT ME!! */
-  public double max;
+  Color maxColour;
 
-  /** DOCUMENT ME!! */
-  public double[] scores;
+  double[] scores;
 
   /**
-   * Creates a new ScoreColourScheme object.
+   * Constructor
    * 
+   * @param symbolIndex
+   *          a lookup where the index is a char e.g. 'R' or 'r', and the value
+   *          is its position in the colour table lookup
    * @param scores
-   *          DOCUMENT ME!
-   * @param min
-   *          DOCUMENT ME!
-   * @param max
-   *          DOCUMENT ME!
+   *          per residue, with indices corresponding to those for colour lookup
    */
-  public ScoreColourScheme(int symbolIndex[], double[] scores, double min,
-          double max)
+  public ScoreColourScheme(String name, int[] symbolIndex, double[] scores,
+          Color minColour, Color maxColour)
   {
     super(symbolIndex);
+    this.schemeName = name;
+    this.minColour = minColour;
+    this.maxColour = maxColour;
 
+    setMinMax(scores);
     this.scores = scores;
-    this.min = min;
-    this.max = max;
 
-    // Make colours in constructor
-    // Why wasn't this done earlier?
-    int i, iSize = scores.length;
+    int iSize = scores.length;
     colors = new Color[scores.length];
-    for (i = 0; i < iSize; i++)
+    for (int i = 0; i < iSize; i++)
     {
-      float red = (float) (scores[i] - (float) min) / (float) (max - min);
-
-      if (red > 1.0f)
-      {
-        red = 1.0f;
-      }
-
-      if (red < 0.0f)
-      {
-        red = 0.0f;
-      }
-      colors[i] = makeColour(red);
+      colors[i] = getScoreColour(scores[i]);
     }
   }
 
   /**
-   * DOCUMENT ME!
-   * 
-   * @param s
-   *          DOCUMENT ME!
-   * @param j
-   *          DOCUMENT ME!
+   * Computes a colour for a score by
+   * <ul>
+   * <li>first scaling the score linearly from 0 (minScore) to 1 (maxScore)</li>
+   * <li>then interpolating rgb values from minColour to maxColour</li>
+   * </ul>
+   * This method is used to make colours for residue scores, but may also be
+   * called to generate a colour for an intermediate score value (for example, a
+   * column average).
+   */
+  public Color getScoreColour(double rawScore)
+  {
+    float score = (float) (rawScore - (float) min) / (float) (max - min);
+    score = Math.max(score, 0f);
+    score = Math.min(score, 1f);
+
+    int r = minColour.getRed()
+            + Math.round((maxColour.getRed() - minColour.getRed()) * score);
+    int g = minColour.getGreen()
+            + Math.round(
+                    (maxColour.getGreen() - minColour.getGreen()) * score);
+    int b = minColour.getBlue()
+            + Math.round(
+                    (maxColour.getBlue() - minColour.getBlue()) * score);
+
+    Color c = new Color(r, g, b);
+    return c;
+  }
+
+  /**
+   * Inspects score values and saves the minimum and maximum
    * 
-   * @return DOCUMENT ME!
+   * @param vals
    */
-  @Override
-  public Color findColour(char c, int j, SequenceI seq)
+  void setMinMax(double[] vals)
   {
-    if (threshold > 0)
-    {
-      if (!aboveThreshold(c, j))
-      {
-        return Color.white;
-      }
-    }
+    double dMin = Double.MAX_VALUE;
+    double dMax = -Double.MAX_VALUE;
 
-    if (jalview.util.Comparison.isGap(c))
+    for (int i = 0; i < vals.length - 1; i++)
     {
-      return Color.white;
+      dMin = Math.min(dMin, vals[i]);
+      dMax = Math.max(dMax, vals[i]);
     }
 
-    Color currentColour = colors[ResidueProperties.aaIndex[c]];
+    this.min = vals.length == 0 ? 0d : dMin;
+    this.max = vals.length == 0 ? 0d : dMax;
+  }
 
-    if (conservationColouring)
+  @Override
+  public Color findColour(char c, int j, SequenceI seq)
+  {
+    if (Comparison.isGap(c))
     {
-      currentColour = applyConservation(currentColour, j);
+      return Color.white;
     }
-
-    return currentColour;
+    return super.findColour(c);
   }
 
-  /**
-   * DOCUMENT ME!
-   * 
-   * @param c
-   *          DOCUMENT ME!
-   * 
-   * @return DOCUMENT ME!
-   */
-  public Color makeColour(float c)
+  @Override
+  public String getSchemeName()
   {
-    return new Color(c, (float) 0.0, (float) 1.0 - c);
+    return schemeName;
   }
 
+  /**
+   * Returns a new instance of this colour scheme with which the given data may
+   * be coloured
+   */
   @Override
-  public String getSchemeName()
+  public ColourSchemeI getInstance(AlignViewportI view,
+          AnnotatedCollectionI coll)
   {
-    return "Score";
+    return new ScoreColourScheme(schemeName, symbolIndex, scores, minColour,
+            maxColour);
   }
 }