Disable memory checker for now
[jalview.git] / src / jalview / datamodel / SequenceGroup.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer
3  * Copyright (C) 2007 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 import java.util.*;
22
23 import java.awt.*;
24
25 import jalview.analysis.*;
26 import jalview.schemes.*;
27
28 /**
29  * DOCUMENT ME!
30  *
31  * @author $author$
32  * @version $Revision$
33  */
34 public class SequenceGroup
35 {
36   String groupName;
37   String description;
38   Conservation conserve;
39   Vector aaFrequency;
40   boolean displayBoxes = true;
41   boolean displayText = true;
42   boolean colourText = true;
43   private Vector sequences = new Vector();
44   int width = -1;
45
46   /** DOCUMENT ME!! */
47   public ColourSchemeI cs;
48   int startRes = 0;
49   int endRes = 0;
50   Color outlineColour = Color.black;
51   public int thresholdTextColour = 0;
52   public Color textColour = Color.black;
53   public Color textColour2 = Color.white;
54
55   /**
56    * Creates a new SequenceGroup object.
57    */
58   public SequenceGroup()
59   {
60     groupName = "JGroup:" + this.hashCode();
61   }
62
63   /**
64    * Creates a new SequenceGroup object.
65    *
66    * @param sequences DOCUMENT ME!
67    * @param groupName DOCUMENT ME!
68    * @param scheme DOCUMENT ME!
69    * @param displayBoxes DOCUMENT ME!
70    * @param displayText DOCUMENT ME!
71    * @param colourText DOCUMENT ME!
72    * @param start DOCUMENT ME!
73    * @param end DOCUMENT ME!
74    */
75   public SequenceGroup(Vector sequences, String groupName,
76                        ColourSchemeI scheme, boolean displayBoxes,
77                        boolean displayText,
78                        boolean colourText, int start, int end)
79   {
80     this.sequences = sequences;
81     this.groupName = groupName;
82     this.displayBoxes = displayBoxes;
83     this.displayText = displayText;
84     this.colourText = colourText;
85     this.cs = scheme;
86     startRes = start;
87     endRes = end;
88     recalcConservation();
89   }
90
91   public SequenceI[] getSelectionAsNewSequences(AlignmentI align)
92   {
93     int iSize = sequences.size();
94     SequenceI[] seqs = new SequenceI[iSize];
95     SequenceI[] inorder = getSequencesInOrder(align);
96
97     for (int i = 0; i < iSize; i++)
98     {
99       SequenceI seq = inorder[i];
100
101       seqs[i] = new Sequence(seq.getName(),
102                              seq.getSequence(startRes, endRes + 1),
103                              seq.findPosition(startRes),
104                              findEndRes(seq));
105
106       seqs[i].setDescription(seq.getDescription());
107       seqs[i].setDBRef(seq.getDBRef());
108       seqs[i].setSequenceFeatures(seq.getSequenceFeatures());
109       if (seq.getDatasetSequence() != null)
110       {
111         seqs[i].setDatasetSequence(seq.getDatasetSequence());
112       }
113
114       if (seq.getAnnotation() != null)
115       {
116         for (int a = 0; a < seq.getAnnotation().length; a++)
117         {
118           seqs[i].addAlignmentAnnotation(new AlignmentAnnotation(seq.getAnnotation()[a]));
119         }
120       }
121     }
122
123     return seqs;
124
125   }
126
127   /**
128    * If sequence ends in gaps, the end residue can
129    * be correctly calculated here
130    * @param seq SequenceI
131    * @return int
132    */
133   public int findEndRes(SequenceI seq)
134   {
135     int eres = 0;
136     char ch;
137
138     for (int j = 0; j < endRes + 1 && j < seq.getLength(); j++)
139     {
140       ch = seq.getCharAt(j);
141       if (!jalview.util.Comparison.isGap( (ch)))
142       {
143         eres++;
144       }
145     }
146
147     if (eres > 0)
148     {
149       eres += seq.getStart() - 1;
150     }
151
152     return eres;
153   }
154
155   public Vector getSequences(Hashtable hiddenReps)
156   {
157     if (hiddenReps == null)
158     {
159       return sequences;
160     }
161     else
162     {
163       Vector allSequences = new Vector();
164       SequenceI seq, seq2;
165       for (int i = 0; i < sequences.size(); i++)
166       {
167         seq = (SequenceI) sequences.elementAt(i);
168         allSequences.addElement(seq);
169         if (hiddenReps.containsKey(seq))
170         {
171           SequenceGroup hsg = (SequenceGroup) hiddenReps.get(seq);
172           for (int h = 0; h < hsg.getSize(); h++)
173           {
174             seq2 = hsg.getSequenceAt(h);
175             if (seq2 != seq
176                 && !allSequences.contains(seq2))
177             {
178               allSequences.addElement(seq2);
179             }
180           }
181         }
182       }
183
184       return allSequences;
185     }
186   }
187
188   public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)
189   {
190     Vector tmp = getSequences(hiddenReps);
191     if (tmp == null)
192     {
193       return null;
194     }
195     SequenceI[] result = new SequenceI[tmp.size()];
196     for (int i = 0; i < result.length; i++)
197     {
198       result[i] = (SequenceI) tmp.elementAt(i);
199     }
200
201     return result;
202   }
203
204   /**
205    * DOCUMENT ME!
206    *
207    * @param col DOCUMENT ME!
208    *
209    * @return DOCUMENT ME!
210    */
211   public boolean adjustForRemoveLeft(int col)
212   {
213     // return value is true if the group still exists
214     if (startRes >= col)
215     {
216       startRes = startRes - col;
217     }
218
219     if (endRes >= col)
220     {
221       endRes = endRes - col;
222
223       if (startRes > endRes)
224       {
225         startRes = 0;
226       }
227     }
228     else
229     {
230       // must delete this group!!
231       return false;
232     }
233
234     return true;
235   }
236
237   /**
238    * DOCUMENT ME!
239    *
240    * @param col DOCUMENT ME!
241    *
242    * @return DOCUMENT ME!
243    */
244   public boolean adjustForRemoveRight(int col)
245   {
246     if (startRes > col)
247     {
248       // delete this group
249       return false;
250     }
251
252     if (endRes >= col)
253     {
254       endRes = col;
255     }
256
257     return true;
258   }
259
260   /**
261    * DOCUMENT ME!
262    *
263    * @return DOCUMENT ME!
264    */
265   public String getName()
266   {
267     return groupName;
268   }
269
270   public String getDescription()
271   {
272     return description;
273   }
274
275   /**
276    * DOCUMENT ME!
277    *
278    * @param name DOCUMENT ME!
279    */
280   public void setName(String name)
281   {
282     groupName = name;
283   }
284
285   public void setDescription(String desc)
286   {
287     description = desc;
288   }
289
290   /**
291    * DOCUMENT ME!
292    *
293    * @return DOCUMENT ME!
294    */
295   public Conservation getConservation()
296   {
297     return conserve;
298   }
299
300   /**
301    * DOCUMENT ME!
302    *
303    * @param c DOCUMENT ME!
304    */
305   public void setConservation(Conservation c)
306   {
307     conserve = c;
308   }
309
310   /**
311    * DOCUMENT ME!
312    *
313    * @param s DOCUMENT ME!
314    * @param recalc DOCUMENT ME!
315    */
316   public void addSequence(SequenceI s, boolean recalc)
317   {
318     if (s != null && !sequences.contains(s))
319     {
320       sequences.addElement(s);
321     }
322
323     if (recalc)
324     {
325       recalcConservation();
326     }
327   }
328
329   /**
330    * DOCUMENT ME!
331    */
332   public void recalcConservation()
333   {
334     if (cs == null)
335     {
336       return;
337     }
338
339     try
340     {
341       cs.setConsensus(AAFrequency.calculate(sequences, startRes, endRes + 1));
342
343       if (cs instanceof ClustalxColourScheme)
344       {
345         ( (ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
346       }
347
348       if (cs.conservationApplied())
349       {
350         Conservation c = new Conservation(groupName,
351                                           ResidueProperties.propHash, 3,
352                                           sequences,
353                                           startRes, endRes + 1);
354         c.calculate();
355         c.verdict(false, 25);
356
357         cs.setConservation(c);
358
359         if (cs instanceof ClustalxColourScheme)
360         {
361           ( (ClustalxColourScheme) cs).resetClustalX(sequences,
362               getWidth());
363         }
364       }
365     }
366     catch (java.lang.OutOfMemoryError err)
367     {
368       System.out.println("Out of memory loading groups: " + err);
369     }
370
371   }
372
373   /**
374    * DOCUMENT ME!
375    *
376    * @param s DOCUMENT ME!
377    * @param recalc DOCUMENT ME!
378    */
379   public void addOrRemove(SequenceI s, boolean recalc)
380   {
381     if (sequences.contains(s))
382     {
383       deleteSequence(s, recalc);
384     }
385     else
386     {
387       addSequence(s, recalc);
388     }
389   }
390
391   /**
392    * DOCUMENT ME!
393    *
394    * @param s DOCUMENT ME!
395    * @param recalc DOCUMENT ME!
396    */
397   public void deleteSequence(SequenceI s, boolean recalc)
398   {
399     sequences.removeElement(s);
400
401     if (recalc)
402     {
403       recalcConservation();
404     }
405   }
406
407   /**
408    * DOCUMENT ME!
409    *
410    * @return DOCUMENT ME!
411    */
412   public int getStartRes()
413   {
414     return startRes;
415   }
416
417   /**
418    * DOCUMENT ME!
419    *
420    * @return DOCUMENT ME!
421    */
422   public int getEndRes()
423   {
424     return endRes;
425   }
426
427   /**
428    * DOCUMENT ME!
429    *
430    * @param i DOCUMENT ME!
431    */
432   public void setStartRes(int i)
433   {
434     startRes = i;
435   }
436
437   /**
438    * DOCUMENT ME!
439    *
440    * @param i DOCUMENT ME!
441    */
442   public void setEndRes(int i)
443   {
444     endRes = i;
445   }
446
447   /**
448    * DOCUMENT ME!
449    *
450    * @return DOCUMENT ME!
451    */
452   public int getSize()
453   {
454     return sequences.size();
455   }
456
457   /**
458    * DOCUMENT ME!
459    *
460    * @param i DOCUMENT ME!
461    *
462    * @return DOCUMENT ME!
463    */
464   public SequenceI getSequenceAt(int i)
465   {
466     return (SequenceI) sequences.elementAt(i);
467   }
468
469   /**
470    * DOCUMENT ME!
471    *
472    * @param state DOCUMENT ME!
473    */
474   public void setColourText(boolean state)
475   {
476     colourText = state;
477   }
478
479   /**
480    * DOCUMENT ME!
481    *
482    * @return DOCUMENT ME!
483    */
484   public boolean getColourText()
485   {
486     return colourText;
487   }
488
489   /**
490    * DOCUMENT ME!
491    *
492    * @param state DOCUMENT ME!
493    */
494   public void setDisplayText(boolean state)
495   {
496     displayText = state;
497   }
498
499   /**
500    * DOCUMENT ME!
501    *
502    * @return DOCUMENT ME!
503    */
504   public boolean getDisplayText()
505   {
506     return displayText;
507   }
508
509   /**
510    * DOCUMENT ME!
511    *
512    * @param state DOCUMENT ME!
513    */
514   public void setDisplayBoxes(boolean state)
515   {
516     displayBoxes = state;
517   }
518
519   /**
520    * DOCUMENT ME!
521    *
522    * @return DOCUMENT ME!
523    */
524   public boolean getDisplayBoxes()
525   {
526     return displayBoxes;
527   }
528
529   /**
530    * DOCUMENT ME!
531    *
532    * @return DOCUMENT ME!
533    */
534   public int getWidth()
535   {
536     // MC This needs to get reset when characters are inserted and deleted
537     if (sequences.size() > 0)
538     {
539       width = ( (SequenceI) sequences.elementAt(0)).getLength();
540     }
541
542     for (int i = 1; i < sequences.size(); i++)
543     {
544       SequenceI seq = (SequenceI) sequences.elementAt(i);
545
546       if (seq.getLength() > width)
547       {
548         width = seq.getLength();
549       }
550     }
551
552     return width;
553   }
554
555   /**
556    * DOCUMENT ME!
557    *
558    * @param c DOCUMENT ME!
559    */
560   public void setOutlineColour(Color c)
561   {
562     outlineColour = c;
563   }
564
565   /**
566    * DOCUMENT ME!
567    *
568    * @return DOCUMENT ME!
569    */
570   public Color getOutlineColour()
571   {
572     return outlineColour;
573   }
574
575   /**
576    *
577    * returns the sequences in the group ordered by the ordering given by al
578    *
579    * @param al Alignment
580    * @return SequenceI[]
581    */
582   public SequenceI[] getSequencesInOrder(AlignmentI al)
583   {
584     int sSize = sequences.size();
585     int alHeight = al.getHeight();
586
587     SequenceI[] seqs = new SequenceI[sSize];
588
589     int index = 0;
590     for (int i = 0; i < alHeight && index < sSize; i++)
591     {
592       if (sequences.contains(al.getSequenceAt(i)))
593       {
594         seqs[index++] = al.getSequenceAt(i);
595       }
596     }
597
598     return seqs;
599   }
600 }