create method to test HMM model as string
[jalview.git] / test / jalview / schemes / FeatureColourTest.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.schemes;
22
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertFalse;
25 import static org.testng.AssertJUnit.assertTrue;
26 import static org.testng.AssertJUnit.fail;
27
28 import jalview.datamodel.SequenceFeature;
29 import jalview.gui.JvOptionPane;
30 import jalview.util.ColorUtils;
31 import jalview.util.Format;
32
33 import java.awt.Color;
34
35 import org.testng.annotations.BeforeClass;
36 import org.testng.annotations.Test;
37
38 public class FeatureColourTest
39 {
40
41   @BeforeClass(alwaysRun = true)
42   public void setUpJvOptionPane()
43   {
44     JvOptionPane.setInteractiveMode(false);
45     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
46   }
47
48   @Test(groups = { "Functional" })
49   public void testCopyConstructor()
50   {
51     /*
52      * plain colour
53      */
54     FeatureColour fc = new FeatureColour(Color.RED);
55     FeatureColour fc1 = new FeatureColour(fc);
56     assertTrue(fc1.getColour().equals(Color.RED));
57     assertFalse(fc1.isGraduatedColour());
58     assertFalse(fc1.isColourByLabel());
59
60     /*
61      * min-max colour
62      */
63     fc = new FeatureColour(Color.gray, Color.black, 10f, 20f);
64     fc.setAboveThreshold(true);
65     fc.setThreshold(12f);
66     fc1 = new FeatureColour(fc);
67     assertTrue(fc1.isGraduatedColour());
68     assertFalse(fc1.isColourByLabel());
69     assertTrue(fc1.isAboveThreshold());
70     assertEquals(12f, fc1.getThreshold());
71     assertEquals(Color.gray, fc1.getMinColour());
72     assertEquals(Color.black, fc1.getMaxColour());
73     assertEquals(10f, fc1.getMin());
74     assertEquals(20f, fc1.getMax());
75
76     /*
77      * colour by label
78      */
79     fc = new FeatureColour();
80     fc.setColourByLabel(true);
81     fc1 = new FeatureColour(fc);
82     assertTrue(fc1.isColourByLabel());
83     assertFalse(fc1.isGraduatedColour());
84   }
85
86   @Test(groups = { "Functional" })
87   public void testIsColored_simpleColour()
88   {
89     FeatureColour fc = new FeatureColour(Color.RED);
90     assertTrue(fc.isColored(new SequenceFeature()));
91   }
92
93   @Test(groups = { "Functional" })
94   public void testIsColored_colourByLabel()
95   {
96     FeatureColour fc = new FeatureColour();
97     fc.setColourByLabel(true);
98     assertTrue(fc.isColored(new SequenceFeature()));
99   }
100
101   @Test(groups = { "Functional" })
102   public void testIsColored_aboveThreshold()
103   {
104     // graduated colour range from score 20 to 100
105     FeatureColour fc = new FeatureColour(Color.WHITE, Color.BLACK, 20f,
106             100f);
107
108     // score 0 is adjusted to bottom of range
109     SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 0f,
110             null);
111     assertTrue(fc.isColored(sf));
112     assertEquals(Color.WHITE, fc.getColor(sf));
113
114     // score 120 is adjusted to top of range
115     sf.setScore(120f);
116     assertEquals(Color.BLACK, fc.getColor(sf));
117
118     // value below threshold is still rendered
119     // setting threshold has no effect yet...
120     fc.setThreshold(60f);
121     sf.setScore(36f);
122     assertTrue(fc.isColored(sf));
123     assertEquals(new Color(204, 204, 204), fc.getColor(sf));
124
125     // now apply threshold:
126     fc.setAboveThreshold(true);
127     assertFalse(fc.isColored(sf));
128     // colour is still returned though ?!?
129     assertEquals(new Color(204, 204, 204), fc.getColor(sf));
130
131     sf.setScore(84); // above threshold now
132     assertTrue(fc.isColored(sf));
133     assertEquals(new Color(51, 51, 51), fc.getColor(sf));
134   }
135
136   @Test(groups = { "Functional" })
137   public void testGetColor_simpleColour()
138   {
139     FeatureColour fc = new FeatureColour(Color.RED);
140     assertEquals(Color.RED, fc.getColor(new SequenceFeature()));
141   }
142
143   @Test(groups = { "Functional" })
144   public void testGetColor_colourByLabel()
145   {
146     FeatureColour fc = new FeatureColour();
147     fc.setColourByLabel(true);
148     SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 1f,
149             null);
150     Color expected = ColorUtils.createColourFromName("desc");
151     assertEquals(expected, fc.getColor(sf));
152   }
153
154   @Test(groups = { "Functional" })
155   public void testGetColor_Graduated()
156   {
157     // graduated colour from score 0 to 100, gray(128, 128, 128) to red(255, 0,
158     // 0)
159     FeatureColour fc = new FeatureColour(Color.GRAY, Color.RED, 0f, 100f);
160     // feature score is 75 which is 3/4 of the way from GRAY to RED
161     SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 75f,
162             null);
163     // the colour gradient is computed in float values from 0-1 (where 1 == 255)
164     float red = 128 / 255f + 3 / 4f * (255 - 128) / 255f;
165     float green = 128 / 255f + 3 / 4f * (0 - 128) / 255f;
166     float blue = 128 / 255f + 3 / 4f * (0 - 128) / 255f;
167     Color expected = new Color(red, green, blue);
168     assertEquals(expected, fc.getColor(sf));
169   }
170
171   @Test(groups = { "Functional" })
172   public void testGetColor_belowThreshold()
173   {
174     // gradient from [50, 150] from WHITE(255, 255, 255) to BLACK(0, 0, 0)
175     FeatureColour fc = new FeatureColour(Color.WHITE, Color.BLACK, 50f,
176             150f);
177     SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 70f,
178             null);
179     fc.setThreshold(100f); // ignore for now
180     assertTrue(fc.isColored(sf));
181     assertEquals(new Color(204, 204, 204), fc.getColor(sf));
182
183     fc.setAboveThreshold(true); // feature lies below threshold
184     assertFalse(fc.isColored(sf));
185     assertEquals(new Color(204, 204, 204), fc.getColor(sf));
186   }
187
188   /**
189    * Test output of feature colours to Jalview features file format
190    */
191   @Test(groups = { "Functional" })
192   public void testToJalviewFormat()
193   {
194     /*
195      * plain colour - to RGB hex code
196      */
197     FeatureColour fc = new FeatureColour(Color.RED);
198     String redHex = Format.getHexString(Color.RED);
199     String hexColour = redHex;
200     assertEquals("domain\t" + hexColour, fc.toJalviewFormat("domain"));
201
202     /*
203      * colour by label (no threshold)
204      */
205     fc = new FeatureColour();
206     fc.setColourByLabel(true);
207     assertEquals("domain\tlabel", fc.toJalviewFormat("domain"));
208
209     /*
210      * colour by label (autoscaled) (an odd state you can reach by selecting
211      * 'above threshold', then deselecting 'threshold is min/max' then 'colour
212      * by label')
213      */
214     fc.setAutoScaled(true);
215     assertEquals("domain\tlabel", fc.toJalviewFormat("domain"));
216
217     /*
218      * colour by label (above threshold) (min/max values are output though not
219      * used by this scheme)
220      */
221     fc.setAutoScaled(false);
222     fc.setThreshold(12.5f);
223     fc.setAboveThreshold(true);
224     assertEquals("domain\tlabel|||0.0|0.0|above|12.5",
225             fc.toJalviewFormat("domain"));
226
227     /*
228      * colour by label (below threshold)
229      */
230     fc.setBelowThreshold(true);
231     assertEquals("domain\tlabel|||0.0|0.0|below|12.5",
232             fc.toJalviewFormat("domain"));
233
234     /*
235      * graduated colour, no threshold
236      */
237     fc = new FeatureColour(Color.GREEN, Color.RED, 12f, 25f);
238     String greenHex = Format.getHexString(Color.GREEN);
239     String expected = String.format("domain\t%s|%s|abso|12.0|25.0|none",
240             greenHex, redHex);
241     assertEquals(expected, fc.toJalviewFormat("domain"));
242
243     /*
244      * colour ranges over the actual score ranges (not min/max)
245      */
246     fc.setAutoScaled(true);
247     expected = String.format("domain\t%s|%s|12.0|25.0|none", greenHex,
248             redHex);
249     assertEquals(expected, fc.toJalviewFormat("domain"));
250
251     /*
252      * graduated colour below threshold
253      */
254     fc.setThreshold(12.5f);
255     fc.setBelowThreshold(true);
256     expected = String.format("domain\t%s|%s|12.0|25.0|below|12.5",
257             greenHex, redHex);
258     assertEquals(expected, fc.toJalviewFormat("domain"));
259
260     /*
261      * graduated colour above threshold
262      */
263     fc.setThreshold(12.5f);
264     fc.setAboveThreshold(true);
265     fc.setAutoScaled(false);
266     expected = String.format("domain\t%s|%s|abso|12.0|25.0|above|12.5",
267             greenHex, redHex);
268     assertEquals(expected, fc.toJalviewFormat("domain"));
269   }
270
271   /**
272    * Test parsing of feature colours from Jalview features file format
273    */
274   @Test(groups = { "Functional" })
275   public void testParseJalviewFeatureColour()
276   {
277     /*
278      * simple colour by name
279      */
280     FeatureColour fc = FeatureColour.parseJalviewFeatureColour("red");
281     assertTrue(fc.isSimpleColour());
282     assertEquals(Color.RED, fc.getColour());
283
284     /*
285      * simple colour by hex code
286      */
287     fc = FeatureColour.parseJalviewFeatureColour(Format
288             .getHexString(Color.RED));
289     assertTrue(fc.isSimpleColour());
290     assertEquals(Color.RED, fc.getColour());
291
292     /*
293      * simple colour by rgb triplet
294      */
295     fc = FeatureColour.parseJalviewFeatureColour("255,0,0");
296     assertTrue(fc.isSimpleColour());
297     assertEquals(Color.RED, fc.getColour());
298
299     /*
300      * malformed colour
301      */
302     try
303     {
304       fc = FeatureColour.parseJalviewFeatureColour("oops");
305       fail("expected exception");
306     } catch (IllegalArgumentException e)
307     {
308       assertEquals("Invalid colour descriptor: oops", e.getMessage());
309     }
310
311     /*
312      * colour by label (no threshold)
313      */
314     fc = FeatureColour.parseJalviewFeatureColour("label");
315     assertTrue(fc.isColourByLabel());
316     assertFalse(fc.hasThreshold());
317
318     /*
319      * colour by label (with threshold)
320      */
321     fc = FeatureColour
322             .parseJalviewFeatureColour("label|||0.0|0.0|above|12.0");
323     assertTrue(fc.isColourByLabel());
324     assertTrue(fc.isAboveThreshold());
325     assertEquals(12.0f, fc.getThreshold());
326
327     /*
328      * graduated colour (by name) (no threshold)
329      */
330     fc = FeatureColour.parseJalviewFeatureColour("red|green|10.0|20.0");
331     assertTrue(fc.isGraduatedColour());
332     assertFalse(fc.hasThreshold());
333     assertEquals(Color.RED, fc.getMinColour());
334     assertEquals(Color.GREEN, fc.getMaxColour());
335     assertEquals(10f, fc.getMin());
336     assertEquals(20f, fc.getMax());
337     assertTrue(fc.isAutoScaled());
338
339     /*
340      * graduated colour (by hex code) (above threshold)
341      */
342     String descriptor = String.format("%s|%s|10.0|20.0|above|15",
343             Format.getHexString(Color.RED),
344             Format.getHexString(Color.GREEN));
345     fc = FeatureColour.parseJalviewFeatureColour(descriptor);
346     assertTrue(fc.isGraduatedColour());
347     assertTrue(fc.hasThreshold());
348     assertTrue(fc.isAboveThreshold());
349     assertEquals(15f, fc.getThreshold());
350     assertEquals(Color.RED, fc.getMinColour());
351     assertEquals(Color.GREEN, fc.getMaxColour());
352     assertEquals(10f, fc.getMin());
353     assertEquals(20f, fc.getMax());
354     assertTrue(fc.isAutoScaled());
355
356     /*
357      * graduated colour (by RGB triplet) (below threshold), absolute scale
358      */
359     descriptor = String.format("255,0,0|0,255,0|abso|10.0|20.0|below|15");
360     fc = FeatureColour.parseJalviewFeatureColour(descriptor);
361     assertTrue(fc.isGraduatedColour());
362     assertFalse(fc.isAutoScaled());
363     assertTrue(fc.hasThreshold());
364     assertTrue(fc.isBelowThreshold());
365     assertEquals(15f, fc.getThreshold());
366     assertEquals(Color.RED, fc.getMinColour());
367     assertEquals(Color.GREEN, fc.getMaxColour());
368     assertEquals(10f, fc.getMin());
369     assertEquals(20f, fc.getMax());
370
371     descriptor = String
372             .format("blue|255,0,255|absolute|20.0|95.0|below|66.0");
373     fc = FeatureColour.parseJalviewFeatureColour(descriptor);
374     assertTrue(fc.isGraduatedColour());
375   }
376 }