JAL-3949 fixed failing commandlinetests due to more output and line count limit
[jalview.git] / src / jalview / schemes / UserColourScheme.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 java.util.Locale;
24
25 import jalview.api.AlignViewportI;
26 import jalview.datamodel.AnnotatedCollectionI;
27 import jalview.util.ColorUtils;
28 import jalview.util.StringUtils;
29
30 import java.awt.Color;
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.HashMap;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.Map.Entry;
37 import java.util.StringTokenizer;
38
39 public class UserColourScheme extends ResidueColourScheme
40 {
41   /*
42    * lookup (by symbol index) of lower case colours (if configured)
43    */
44   Color[] lowerCaseColours;
45
46   protected String schemeName;
47
48   public UserColourScheme()
49   {
50     super(ResidueProperties.aaIndex);
51   }
52
53   public UserColourScheme(Color[] newColors)
54   {
55     super(ResidueProperties.aaIndex);
56     colors = newColors;
57   }
58
59   @Override
60   public ColourSchemeI getInstance(AlignViewportI view,
61           AnnotatedCollectionI sg)
62   {
63     return new UserColourScheme(this);
64   }
65
66   /**
67    * Copy constructor
68    * 
69    * @return
70    */
71   protected UserColourScheme(UserColourScheme from)
72   {
73     this(from.colors);
74     schemeName = from.schemeName;
75     if (from.lowerCaseColours != null)
76     {
77       lowerCaseColours = new Color[from.lowerCaseColours.length];
78       System.arraycopy(from.lowerCaseColours, 0, lowerCaseColours, 0,
79               from.lowerCaseColours.length);
80     }
81   }
82
83   /**
84    * Constructor for an animino acid colour scheme. The colour specification may
85    * be one of
86    * <ul>
87    * <li>an AWT colour name e.g. red</li>
88    * <li>an AWT hex rgb colour e.g. ff2288</li>
89    * <li>residue colours list e.g. D,E=red;K,R,H=0022FF;c=yellow</li>
90    * </ul>
91    * 
92    * @param colour
93    */
94   public UserColourScheme(String colour)
95   {
96     super(ResidueProperties.aaIndex);
97
98     if (colour.contains("="))
99     {
100       /*
101        * a list of colours per residue(s)
102        */
103       parseAppletParameter(colour);
104       return;
105     }
106
107     Color col = ColorUtils.parseColourString(colour);
108
109     if (col == null)
110     {
111       System.out.println("Making colour from name: " + colour);
112       col = ColorUtils.createColourFromName(colour);
113     }
114
115     setAll(col);
116     schemeName = colour;
117   }
118
119   /**
120    * Sets all symbols to the specified colour
121    * 
122    * @param col
123    */
124   protected void setAll(Color col)
125   {
126     if (symbolIndex == null)
127     {
128       return;
129     }
130     int max = 0;
131     for (int index : symbolIndex)
132     {
133       max = Math.max(max, index);
134     }
135     colors = new Color[max + 1];
136     for (int i = 0; i <= max; i++)
137     {
138       colors[i] = col;
139     }
140   }
141
142   public Color[] getColours()
143   {
144     return colors;
145   }
146
147   public Color[] getLowerCaseColours()
148   {
149     return lowerCaseColours;
150   }
151
152   public void setName(String name)
153   {
154     schemeName = name;
155   }
156
157   public String getName()
158   {
159     return schemeName;
160   }
161
162   /**
163    * Parse and save residue colours specified as (for example)
164    * 
165    * <pre>
166    *     D,E=red; K,R,H=0022FF; c=100,50,75
167    * </pre>
168    * 
169    * This should be a semi-colon separated list of colours, which may be defined
170    * by colour name, hex value or comma-separated RGB triple. Each colour is
171    * defined for a comma-separated list of amino acid single letter codes. (Note
172    * that this also allows a colour scheme to be defined for ACGT, but not for
173    * U.)
174    * 
175    * @param paramValue
176    */
177   void parseAppletParameter(String paramValue)
178   {
179     setAll(Color.white);
180
181     StringTokenizer st = new StringTokenizer(paramValue, ";");
182     StringTokenizer st2;
183     String token = null, colour, residues;
184     try
185     {
186       while (st.hasMoreElements())
187       {
188         token = st.nextToken().trim();
189         residues = token.substring(0, token.indexOf("="));
190         colour = token.substring(token.indexOf("=") + 1);
191
192         st2 = new StringTokenizer(residues, " ,");
193         while (st2.hasMoreTokens())
194         {
195           String residue = st2.nextToken();
196
197           int colIndex = ResidueProperties.aaIndex[residue.charAt(0)];
198           if (colIndex == -1)
199           {
200             continue;
201           }
202
203           if (residue.equalsIgnoreCase("lowerCase"))
204           {
205             if (lowerCaseColours == null)
206             {
207               lowerCaseColours = new Color[colors.length];
208             }
209             for (int i = 0; i < lowerCaseColours.length; i++)
210             {
211               if (lowerCaseColours[i] == null)
212               {
213                 lowerCaseColours[i] = ColorUtils.parseColourString(colour);
214               }
215             }
216
217             continue;
218           }
219
220           if (residue.equals(residue.toLowerCase(Locale.ROOT)))
221           {
222             if (lowerCaseColours == null)
223             {
224               lowerCaseColours = new Color[colors.length];
225             }
226             lowerCaseColours[colIndex] = ColorUtils
227                     .parseColourString(colour);
228           }
229           else
230           {
231             colors[colIndex] = ColorUtils.parseColourString(colour);
232           }
233         }
234       }
235     } catch (Exception ex)
236     {
237       System.out.println(
238               "Error parsing userDefinedColours:\n" + token + "\n" + ex);
239     }
240
241   }
242
243   public void setLowerCaseColours(Color[] lcolours)
244   {
245     lowerCaseColours = lcolours;
246   }
247
248   /**
249    * Returns the colour for the given residue character. If the residue is
250    * lower-case, and there is a specific colour defined for lower case, that
251    * colour is returned, else the colour for the upper case residue.
252    */
253   @Override
254   public Color findColour(char c)
255   {
256     if ('a' <= c && c <= 'z' && lowerCaseColours != null)
257     {
258       Color colour = lowerCaseColours[symbolIndex[c]];
259       if (colour != null)
260       {
261         return colour;
262       }
263     }
264     return super.findColour(c);
265   }
266
267   /**
268    * Answers the customised name of the colour scheme, if it has one, else "User
269    * Defined"
270    */
271   @Override
272   public String getSchemeName()
273   {
274     if (schemeName != null && schemeName.length() > 0)
275     {
276       return schemeName;
277     }
278     return ResidueColourScheme.USER_DEFINED;
279   }
280
281   /**
282    * Generate an applet colour parameter like A,C,D=12ffe9;Q,W=2393fd;w=9178dd
283    * 
284    * @return
285    */
286   public String toAppletParameter()
287   {
288     /*
289      * step 1: build a map from colours to the symbol(s) that have the colour
290      */
291     Map<Color, List<String>> colours = new HashMap<>();
292
293     for (char symbol = 'A'; symbol <= 'Z'; symbol++)
294     {
295       String residue = String.valueOf(symbol);
296       int index = symbolIndex[symbol];
297       Color c = colors[index];
298       if (c != null && !c.equals(Color.white))
299       {
300         if (colours.get(c) == null)
301         {
302           colours.put(c, new ArrayList<String>());
303         }
304         colours.get(c).add(residue);
305       }
306       if (lowerCaseColours != null)
307       {
308         c = lowerCaseColours[index];
309         if (c != null && !c.equals(Color.white))
310         {
311           residue = residue.toLowerCase(Locale.ROOT);
312           if (colours.get(c) == null)
313           {
314             colours.put(c, new ArrayList<String>());
315           }
316           colours.get(c).add(residue);
317         }
318       }
319     }
320
321     /*
322      * step 2: make a list of { A,G,R=12f9d6 } residues/colour specs
323      */
324     List<String> residueColours = new ArrayList<>();
325     for (Entry<Color, List<String>> cols : colours.entrySet())
326     {
327       boolean first = true;
328       StringBuilder sb = new StringBuilder();
329       for (String residue : cols.getValue())
330       {
331         if (!first)
332         {
333           sb.append(",");
334         }
335         sb.append(residue);
336         first = false;
337       }
338       sb.append("=");
339       /*
340        * get color as hex value, dropping the alpha (ff) part
341        */
342       String hexString = Integer.toHexString(cols.getKey().getRGB())
343               .substring(2);
344       sb.append(hexString);
345       residueColours.add(sb.toString());
346     }
347
348     /*
349      * sort and output
350      */
351     Collections.sort(residueColours);
352     return StringUtils.listToDelimitedString(residueColours, ";");
353   }
354
355   @Override
356   public boolean hasGapColour()
357   {
358     return (findColour(' ') != null);
359   }
360 }