Clover icon

Coverage Report

  1. Project Clover database Tue Mar 10 2026 14:58:44 GMT
  2. Package jalview.datamodel

File HiddenSequences.java

 

Coverage histogram

../../img/srcFileCovDistChart0.png
0% of files have more coverage

Code metrics

74
130
15
1
430
280
59
0.45
8.67
15
3.93

Classes

Class Line # Actions
HiddenSequences 27 130 59
0.00%
 

Contributing tests

No tests hitting this source file were found.

Source view

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  0 toggle public HiddenSequences(AlignmentI al)
42    {
43  0 alignment = al;
44    }
45   
46    /**
47    * Answers the number of hidden sequences
48    *
49    * @return
50    */
 
51  0 toggle public int getSize()
52    {
53  0 if (hiddenSequences == null)
54    {
55  0 return 0;
56    }
57  0 int count = 0;
58  0 for (SequenceI seq : hiddenSequences)
59    {
60  0 if (seq != null)
61    {
62  0 count++;
63    }
64    }
65   
66  0 return count;
67    }
68   
69    /**
70    * Answers the length of the longest hidden sequence
71    *
72    * @return
73    */
 
74  0 toggle public int getWidth()
75    {
76  0 if (hiddenSequences == null)
77    {
78  0 return 0;
79    }
80  0 int width = 0;
81  0 for (SequenceI seq : hiddenSequences)
82    {
83  0 if (seq != null && seq.getLength() > width)
84    {
85  0 width = seq.getLength();
86    }
87    }
88   
89  0 return width;
90    }
91   
92    /**
93    * Call this method after a sequence is removed from the main alignment
94    */
 
95  0 toggle public void adjustHeightSequenceDeleted(int seqIndex)
96    {
97  0 if (hiddenSequences == null)
98    {
99  0 return;
100    }
101   
102  0 int alHeight = alignment.getHeight();
103   
104  0 SequenceI[] tmp = new SequenceI[alHeight + getSize()];
105  0 int deletionIndex = adjustForHiddenSeqs(seqIndex);
106   
107  0 for (int i = 0; i < hiddenSequences.length; i++)
108    {
109  0 if (hiddenSequences[i] == null)
110    {
111  0 continue;
112    }
113   
114  0 if (i > deletionIndex)
115    {
116  0 tmp[i - 1] = hiddenSequences[i];
117    }
118    else
119    {
120  0 tmp[i] = hiddenSequences[i];
121    }
122    }
123   
124  0 hiddenSequences = tmp;
125   
126    }
127   
128    /**
129    * Call this method after a sequence is added to the main alignment
130    */
 
131  0 toggle public void adjustHeightSequenceAdded()
132    {
133  0 if (hiddenSequences == null)
134    {
135  0 return;
136    }
137   
138  0 int alHeight = alignment.getHeight();
139   
140  0 SequenceI[] tmp = new SequenceI[alHeight + getSize()];
141  0 System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
142  0 hiddenSequences = tmp;
143    }
144   
145    /**
146    * Mark the specified sequence as hidden
147    *
148    * @param sequence
149    */
 
150  0 toggle public void hideSequence(SequenceI sequence)
151    {
152  0 if (hiddenSequences == null)
153    {
154  0 hiddenSequences = new SequenceI[alignment.getHeight()];
155    }
156   
157  0 int absAlignmentIndex = alignment.findIndex(sequence);
158  0 int alignmentIndex = adjustForHiddenSeqs(absAlignmentIndex);
159   
160  0 if (alignmentIndex < 0 || hiddenSequences[alignmentIndex] != null)
161    {
162  0 jalview.bin.Console.outPrintln("ERROR!!!!!!!!!!!");
163  0 return;
164    }
165   
166  0 hiddenSequences[alignmentIndex] = sequence;
167   
168  0 alignment.deleteHiddenSequence(absAlignmentIndex);
169    }
170   
 
171  0 toggle public List<SequenceI> showAll(
172    Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
173    {
174  0 List<SequenceI> revealedSeqs = new ArrayList<>();
175   
176  0 if (hiddenSequences == null)
177    {
178  0 return revealedSeqs;
179    }
180   
181  0 for (int i = 0; i < hiddenSequences.length; i++)
182    {
183  0 if (hiddenSequences[i] != null)
184    {
185  0 List<SequenceI> tmp = showSequence(i, hiddenRepSequences);
186  0 for (SequenceI seq : tmp)
187    {
188  0 revealedSeqs.add(seq);
189    }
190    }
191    }
192  0 return revealedSeqs;
193    }
194   
195    /**
196    * Reveals (unhides) consecutive hidden sequences just above the given
197    * alignment index. The revealed sequences are selected (including their
198    * visible representative sequence if there was one and 'reveal' is being
199    * performed on it).
200    *
201    * @param alignmentIndex
202    * @param hiddenRepSequences
203    * a map of representative sequences to the sequences they represent
204    * @return
205    */
 
206  0 toggle public List<SequenceI> showSequence(int alignmentIndex,
207    Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
208    {
209  0 List<SequenceI> revealedSeqs = new ArrayList<>();
210  0 SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
211  0 if (repSequence != null && hiddenRepSequences != null
212    && hiddenRepSequences.containsKey(repSequence))
213    {
214  0 hiddenRepSequences.remove(repSequence);
215  0 revealedSeqs.add(repSequence);
216    }
217   
218  0 int start = adjustForHiddenSeqs(alignmentIndex - 1);
219  0 int end = adjustForHiddenSeqs(alignmentIndex);
220  0 if (end >= hiddenSequences.length)
221    {
222  0 end = hiddenSequences.length - 1;
223    }
224   
225  0 List<SequenceI> asequences = alignment.getSequences();
226  0 synchronized (asequences)
227    {
228  0 for (int index = end; index > start; index--)
229    {
230  0 SequenceI seq = hiddenSequences[index];
231  0 hiddenSequences[index] = null;
232   
233  0 if (seq != null)
234    {
235  0 if (seq.getLength() > 0)
236    {
237  0 revealedSeqs.add(seq);
238  0 asequences.add(alignmentIndex, seq);
239    }
240    else
241    {
242  0 jalview.bin.Console.outPrintln(
243    seq.getName() + " has been deleted whilst hidden");
244    }
245    }
246    }
247    }
248  0 return revealedSeqs;
249    }
250   
 
251  0 toggle public SequenceI getHiddenSequence(int alignmentIndex)
252    {
253  0 return hiddenSequences == null ? null : hiddenSequences[alignmentIndex];
254    }
255   
256    /**
257    * Convert absolute alignment index to visible alignment index (or -1 if
258    * before the first visible sequence)
259    *
260    * @param alignmentIndex
261    * @return
262    */
 
263  0 toggle public int findIndexWithoutHiddenSeqs(int alignmentIndex)
264    {
265  0 if (hiddenSequences == null)
266    {
267  0 return alignmentIndex;
268    }
269  0 int index = 0;
270  0 int hiddenSeqs = 0;
271  0 int diff = 0;
272  0 if (hiddenSequences.length <= alignmentIndex)
273    {
274    // if the alignmentIndex runs past the end of hidden sequences
275    // and therefore actually past the end of the alignment
276    // store the difference to add back on at the end, so that behaviour
277    // is consistent with hidden columns behaviour (used by overview panel)
278  0 diff = alignmentIndex - hiddenSequences.length + 1;
279  0 alignmentIndex = hiddenSequences.length - 1;
280    }
281   
282  0 while (index <= alignmentIndex)
283    {
284  0 if (hiddenSequences[index] != null)
285    {
286  0 hiddenSeqs++;
287    }
288  0 index++;
289    }
290   
291  0 return (alignmentIndex - hiddenSeqs + diff);
292    }
293   
294    /**
295    * Find the visible row which is a given visible number of rows above another
296    * visible row. i.e. for a startRow x, the row which is distance 1 away will
297    * be row x-1.
298    *
299    * @param visibleDistance
300    * the number of visible rows to offset by
301    * @param startRow
302    * the row to start from
303    * @return the position of the row in the visible alignment
304    */
 
305  0 toggle public int subtractVisibleRows(int visibleDistance, int startRow)
306    {
307    // walk upwards through the alignment
308    // count all the non-null sequences until we have visibleDistance counted
309    // then return the next visible sequence
310  0 if (hiddenSequences == null)
311    {
312  0 return startRow - visibleDistance;
313    }
314   
315  0 int index = Math.min(startRow, hiddenSequences.length - 1);
316  0 int count = 0;
317  0 while ((index > -1) && (count < visibleDistance))
318    {
319  0 if (hiddenSequences[index] == null)
320    {
321    // count visible sequences
322  0 count++;
323    }
324  0 index--;
325    }
326  0 return index;
327    }
328   
329    /**
330    * Convert alignment index from visible alignment to absolute alignment
331    *
332    * @param alignmentIndex
333    * @return
334    */
 
335  0 toggle public int adjustForHiddenSeqs(int alignmentIndex)
336    {
337  0 if (hiddenSequences == null)
338    {
339  0 return alignmentIndex;
340    }
341  0 int index = 0;
342  0 int hSize = hiddenSequences.length;
343  0 while (index <= alignmentIndex && index < hSize)
344    {
345  0 if (hiddenSequences[index] != null)
346    {
347  0 alignmentIndex++;
348    }
349  0 index++;
350    }
351  0 ;
352   
353  0 return alignmentIndex;
354    }
355   
356    /**
357    * makes a copy of the alignment with hidden sequences included. Using the
358    * copy for anything other than simple output is not recommended. Note - this
359    * method DOES NOT USE THE AlignmentI COPY CONSTRUCTOR!
360    *
361    * @return
362    */
 
363  0 toggle public AlignmentI getFullAlignment()
364    {
365  0 SequenceI[] seq;
366  0 if (hiddenSequences == null)
367    {
368  0 seq = alignment.getSequencesArray();
369    }
370    else
371    {
372  0 int isize = hiddenSequences.length;
373  0 seq = new Sequence[isize];
374   
375  0 int index = 0;
376  0 for (int i = 0; i < hiddenSequences.length; i++)
377    {
378  0 if (hiddenSequences[i] != null)
379    {
380  0 seq[i] = hiddenSequences[i];
381    }
382    else
383    {
384  0 seq[i] = alignment.getSequenceAt(index);
385  0 index++;
386    }
387    }
388    }
389  0 Alignment fAlignmt = new Alignment(seq);
390  0 fAlignmt.annotations = alignment.getAlignmentAnnotation();
391  0 fAlignmt.alignmentProperties = alignment.getProperties();
392  0 fAlignmt.groups = alignment.getGroups();
393  0 fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
394  0 fAlignmt.setSeqrep(alignment.getSeqrep());
395   
396  0 return fAlignmt;
397    }
398   
 
399  0 toggle public boolean isHidden(SequenceI seq)
400    {
401  0 if (hiddenSequences != null)
402    {
403  0 for (int i = 0; i < hiddenSequences.length; i++)
404    {
405  0 if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
406    {
407  0 return true;
408    }
409    }
410    }
411   
412  0 return false;
413    }
414   
415    /**
416    * Answers if a sequence is hidden
417    *
418    * @param seq
419    * (absolute) index to test
420    * @return true if sequence at index seq is hidden
421    */
 
422  0 toggle public boolean isHidden(int seq)
423    {
424  0 if (hiddenSequences != null)
425    {
426  0 return (hiddenSequences[seq] != null);
427    }
428  0 return false;
429    }
430    }
  • Report generated by OpenClover v 4.4.1 on Tue Mar 10 2026 14:59:17 GMT using coverage data from Thu Jan 1 1970 01:00:00 GMT.
  • OpenClover is free and open-source software.