AnnotationId is hashcode of object
[jalview.git] / src / jalview / datamodel / AlignmentAnnotation.java
1 /*
2 * Jalview - A Sequence Alignment Editor and Viewer
3 * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
18 */
19 package jalview.datamodel;
20
21
22 /**
23  * DOCUMENT ME!
24  *
25  * @author $author$
26  * @version $Revision$
27  */
28 public class AlignmentAnnotation
29 {
30   /** If true, this annotations is calculated every edit,
31    * eg consensus, quality or conservation graphs */
32   public boolean autoCalculated = false;
33
34   public String annotationId;
35
36     public SequenceI sequenceRef;
37
38     /** DOCUMENT ME!! */
39     public String label;
40
41     /** DOCUMENT ME!! */
42     public String description;
43
44     /** DOCUMENT ME!! */
45     public Annotation[] annotations;
46
47     public java.util.Hashtable sequenceMapping;
48
49     /** DOCUMENT ME!! */
50     public float graphMin;
51
52     /** DOCUMENT ME!! */
53     public float graphMax;
54
55     public GraphLine threshold;
56
57     // Graphical hints and tips
58
59     /** DOCUMENT ME!! */
60     public boolean editable = false;
61
62     /** DOCUMENT ME!! */
63     public boolean hasIcons; //
64
65     /** DOCUMENT ME!! */
66     public boolean hasText;
67
68     /** DOCUMENT ME!! */
69     public boolean visible = true;
70
71     public int graphGroup = -1;
72
73     /** DOCUMENT ME!! */
74     public int height = 0;
75
76     public int graph = 0;
77
78     public int graphHeight = 40;
79
80     public static final int NO_GRAPH = 0;
81
82     public static final int BAR_GRAPH = 1;
83
84     public static final int LINE_GRAPH = 2;
85
86     public static int getGraphValueFromString(String string)
87     {
88       if(string.equalsIgnoreCase("BAR_GRAPH"))
89         return BAR_GRAPH;
90       else if(string.equalsIgnoreCase("LINE_GRAPH"))
91         return LINE_GRAPH;
92       else
93         return NO_GRAPH;
94     }
95
96     /**
97      * Creates a new AlignmentAnnotation object.
98      *
99      * @param label DOCUMENT ME!
100      * @param description DOCUMENT ME!
101      * @param annotations DOCUMENT ME!
102      */
103     public AlignmentAnnotation(String label, String description,
104         Annotation[] annotations)
105     {
106         // always editable?
107         editable = true;
108         this.label = label;
109         this.description = description;
110         this.annotations = annotations;
111
112        areLabelsSecondaryStructure();
113     }
114
115     void areLabelsSecondaryStructure()
116     {
117       boolean nonSSLabel = false;
118       for (int i = 0; i < annotations.length; i++)
119       {
120         if(annotations[i]==null)
121           continue;
122
123         if (annotations[i].secondaryStructure == 'H' ||
124             annotations[i].secondaryStructure == 'E')
125         {
126           hasIcons = true;
127         }
128
129         if (annotations[i].displayCharacter.length()==1
130             && !annotations[i].displayCharacter.equals("H")
131             && !annotations[i].displayCharacter.equals("E")
132             && !annotations[i].displayCharacter.equals("-"))
133         {
134           if(jalview.schemes.ResidueProperties.aaIndex
135              [annotations[i].displayCharacter.charAt(0)]>0)
136           {
137             nonSSLabel = true;
138           }
139         }
140
141         if (annotations[i].displayCharacter.length() > 0)
142         {
143           hasText = true;
144         }
145       }
146
147       if(nonSSLabel)
148       {
149         hasIcons = false;
150         for (int j = 0; j < annotations.length; j++)
151         {
152           if(annotations[j] !=null && annotations[j].secondaryStructure!=' ')
153           {
154             annotations[j].displayCharacter
155                 =String.valueOf(annotations[j].secondaryStructure);
156             annotations[j].secondaryStructure = ' ';
157           }
158
159         }
160
161       }
162
163       annotationId  = this.hashCode()+"";
164     }
165
166     /**
167      * Creates a new AlignmentAnnotation object.
168      *
169      * @param label DOCUMENT ME!
170      * @param description DOCUMENT ME!
171      * @param annotations DOCUMENT ME!
172      * @param min DOCUMENT ME!
173      * @param max DOCUMENT ME!
174      * @param winLength DOCUMENT ME!
175      */
176     public AlignmentAnnotation(String label, String description,
177         Annotation[] annotations, float min, float max, int graphType)
178     {
179         // graphs are not editable
180         this.label = label;
181         this.description = description;
182         this.annotations = annotations;
183         graph = graphType;
184
185         boolean drawValues = true;
186
187         if (min == max)
188         {
189             min = 999999999;
190             for (int i = 0; i < annotations.length; i++)
191             {
192                 if (annotations[i] == null)
193                 {
194                     continue;
195                 }
196
197                 if(drawValues && annotations[i].displayCharacter.length() > 1 )
198                 {
199                   drawValues = false;
200                 }
201
202                 if (annotations[i].value > max)
203                 {
204                     max = annotations[i].value;
205                 }
206
207                 if (annotations[i].value < min)
208                 {
209                     min = annotations[i].value;
210                 }
211             }
212         }
213
214         graphMin = min;
215         graphMax = max;
216
217         areLabelsSecondaryStructure();
218
219         if(!drawValues && graphType!=NO_GRAPH)
220         {
221           for (int i = 0; i < annotations.length; i++)
222           {
223             if (annotations[i] != null)
224               annotations[i].displayCharacter = "";
225           }
226         }
227     }
228
229     /**
230      * DOCUMENT ME!
231      *
232      * @return DOCUMENT ME!
233      */
234     public String toString()
235     {
236         StringBuffer buffer = new StringBuffer();
237
238         for (int i = 0; i < annotations.length; i++)
239         {
240             if (annotations[i] != null)
241             {
242                 if (graph!=0)
243                 {
244                     buffer.append(annotations[i].value);
245                 }
246                 else if (hasIcons)
247                 {
248                     buffer.append(annotations[i].secondaryStructure);
249                 }
250                 else
251                 {
252                     buffer.append(annotations[i].displayCharacter);
253                 }
254             }
255
256             buffer.append(", ");
257         }
258
259         if (label.equals("Consensus"))
260         {
261             buffer.append("\n");
262
263             for (int i = 0; i < annotations.length; i++)
264             {
265                 if (annotations[i] != null)
266                 {
267                     buffer.append(annotations[i].description);
268                 }
269
270                 buffer.append(", ");
271             }
272         }
273
274         return buffer.toString();
275       }
276
277       public void setThreshold(GraphLine line)
278       {
279         threshold = line;
280       }
281
282       public GraphLine getThreshold()
283       {
284           return threshold;
285       }
286
287       /**
288        * Attach the annotation to seqRef, starting from startRes position. If alreadyMapped is true then the indices of the annotation[] array are sequence positions rather than alignment column positions.
289        * @param seqRef
290        * @param startRes
291        * @param alreadyMapped
292        */
293       public void createSequenceMapping(SequenceI seqRef,
294                                         int startRes,
295                                         boolean alreadyMapped)
296       {
297
298         if(seqRef == null)
299           return;
300
301
302         sequenceMapping = new java.util.Hashtable();
303
304         sequenceRef = seqRef;
305         int seqPos;
306
307         for(int i = 0; i < annotations.length; i++)
308         {
309             if (annotations[i] != null)
310             {
311               if(alreadyMapped)
312                 seqPos = seqRef.findPosition(i);
313               else
314                 seqPos = i+startRes;
315
316               sequenceMapping.put(new Integer(seqPos), annotations[i]);
317             }
318          }
319
320       }
321
322       public void adjustForAlignment()
323       {
324           int a=0, aSize = sequenceRef.getLength();
325
326           if(aSize == 0)
327           {
328             //Its been deleted
329             return;
330           }
331
332           int position;
333           Annotation[] temp = new Annotation[aSize];
334           Integer index;
335
336           for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++)
337           {
338               index = new Integer(a);
339               if(sequenceMapping.containsKey(index))
340               {
341                 position = sequenceRef.findIndex(a)-1;
342
343                 temp[position] = (Annotation)sequenceMapping.get(index);
344               }
345           }
346
347           annotations = temp;
348       }
349 }
350
351