2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.datamodel;
23 import java.util.ArrayList;
24 import java.util.List;
27 public class HiddenSequences
30 * holds a list of hidden sequences associated with an alignment.
32 public SequenceI[] hiddenSequences;
37 * Constructor given a reference to an alignment (with no hidden sequences)
41 public HiddenSequences(AlignmentI al)
47 * Answers the number of hidden sequences
53 if (hiddenSequences == null)
58 for (SequenceI seq : hiddenSequences)
70 * Answers the length of the longest hidden sequence
76 if (hiddenSequences == null)
81 for (SequenceI seq : hiddenSequences)
83 if (seq != null && seq.getLength() > width)
85 width = seq.getLength();
93 * Call this method after a sequence is removed from the main alignment
95 public void adjustHeightSequenceDeleted(int seqIndex)
97 if (hiddenSequences == null)
102 int alHeight = alignment.getHeight();
104 SequenceI[] tmp = new SequenceI[alHeight + getSize()];
105 int deletionIndex = adjustForHiddenSeqs(seqIndex);
107 for (int i = 0; i < hiddenSequences.length; i++)
109 if (hiddenSequences[i] == null)
114 if (i > deletionIndex)
116 tmp[i - 1] = hiddenSequences[i];
120 tmp[i] = hiddenSequences[i];
124 hiddenSequences = tmp;
129 * Call this method after a sequence is added to the main alignment
131 public void adjustHeightSequenceAdded()
133 if (hiddenSequences == null)
138 int alHeight = alignment.getHeight();
140 SequenceI[] tmp = new SequenceI[alHeight + getSize()];
141 System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
142 hiddenSequences = tmp;
146 * Mark the specified sequence as hidden
150 public void hideSequence(SequenceI sequence)
152 if (hiddenSequences == null)
154 hiddenSequences = new SequenceI[alignment.getHeight()];
157 int absAlignmentIndex = alignment.findIndex(sequence);
158 int alignmentIndex = adjustForHiddenSeqs(absAlignmentIndex);
160 if (hiddenSequences[alignmentIndex] != null)
162 System.out.println("ERROR!!!!!!!!!!!");
165 hiddenSequences[alignmentIndex] = sequence;
167 alignment.deleteHiddenSequence(absAlignmentIndex);
170 public List<SequenceI> showAll(
171 Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
173 List<SequenceI> revealedSeqs = new ArrayList<>();
175 if (hiddenSequences == null)
180 for (int i = 0; i < hiddenSequences.length; i++)
182 if (hiddenSequences[i] != null)
184 List<SequenceI> tmp = showSequence(i, hiddenRepSequences);
185 for (SequenceI seq : tmp)
187 revealedSeqs.add(seq);
195 * Reveals (unhides) consecutive hidden sequences just above the given
196 * alignment index. The revealed sequences are selected (including their
197 * visible representative sequence if there was one and 'reveal' is being
200 * @param alignmentIndex
201 * @param hiddenRepSequences
202 * a map of representative sequences to the sequences they represent
205 public List<SequenceI> showSequence(int alignmentIndex,
206 Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
208 List<SequenceI> revealedSeqs = new ArrayList<>();
209 SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
210 if (repSequence != null && hiddenRepSequences != null
211 && hiddenRepSequences.containsKey(repSequence))
213 hiddenRepSequences.remove(repSequence);
214 revealedSeqs.add(repSequence);
217 int start = adjustForHiddenSeqs(alignmentIndex - 1);
218 int end = adjustForHiddenSeqs(alignmentIndex);
219 if (end >= hiddenSequences.length)
221 end = hiddenSequences.length - 1;
224 List<SequenceI> asequences;
225 synchronized (asequences = alignment.getSequences())
227 for (int index = end; index > start; index--)
229 SequenceI seq = hiddenSequences[index];
230 hiddenSequences[index] = null;
234 if (seq.getLength() > 0)
236 revealedSeqs.add(seq);
237 asequences.add(alignmentIndex, seq);
241 System.out.println(seq.getName()
242 + " has been deleted whilst hidden");
250 public SequenceI getHiddenSequence(int alignmentIndex)
252 return hiddenSequences == null ? null : hiddenSequences[alignmentIndex];
256 * Convert absolute alignment index to visible alignment index (or -1 if
257 * before the first visible sequence)
259 * @param alignmentIndex
262 public int findIndexWithoutHiddenSeqs(int alignmentIndex)
264 if (hiddenSequences == null)
266 return alignmentIndex;
271 if (hiddenSequences.length <= alignmentIndex)
273 // if the alignmentIndex runs past the end of hidden sequences
274 // and therefore actually past the end of the alignment
275 // store the difference to add back on at the end, so that behaviour
276 // is consistent with hidden columns behaviour (used by overview panel)
277 diff = alignmentIndex - hiddenSequences.length + 1;
278 alignmentIndex = hiddenSequences.length - 1;
281 while (index <= alignmentIndex)
283 if (hiddenSequences[index] != null)
290 return (alignmentIndex - hiddenSeqs + diff);
294 * Find the visible row which is a given visible number of rows above another
295 * visible row. i.e. for a startRow x, the row which is distance 1 away will
298 * @param visibleDistance
299 * the number of visible rows to offset by
301 * the row to start from
302 * @return the position of the row in the visible alignment
304 public int subtractVisibleRows(int visibleDistance, int startRow)
306 // walk upwards through the alignment
307 // count all the non-null sequences until we have visibleDistance counted
308 // then return the next visible sequence
309 if (hiddenSequences == null)
311 return startRow - visibleDistance;
314 int index = startRow;
316 while ((index > -1) && (count < visibleDistance))
318 if (hiddenSequences[index] == null)
320 // count visible sequences
329 * Convert alignment index from visible alignment to absolute alignment
331 * @param alignmentIndex
334 public int adjustForHiddenSeqs(int alignmentIndex)
336 if (hiddenSequences == null)
338 return alignmentIndex;
341 int hSize = hiddenSequences.length;
342 while (index <= alignmentIndex && index < hSize)
344 if (hiddenSequences[index] != null)
352 return alignmentIndex;
356 * makes a copy of the alignment with hidden sequences included. Using the
357 * copy for anything other than simple output is not recommended. Note - this
358 * method DOES NOT USE THE AlignmentI COPY CONSTRUCTOR!
362 public AlignmentI getFullAlignment()
365 if (hiddenSequences == null)
367 seq = alignment.getSequencesArray();
371 int isize = hiddenSequences.length;
372 seq = new Sequence[isize];
375 for (int i = 0; i < hiddenSequences.length; i++)
377 if (hiddenSequences[i] != null)
379 seq[i] = hiddenSequences[i];
383 seq[i] = alignment.getSequenceAt(index);
388 Alignment fAlignmt = new Alignment(seq);
389 fAlignmt.annotations = alignment.getAlignmentAnnotation();
390 fAlignmt.alignmentProperties = alignment.getProperties();
391 fAlignmt.groups = alignment.getGroups();
392 fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
393 fAlignmt.setSeqrep(alignment.getSeqrep());
398 public boolean isHidden(SequenceI seq)
400 if (hiddenSequences != null)
402 for (int i = 0; i < hiddenSequences.length; i++)
404 if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
415 * Answers if a sequence is hidden
418 * (absolute) index to test
419 * @return true if sequence at index seq is hidden
421 public boolean isHidden(int seq)
423 if (hiddenSequences != null)
425 return (hiddenSequences[seq] != null);