X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenSequences.java;h=e2ef31886d5542835935e42f1d09c21a4fab0b25;hb=HEAD;hp=e652182dff4076fae3f1ed21a8bfe5f7ce3d087f;hpb=a8f483d04205bb8273ee311c12968b7e86d205fa;p=jalview.git diff --git a/src/jalview/datamodel/HiddenSequences.java b/src/jalview/datamodel/HiddenSequences.java index e652182..e2ef318 100755 --- a/src/jalview/datamodel/HiddenSequences.java +++ b/src/jalview/datamodel/HiddenSequences.java @@ -1,24 +1,28 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.datamodel; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; public class HiddenSequences { @@ -29,11 +33,21 @@ public class HiddenSequences AlignmentI alignment; + /** + * Constructor given a reference to an alignment (with no hidden sequences) + * + * @param al + */ public HiddenSequences(AlignmentI al) { alignment = al; } + /** + * Answers the number of hidden sequences + * + * @return + */ public int getSize() { if (hiddenSequences == null) @@ -41,9 +55,9 @@ public class HiddenSequences return 0; } int count = 0; - for (int i = 0; i < hiddenSequences.length; i++) + for (SequenceI seq : hiddenSequences) { - if (hiddenSequences[i] != null) + if (seq != null) { count++; } @@ -52,15 +66,23 @@ public class HiddenSequences return count; } + /** + * Answers the length of the longest hidden sequence + * + * @return + */ public int getWidth() { + if (hiddenSequences == null) + { + return 0; + } int width = 0; - for (int i = 0; i < hiddenSequences.length; i++) + for (SequenceI seq : hiddenSequences) { - if (hiddenSequences[i] != null - && hiddenSequences[i].getLength() > width) + if (seq != null && seq.getLength() > width) { - width = hiddenSequences[i].getLength(); + width = seq.getLength(); } } @@ -68,7 +90,7 @@ public class HiddenSequences } /** - * Call this method if sequences are removed from the main alignment + * Call this method after a sequence is removed from the main alignment */ public void adjustHeightSequenceDeleted(int seqIndex) { @@ -104,8 +126,7 @@ public class HiddenSequences } /** - * Call this method if sequences are added to or removed from the main - * alignment + * Call this method after a sequence is added to the main alignment */ public void adjustHeightSequenceAdded() { @@ -121,6 +142,11 @@ public class HiddenSequences hiddenSequences = tmp; } + /** + * Mark the specified sequence as hidden + * + * @param sequence + */ public void hideSequence(SequenceI sequence) { if (hiddenSequences == null) @@ -128,47 +154,65 @@ public class HiddenSequences hiddenSequences = new SequenceI[alignment.getHeight()]; } - int alignmentIndex = alignment.findIndex(sequence); - alignmentIndex = adjustForHiddenSeqs(alignmentIndex); + int absAlignmentIndex = alignment.findIndex(sequence); + int alignmentIndex = adjustForHiddenSeqs(absAlignmentIndex); - if (hiddenSequences[alignmentIndex] != null) + if (alignmentIndex < 0 || hiddenSequences[alignmentIndex] != null) { - System.out.println("ERROR!!!!!!!!!!!"); + jalview.bin.Console.outPrintln("ERROR!!!!!!!!!!!"); + return; } hiddenSequences[alignmentIndex] = sequence; - alignment.deleteSequence(sequence); + alignment.deleteHiddenSequence(absAlignmentIndex); } - public Vector showAll( + public List showAll( Map hiddenRepSequences) { - Vector revealedSeqs = new Vector(); + List revealedSeqs = new ArrayList<>(); + + if (hiddenSequences == null) + { + return revealedSeqs; + } + for (int i = 0; i < hiddenSequences.length; i++) { if (hiddenSequences[i] != null) { - Vector tmp = showSequence(i, hiddenRepSequences); - for (int t = 0; t < tmp.size(); t++) + List tmp = showSequence(i, hiddenRepSequences); + for (SequenceI seq : tmp) { - revealedSeqs.addElement(tmp.elementAt(t)); + revealedSeqs.add(seq); } } } return revealedSeqs; } - public Vector showSequence(int alignmentIndex, + /** + * Reveals (unhides) consecutive hidden sequences just above the given + * alignment index. The revealed sequences are selected (including their + * visible representative sequence if there was one and 'reveal' is being + * performed on it). + * + * @param alignmentIndex + * @param hiddenRepSequences + * a map of representative sequences to the sequences they represent + * @return + */ + public List showSequence(int alignmentIndex, Map hiddenRepSequences) { - Vector revealedSeqs = new Vector(); + List revealedSeqs = new ArrayList<>(); SequenceI repSequence = alignment.getSequenceAt(alignmentIndex); if (repSequence != null && hiddenRepSequences != null && hiddenRepSequences.containsKey(repSequence)) { hiddenRepSequences.remove(repSequence); - revealedSeqs.addElement(repSequence); + revealedSeqs.add(repSequence); } int start = adjustForHiddenSeqs(alignmentIndex - 1); @@ -178,8 +222,8 @@ public class HiddenSequences end = hiddenSequences.length - 1; } - List asequences; - synchronized (asequences = alignment.getSequences()) + List asequences = alignment.getSequences(); + synchronized (asequences) { for (int index = end; index > start; index--) { @@ -190,33 +234,48 @@ public class HiddenSequences { if (seq.getLength() > 0) { - revealedSeqs.addElement(seq); + revealedSeqs.add(seq); asequences.add(alignmentIndex, seq); } else { - System.out.println(seq.getName() - + " has been deleted whilst hidden"); + jalview.bin.Console.outPrintln( + seq.getName() + " has been deleted whilst hidden"); } } - } } - return revealedSeqs; } public SequenceI getHiddenSequence(int alignmentIndex) { - return hiddenSequences[alignmentIndex]; + return hiddenSequences == null ? null : hiddenSequences[alignmentIndex]; } + /** + * Convert absolute alignment index to visible alignment index (or -1 if + * before the first visible sequence) + * + * @param alignmentIndex + * @return + */ public int findIndexWithoutHiddenSeqs(int alignmentIndex) { + if (hiddenSequences == null) + { + return alignmentIndex; + } int index = 0; int hiddenSeqs = 0; + int diff = 0; if (hiddenSequences.length <= alignmentIndex) { + // if the alignmentIndex runs past the end of hidden sequences + // and therefore actually past the end of the alignment + // store the difference to add back on at the end, so that behaviour + // is consistent with hidden columns behaviour (used by overview panel) + diff = alignmentIndex - hiddenSequences.length + 1; alignmentIndex = hiddenSequences.length - 1; } @@ -228,13 +287,57 @@ public class HiddenSequences } index++; } - ; - return (alignmentIndex - hiddenSeqs); + return (alignmentIndex - hiddenSeqs + diff); + } + + /** + * Find the visible row which is a given visible number of rows above another + * visible row. i.e. for a startRow x, the row which is distance 1 away will + * be row x-1. + * + * @param visibleDistance + * the number of visible rows to offset by + * @param startRow + * the row to start from + * @return the position of the row in the visible alignment + */ + public int subtractVisibleRows(int visibleDistance, int startRow) + { + // walk upwards through the alignment + // count all the non-null sequences until we have visibleDistance counted + // then return the next visible sequence + if (hiddenSequences == null) + { + return startRow - visibleDistance; + } + + int index = Math.min(startRow, hiddenSequences.length - 1); + int count = 0; + while ((index > -1) && (count < visibleDistance)) + { + if (hiddenSequences[index] == null) + { + // count visible sequences + count++; + } + index--; + } + return index; } + /** + * Convert alignment index from visible alignment to absolute alignment + * + * @param alignmentIndex + * @return + */ public int adjustForHiddenSeqs(int alignmentIndex) { + if (hiddenSequences == null) + { + return alignmentIndex; + } int index = 0; int hSize = hiddenSequences.length; while (index <= alignmentIndex && index < hSize) @@ -250,38 +353,78 @@ public class HiddenSequences return alignmentIndex; } + /** + * makes a copy of the alignment with hidden sequences included. Using the + * copy for anything other than simple output is not recommended. Note - this + * method DOES NOT USE THE AlignmentI COPY CONSTRUCTOR! + * + * @return + */ public AlignmentI getFullAlignment() { - int isize = hiddenSequences.length; - SequenceI[] seq = new Sequence[isize]; - - int index = 0; - for (int i = 0; i < hiddenSequences.length; i++) + SequenceI[] seq; + if (hiddenSequences == null) { - if (hiddenSequences[i] != null) - { - seq[i] = hiddenSequences[i]; - } - else + seq = alignment.getSequencesArray(); + } + else + { + int isize = hiddenSequences.length; + seq = new Sequence[isize]; + + int index = 0; + for (int i = 0; i < hiddenSequences.length; i++) { - seq[i] = alignment.getSequenceAt(index); - index++; + if (hiddenSequences[i] != null) + { + seq[i] = hiddenSequences[i]; + } + else + { + seq[i] = alignment.getSequenceAt(index); + index++; + } } } - - return new Alignment(seq); + Alignment fAlignmt = new Alignment(seq); + fAlignmt.annotations = alignment.getAlignmentAnnotation(); + fAlignmt.alignmentProperties = alignment.getProperties(); + fAlignmt.groups = alignment.getGroups(); + fAlignmt.hasRNAStructure = alignment.hasRNAStructure(); + fAlignmt.setSeqrep(alignment.getSeqrep()); + + return fAlignmt; } public boolean isHidden(SequenceI seq) { - for (int i = 0; i < hiddenSequences.length; i++) + if (hiddenSequences != null) { - if (hiddenSequences[i] != null && hiddenSequences[i] == seq) + for (int i = 0; i < hiddenSequences.length; i++) { - return true; + if (hiddenSequences[i] != null && hiddenSequences[i] == seq) + { + return true; + } } } return false; } + + /** + * Answers if a sequence is hidden + * + * @param seq + * (absolute) index to test + * @return true if sequence at index seq is hidden + */ + public boolean isHidden(int seq) + { + if (hiddenSequences != null) + { + return (hiddenSequences[seq] != null); + } + return false; + } }