JAL-1632 add score model params to PCAModel and PCA constructors
[jalview.git] / src / jalview / datamodel / HiddenSequences.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.datamodel;
22
23 import java.util.ArrayList;
24 import java.util.List;
25 import java.util.Map;
26
27 public class HiddenSequences
28 {
29   /**
30    * holds a list of hidden sequences associated with an alignment.
31    */
32   public SequenceI[] hiddenSequences;
33
34   AlignmentI alignment;
35
36   /**
37    * Constructor given a reference to an alignment (with no hidden sequences)
38    * 
39    * @param al
40    */
41   public HiddenSequences(AlignmentI al)
42   {
43     alignment = al;
44   }
45
46   /**
47    * Answers the number of hidden sequences
48    * 
49    * @return
50    */
51   public int getSize()
52   {
53     if (hiddenSequences == null)
54     {
55       return 0;
56     }
57     int count = 0;
58     for (SequenceI seq : hiddenSequences)
59     {
60       if (seq != null)
61       {
62         count++;
63       }
64     }
65
66     return count;
67   }
68
69   /**
70    * Answers the length of the longest hidden sequence
71    * 
72    * @return
73    */
74   public int getWidth()
75   {
76     if (hiddenSequences == null)
77     {
78       return 0;
79     }
80     int width = 0;
81     for (SequenceI seq : hiddenSequences)
82     {
83       if (seq != null && seq.getLength() > width)
84       {
85         width = seq.getLength();
86       }
87     }
88
89     return width;
90   }
91
92   /**
93    * Call this method after a sequence is removed from the main alignment
94    */
95   public void adjustHeightSequenceDeleted(int seqIndex)
96   {
97     if (hiddenSequences == null)
98     {
99       return;
100     }
101
102     int alHeight = alignment.getHeight();
103
104     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
105     int deletionIndex = adjustForHiddenSeqs(seqIndex);
106
107     for (int i = 0; i < hiddenSequences.length; i++)
108     {
109       if (hiddenSequences[i] == null)
110       {
111         continue;
112       }
113
114       if (i > deletionIndex)
115       {
116         tmp[i - 1] = hiddenSequences[i];
117       }
118       else
119       {
120         tmp[i] = hiddenSequences[i];
121       }
122     }
123
124     hiddenSequences = tmp;
125
126   }
127
128   /**
129    * Call this method after a sequence is added to the main alignment
130    */
131   public void adjustHeightSequenceAdded()
132   {
133     if (hiddenSequences == null)
134     {
135       return;
136     }
137
138     int alHeight = alignment.getHeight();
139
140     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
141     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
142     hiddenSequences = tmp;
143   }
144
145   /**
146    * Mark the specified sequence as hidden
147    * 
148    * @param sequence
149    */
150   public void hideSequence(SequenceI sequence)
151   {
152     if (hiddenSequences == null)
153     {
154       hiddenSequences = new SequenceI[alignment.getHeight()];
155     }
156
157     int alignmentIndex = alignment.findIndex(sequence);
158     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
159
160     if (hiddenSequences[alignmentIndex] != null)
161     {
162       System.out.println("ERROR!!!!!!!!!!!");
163     }
164
165     hiddenSequences[alignmentIndex] = sequence;
166
167     alignment.deleteSequence(sequence);
168   }
169
170   public List<SequenceI> showAll(
171           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
172   {
173     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
174     for (int i = 0; i < hiddenSequences.length; i++)
175     {
176       if (hiddenSequences[i] != null)
177       {
178         List<SequenceI> tmp = showSequence(i, hiddenRepSequences);
179         for (SequenceI seq : tmp)
180         {
181           revealedSeqs.add(seq);
182         }
183       }
184     }
185     return revealedSeqs;
186   }
187
188   /**
189    * Reveals (unhides) consecutive hidden sequences just above the given
190    * alignment index. The revealed sequences are selected (including their
191    * visible representative sequence if there was one and 'reveal' is being
192    * performed on it).
193    * 
194    * @param alignmentIndex
195    * @param hiddenRepSequences
196    *          a map of representative sequences to the sequences they represent
197    * @return
198    */
199   public List<SequenceI> showSequence(int alignmentIndex,
200           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
201   {
202     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
203     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
204     if (repSequence != null && hiddenRepSequences != null
205             && hiddenRepSequences.containsKey(repSequence))
206     {
207       hiddenRepSequences.remove(repSequence);
208       revealedSeqs.add(repSequence);
209     }
210
211     int start = adjustForHiddenSeqs(alignmentIndex - 1);
212     int end = adjustForHiddenSeqs(alignmentIndex);
213     if (end >= hiddenSequences.length)
214     {
215       end = hiddenSequences.length - 1;
216     }
217
218     List<SequenceI> asequences;
219     synchronized (asequences = alignment.getSequences())
220     {
221       for (int index = end; index > start; index--)
222       {
223         SequenceI seq = hiddenSequences[index];
224         hiddenSequences[index] = null;
225
226         if (seq != null)
227         {
228           if (seq.getLength() > 0)
229           {
230             revealedSeqs.add(seq);
231             asequences.add(alignmentIndex, seq);
232           }
233           else
234           {
235             System.out.println(seq.getName()
236                     + " has been deleted whilst hidden");
237           }
238         }
239       }
240     }
241     return revealedSeqs;
242   }
243
244   public SequenceI getHiddenSequence(int alignmentIndex)
245   {
246     return hiddenSequences == null ? null : hiddenSequences[alignmentIndex];
247   }
248
249   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
250   {
251     if (hiddenSequences == null)
252     {
253       return alignmentIndex;
254     }
255     int index = 0;
256     int hiddenSeqs = 0;
257     if (hiddenSequences.length <= alignmentIndex)
258     {
259       alignmentIndex = hiddenSequences.length - 1;
260     }
261
262     while (index <= alignmentIndex)
263     {
264       if (hiddenSequences[index] != null)
265       {
266         hiddenSeqs++;
267       }
268       index++;
269     }
270
271     return (alignmentIndex - hiddenSeqs);
272   }
273
274   public int adjustForHiddenSeqs(int alignmentIndex)
275   {
276     if (hiddenSequences == null)
277     {
278       return alignmentIndex;
279     }
280     int index = 0;
281     int hSize = hiddenSequences.length;
282     while (index <= alignmentIndex && index < hSize)
283     {
284       if (hiddenSequences[index] != null)
285       {
286         alignmentIndex++;
287       }
288       index++;
289     }
290     ;
291
292     return alignmentIndex;
293   }
294
295   /**
296    * makes a copy of the alignment with hidden sequences included. Using the
297    * copy for anything other than simple output is not recommended. Note - this
298    * method DOES NOT USE THE AlignmentI COPY CONSTRUCTOR!
299    * 
300    * @return
301    */
302   public AlignmentI getFullAlignment()
303   {
304     SequenceI[] seq;
305     if (hiddenSequences == null)
306     {
307       seq = alignment.getSequencesArray();
308     }
309     else
310     {
311       int isize = hiddenSequences.length;
312       seq = new Sequence[isize];
313
314       int index = 0;
315       for (int i = 0; i < hiddenSequences.length; i++)
316       {
317         if (hiddenSequences[i] != null)
318         {
319           seq[i] = hiddenSequences[i];
320         }
321         else
322         {
323           seq[i] = alignment.getSequenceAt(index);
324           index++;
325         }
326       }
327     }
328     Alignment fAlignmt = new Alignment(seq);
329     fAlignmt.annotations = alignment.getAlignmentAnnotation();
330     fAlignmt.alignmentProperties = alignment.getProperties();
331     fAlignmt.groups = alignment.getGroups();
332     fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
333     fAlignmt.setSeqrep(alignment.getSeqrep());
334
335     return fAlignmt;
336   }
337
338   public boolean isHidden(SequenceI seq)
339   {
340     if (hiddenSequences != null)
341     {
342       for (int i = 0; i < hiddenSequences.length; i++)
343       {
344         if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
345         {
346           return true;
347         }
348       }
349     }
350
351     return false;
352   }
353 }