60129fb8d634c459f83f152176f03bd7ee8c9caf
[jalview.git] / ColorUtils.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 /**
22  * author: Lauren Michelle Lui
23  */
24
25 package jalview.util;
26
27 import java.awt.Color;
28 import java.util.HashMap;
29 import java.util.Map;
30 import java.util.Random;
31
32 public class ColorUtils
33 {
34   private static final int MAX_CACHE_SIZE = 1729;
35   /*
36    * a cache for colours generated from text strings
37    */
38   static Map<String, Color> myColours = new HashMap<>();
39
40   /**
41    * Generates a random color, will mix with input color. Code taken from
42    * http://stackoverflow
43    * .com/questions/43044/algorithm-to-randomly-generate-an-aesthetically
44    * -pleasing-color-palette
45    * 
46    * @param mix
47    * @return Random color in RGB
48    */
49   public static final Color generateRandomColor(Color mix)
50   {
51     Random random = new Random();
52     int red = random.nextInt(256);
53     int green = random.nextInt(256);
54     int blue = random.nextInt(256);
55
56     // mix the color
57     if (mix != null)
58     {
59       red = (red + mix.getRed()) / 2;
60       green = (green + mix.getGreen()) / 2;
61       blue = (blue + mix.getBlue()) / 2;
62     }
63
64     Color color = new Color(red, green, blue);
65     return color;
66
67   }
68
69   /**
70    * Convert to Tk colour code format
71    * 
72    * @param colour
73    * @return
74    * @see http
75    *      ://www.cgl.ucsf.edu/chimera/current/docs/UsersGuide/colortool.html#
76    *      tkcode
77    */
78   public static final String toTkCode(Color colour)
79   {
80     String colstring = "#" + ((colour.getRed() < 16) ? "0" : "")
81             + Integer.toHexString(colour.getRed())
82             + ((colour.getGreen() < 16) ? "0" : "")
83             + Integer.toHexString(colour.getGreen())
84             + ((colour.getBlue() < 16) ? "0" : "")
85             + Integer.toHexString(colour.getBlue());
86     return colstring;
87   }
88
89   /**
90    * Returns a colour three shades darker. Note you can't guarantee that
91    * brighterThan reverses this, as darkerThan may result in black.
92    * 
93    * @param col
94    * @return
95    */
96   public static Color darkerThan(Color col)
97   {
98     return col == null ? null : col.darker().darker().darker();
99   }
100
101   /**
102    * Returns a colour three shades brighter. Note you can't guarantee that
103    * darkerThan reverses this, as brighterThan may result in white.
104    * 
105    * @param col
106    * @return
107    */
108   public static Color brighterThan(Color col)
109   {
110     return col == null ? null : col.brighter().brighter().brighter();
111   }
112
113   /**
114    * Returns a color between minColour and maxColour; the RGB values are in
115    * proportion to where 'value' lies between minValue and maxValue
116    * 
117    * @param value
118    * @param minValue
119    * @param minColour
120    * @param maxValue
121    * @param maxColour
122    * @return
123    */
124   public static Color getGraduatedColour(float value, float minValue,
125           Color minColour, float maxValue, Color maxColour)
126   {
127     if (minValue == maxValue)
128     {
129       return minColour;
130     }
131     if (value < minValue)
132     {
133       value = minValue;
134     }
135     if (value > maxValue)
136     {
137       value = maxValue;
138     }
139
140     /*
141      * prop = proportion of the way value is from minValue to maxValue
142      */
143     float prop = (value - minValue) / (maxValue - minValue);
144     float r = minColour.getRed()
145             + prop * (maxColour.getRed() - minColour.getRed());
146     float g = minColour.getGreen()
147             + prop * (maxColour.getGreen() - minColour.getGreen());
148     float b = minColour.getBlue()
149             + prop * (maxColour.getBlue() - minColour.getBlue());
150     return new Color(r / 255, g / 255, b / 255);
151   }
152
153   /**
154    * 'Fades' the given colour towards white by the specified proportion. A
155    * factor of 1 or more results in White, a factor of 0 leaves the colour
156    * unchanged, and a factor between 0 and 1 results in a proportionate change
157    * of RGB values towards (255, 255, 255).
158    * <p>
159    * A negative bleachFactor can be specified to darken the colour towards Black
160    * (0, 0, 0).
161    * 
162    * @param colour
163    * @param bleachFactor
164    * @return
165    */
166   public static Color bleachColour(Color colour, float bleachFactor)
167   {
168     if (bleachFactor >= 1f)
169     {
170       return Color.WHITE;
171     }
172     if (bleachFactor <= -1f)
173     {
174       return Color.BLACK;
175     }
176     if (bleachFactor == 0f)
177     {
178       return colour;
179     }
180
181     int red = colour.getRed();
182     int green = colour.getGreen();
183     int blue = colour.getBlue();
184
185     if (bleachFactor > 0)
186     {
187       red += (255 - red) * bleachFactor;
188       green += (255 - green) * bleachFactor;
189       blue += (255 - blue) * bleachFactor;
190       return new Color(red, green, blue);
191     }
192     else
193     {
194       float factor = 1 + bleachFactor;
195       red *= factor;
196       green *= factor;
197       blue *= factor;
198       return new Color(red, green, blue);
199     }
200   }
201
202   /**
203    * Parses a string into a Color, where the accepted formats are
204    * <ul>
205    * <li>an AWT colour name e.g. white</li>
206    * <li>a hex colour value (without prefix) e.g. ff0000</li>
207    * <li>an rgb triple e.g. 100,50,150</li>
208    * </ul>
209    * 
210    * @param colour
211    * @return the parsed colour, or null if parsing fails
212    */
213   public static Color parseColourString(String colour)
214   {
215     if (colour == null)
216     {
217       return null;
218     }
219     colour = colour.trim();
220
221     Color col = null;
222     try
223     {
224       int value = Integer.parseInt(colour, 16);
225       col = new Color(value);
226     } catch (NumberFormatException ex)
227     {
228     }
229
230     if (col == null)
231     {
232       col = ColorUtils.getAWTColorFromName(colour);
233     }
234
235     if (col == null)
236     {
237       try
238       {
239         String[] tokens = colour.split(",");
240         if (tokens.length == 3)
241         {
242           int r = Integer.parseInt(tokens[0].trim());
243           int g = Integer.parseInt(tokens[1].trim());
244           int b = Integer.parseInt(tokens[2].trim());
245           col = new Color(r, g, b);
246         }
247       } catch (Exception ex)
248       {
249         // non-numeric token or out of 0-255 range
250       }
251     }
252
253     return col;
254   }
255
256   /**
257    * Constructs a colour from a text string. The hashcode of the whole string is
258    * scaled to the range 0-135. This is added to RGB values made from the
259    * hashcode of each third of the string, and scaled to the range 20-229.
260    * 
261    * @param name
262    * @return
263    */
264   public static Color createColourFromName(String name)
265   {
266     if (name == null)
267     {
268       return Color.white;
269     }
270     if (myColours.containsKey(name))
271     {
272       return myColours.get(name);
273     }
274     int lsize = name.length();
275     int start = 0;
276     int end = lsize / 3;
277
278     int rgbOffset = Math.abs(name.hashCode() % 10) * 15; // 0-135
279
280     /*
281      * red: first third
282      */
283     int r = Math.abs(name.substring(start, end).hashCode() + rgbOffset)
284             % 210 + 20;
285     start = end;
286     end += lsize / 3;
287     if (end > lsize)
288     {
289       end = lsize;
290     }
291
292     /*
293      * green: second third
294      */
295     int g = Math.abs(name.substring(start, end).hashCode() + rgbOffset)
296             % 210 + 20;
297
298     /*
299      * blue: third third
300      */
301     int b = Math.abs(name.substring(end).hashCode() + rgbOffset) % 210 + 20;
302
303     Color color = new Color(r, g, b);
304
305     if (myColours.size() < MAX_CACHE_SIZE)
306     {
307       myColours.put(name, color);
308     }
309
310     return color;
311   }
312
313   /**
314    * Returns the Color constant for a given colour name e.g. "pink", or null if
315    * the name is not recognised
316    * 
317    * @param name
318    * @return
319    */
320   public static Color getAWTColorFromName(String name)
321   {
322     if (name == null)
323     {
324       return null;
325     }
326     Color col = null;
327     name = name.toLowerCase();
328
329     // or make a static map; or use reflection on the field name
330     switch (name)
331     {
332     case "black":
333       col = Color.black;
334       break;
335     case "blue":
336       col = Color.blue;
337       break;
338     case "cyan":
339       col = Color.cyan;
340       break;
341     case "darkgray":
342       col = Color.darkGray;
343       break;
344     case "gray":
345       col = Color.gray;
346       break;
347     case "green":
348       col = Color.green;
349       break;
350     case "lightgray":
351       col = Color.lightGray;
352       break;
353     case "magenta":
354       col = Color.magenta;
355       break;
356     case "orange":
357       col = Color.orange;
358       break;
359     case "pink":
360       col = Color.pink;
361       break;
362     case "red":
363       col = Color.red;
364       break;
365     case "white":
366       col = Color.white;
367       break;
368     case "yellow":
369       col = Color.yellow;
370       break;
371     }
372
373     return col;
374   }
375 }