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
258 * @param alignmentIndex
261 public int findIndexWithoutHiddenSeqs(int alignmentIndex)
263 if (hiddenSequences == null)
265 return alignmentIndex;
270 if (hiddenSequences.length <= alignmentIndex)
272 // if the alignmentIndex runs past the end of hidden sequences
273 // and therefore actually past the end of the alignment
274 // store the difference to add back on at the end, so that behaviour
275 // is consistent with hidden columns behaviour (used by overview panel)
276 diff = alignmentIndex - hiddenSequences.length + 1;
277 alignmentIndex = hiddenSequences.length - 1;
280 while (index <= alignmentIndex)
282 if (hiddenSequences[index] != null)
289 return (alignmentIndex - hiddenSeqs + diff);
293 * Find the visible row which is a given visible number of rows above another
294 * visible row. i.e. for a startRow x, the row which is distance 1 away will
297 * @param visibleDistance
298 * the number of visible rows to offset by
300 * the row to start from
301 * @return the position of the row in the visible alignment
303 public int subtractVisibleRows(int visibleDistance, int startRow)
305 // walk upwards through the alignment
306 // count all the non-null sequences until we have visibleDistance counted
307 // then return the next visible sequence
308 if (hiddenSequences == null)
310 return startRow - visibleDistance;
313 int index = startRow;
315 while ((index > -1) && (count < visibleDistance))
317 if (hiddenSequences[index] == null)
319 // count visible sequences
328 * Convert alignment index from visible alignment to absolute alignment
330 * @param alignmentIndex
333 public int adjustForHiddenSeqs(int alignmentIndex)
335 if (hiddenSequences == null)
337 return alignmentIndex;
340 int hSize = hiddenSequences.length;
341 while (index <= alignmentIndex && index < hSize)
343 if (hiddenSequences[index] != null)
351 return alignmentIndex;
355 * makes a copy of the alignment with hidden sequences included. Using the
356 * copy for anything other than simple output is not recommended. Note - this
357 * method DOES NOT USE THE AlignmentI COPY CONSTRUCTOR!
361 public AlignmentI getFullAlignment()
364 if (hiddenSequences == null)
366 seq = alignment.getSequencesArray();
370 int isize = hiddenSequences.length;
371 seq = new Sequence[isize];
374 for (int i = 0; i < hiddenSequences.length; i++)
376 if (hiddenSequences[i] != null)
378 seq[i] = hiddenSequences[i];
382 seq[i] = alignment.getSequenceAt(index);
387 Alignment fAlignmt = new Alignment(seq);
388 fAlignmt.annotations = alignment.getAlignmentAnnotation();
389 fAlignmt.alignmentProperties = alignment.getProperties();
390 fAlignmt.groups = alignment.getGroups();
391 fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
392 fAlignmt.setSeqrep(alignment.getSeqrep());
397 public boolean isHidden(SequenceI seq)
399 if (hiddenSequences != null)
401 for (int i = 0; i < hiddenSequences.length; i++)
403 if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
414 * Answers if a sequence is hidden
417 * (absolute) index to test
418 * @return true if sequence at index seq is hidden
420 public boolean isHidden(int seq)
422 if (hiddenSequences != null)
424 return (hiddenSequences[seq] != null);