X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=89fb1ab21b2246e1dd61aaf3fec356e731ef2672;hb=HEAD;hp=e047ef4fef321259ef21ec99bfb068ccfa756552;hpb=fcd1956579a9ecf87f659096bcf6e17975c10193;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index e047ef4..89fb1ab 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -21,6 +21,7 @@ package jalview.datamodel; import java.util.ArrayList; +import java.util.Arrays; import java.util.BitSet; import java.util.Iterator; import java.util.List; @@ -32,20 +33,34 @@ import java.util.concurrent.locks.ReentrantReadWriteLock; * use an iterator obtained from one of: * * - getBoundedIterator: iterates over the hidden regions, within some bounds, - * returning absolute positions + * returning *absolute* positions * * - getBoundedStartIterator: iterates over the start positions of hidden - * regions, within some bounds, returning visible positions + * regions, within some bounds, returning *visible* positions * * - getVisContigsIterator: iterates over visible regions in a range, returning - * absolute positions + * *absolute* positions * * - getVisibleColsIterator: iterates over the visible *columns* * - * For performance reasons, provide bounds where possible. + * For performance reasons, provide bounds where possible. Note that column + * numbering begins at 0 throughout this class. * * @author kmourao - * + */ + +/* Implementation notes: + * + * Methods which change the hiddenColumns collection should use a writeLock to + * prevent other threads accessing the hiddenColumns collection while changes + * are being made. They should also reset the hidden columns cursor, and either + * update the hidden columns count, or set it to 0 (so that it will later be + * updated when needed). + * + * + * Methods which only need read access to the hidden columns collection should + * use a readLock to prevent other threads changing the hidden columns + * collection while it is in use. */ public class HiddenColumns { @@ -60,7 +75,8 @@ public class HiddenColumns private HiddenColumnsCursor cursor = new HiddenColumnsCursor(); /* - * cache of the number of hidden columns + * cache of the number of hidden columns: must be kept up to date by methods + * which add or remove hidden columns */ private int numColumns = 0; @@ -68,7 +84,7 @@ public class HiddenColumns * list of hidden column [start, end] ranges; the list is maintained in * ascending start column order */ - private ArrayList hiddenColumns; + private List hiddenColumns = new ArrayList<>(); /** * Constructor @@ -77,14 +93,6 @@ public class HiddenColumns { } - /* - * Methods which change the hiddenColumns collection. These methods should - * use a writeLock to prevent other threads accessing the hiddenColumns - * collection while changes are being made. They should also reset the hidden - * columns cursor, and either update the hidden columns count, or set it to 0 - * (so that it will later be updated when needed). - */ - /** * Copy constructor * @@ -93,29 +101,7 @@ public class HiddenColumns */ public HiddenColumns(HiddenColumns copy) { - try - { - LOCK.writeLock().lock(); - numColumns = 0; - if (copy != null) - { - if (copy.hiddenColumns != null) - { - hiddenColumns = new ArrayList<>(); - Iterator it = copy.iterator(); - while (it.hasNext()) - { - int[] region = it.next(); - hiddenColumns.add(region); - numColumns += region[1] - region[0] + 1; - } - cursor.resetCursor(hiddenColumns); - } - } - } finally - { - LOCK.writeLock().unlock(); - } + this(copy, Integer.MIN_VALUE, Integer.MAX_VALUE, 0); } /** @@ -140,7 +126,6 @@ public class HiddenColumns LOCK.writeLock().lock(); if (copy != null) { - hiddenColumns = new ArrayList<>(); numColumns = 0; Iterator it = copy.getBoundedIterator(start, end); while (it.hasNext()) @@ -150,13 +135,13 @@ public class HiddenColumns // all overlapping regions and we need contained regions if (region[0] >= start && region[1] <= end) { - hiddenColumns.add( - new int[] - { region[0] - offset, region[1] - offset }); + hiddenColumns + .add(new int[] + { region[0] - offset, region[1] - offset }); numColumns += region[1] - region[0] + 1; } } - cursor.resetCursor(hiddenColumns); + cursor = new HiddenColumnsCursor(hiddenColumns); } } finally { @@ -174,31 +159,18 @@ public class HiddenColumns */ public void hideColumns(int start, int end) { - boolean wasAlreadyLocked = false; try { - // check if the write lock was already locked by this thread, - // as this method can be called internally in loops within HiddenColumns - if (!LOCK.isWriteLockedByCurrentThread()) - { - LOCK.writeLock().lock(); - } - else - { - wasAlreadyLocked = true; - } + LOCK.writeLock().lock(); int previndex = 0; int prevHiddenCount = 0; int regionindex = 0; - if (hiddenColumns == null) - { - hiddenColumns = new ArrayList<>(); - } - else + if (!hiddenColumns.isEmpty()) { // set up cursor reset values - HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start); + HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start, + false); regionindex = cursorPos.getRegionIndex(); if (regionindex > 0) @@ -211,13 +183,13 @@ public class HiddenColumns } } - /* - * new range follows everything else; check first to avoid looping over whole hiddenColumns collection - */ + // new range follows everything else; check first to avoid looping over + // whole hiddenColumns collection if (hiddenColumns.isEmpty() || start > hiddenColumns.get(hiddenColumns.size() - 1)[1]) { hiddenColumns.add(new int[] { start, end }); + numColumns += end - start + 1; } else { @@ -238,17 +210,11 @@ public class HiddenColumns // reset the cursor to just before our insertion point: this saves // a lot of reprocessing in large alignments - cursor.resetCursor(hiddenColumns, previndex, prevHiddenCount); - - // reset the number of columns so they will be recounted - numColumns = 0; - + cursor = new HiddenColumnsCursor(hiddenColumns, previndex, + prevHiddenCount); } finally { - if (!wasAlreadyLocked) - { - LOCK.writeLock().unlock(); - } + LOCK.writeLock().unlock(); } } @@ -275,6 +241,7 @@ public class HiddenColumns * insert discontiguous preceding range */ hiddenColumns.add(i, new int[] { start, end }); + numColumns += end - start + 1; added = true; } else if (end <= region[1]) @@ -283,7 +250,10 @@ public class HiddenColumns * new range overlaps existing, or is contiguous preceding it - adjust * start column */ + int oldstart = region[0]; region[0] = Math.min(region[0], start); + numColumns += oldstart - region[0]; // new columns are between old and + // adjusted starts added = true; } else if (start <= region[1] + 1) @@ -292,52 +262,73 @@ public class HiddenColumns * new range overlaps existing, or is contiguous following it - adjust * start and end columns */ - region[0] = Math.min(region[0], start); - region[1] = Math.max(region[1], end); + insertRangeAtOverlap(i, start, end, region); + added = true; + } + return added; + } - /* - * also update or remove any subsequent ranges - * that are overlapped - */ - while (i < hiddenColumns.size() - 1) + /** + * Insert a range whose start position overlaps an existing region and/or is + * contiguous to the right of the region + * + * @param i + * index to insert at + * @param start + * start of range to insert + * @param end + * end of range to insert + * @param region + * the overlapped/continued region + */ + private void insertRangeAtOverlap(int i, int start, int end, int[] region) + { + int oldstart = region[0]; + int oldend = region[1]; + region[0] = Math.min(region[0], start); + region[1] = Math.max(region[1], end); + + numColumns += oldstart - region[0]; + + /* + * also update or remove any subsequent ranges + * that are overlapped + */ + int endi = i; + while (endi < hiddenColumns.size() - 1) + { + int[] nextRegion = hiddenColumns.get(endi + 1); + if (nextRegion[0] > end + 1) { - int[] nextRegion = hiddenColumns.get(i + 1); - if (nextRegion[0] > end + 1) - { - /* - * gap to next hidden range - no more to update - */ - break; - } - region[1] = Math.max(nextRegion[1], end); - - // in theory this is faster than hiddenColumns.remove(i+1) - // benchmarking results a bit ambivalent - hiddenColumns.subList(i + 1, i + 2).clear(); + /* + * gap to next hidden range - no more to update + */ + break; } - added = true; + numColumns -= nextRegion[1] - nextRegion[0] + 1; + region[1] = Math.max(nextRegion[1], end); + endi++; } - return added; + numColumns += region[1] - oldend; + hiddenColumns.subList(i + 1, endi + 1).clear(); } /** - * mark the columns corresponding to gap characters as hidden in the column - * selection + * hide a list of ranges * - * @param sr + * @param ranges */ - public void hideInsertionsFor(SequenceI sr) + public void hideList(List ranges) { try { LOCK.writeLock().lock(); - List inserts = sr.getInsertions(); - for (int[] r : inserts) + for (int[] r : ranges) { hideColumns(r[0], r[1]); } - cursor.resetCursor(hiddenColumns); - numColumns = 0; + cursor = new HiddenColumnsCursor(hiddenColumns); + } finally { LOCK.writeLock().unlock(); @@ -352,21 +343,18 @@ public class HiddenColumns try { LOCK.writeLock().lock(); - if (hiddenColumns != null) + + for (int[] region : hiddenColumns) { - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) + for (int j = region[0]; j < region[1] + 1; j++) { - int[] region = it.next(); - for (int j = region[0]; j < region[1] + 1; j++) - { - sel.addElement(j); - } + sel.addElement(j); } - hiddenColumns = null; - cursor.resetCursor(hiddenColumns); - numColumns = 0; } + hiddenColumns.clear(); + cursor = new HiddenColumnsCursor(hiddenColumns); + numColumns = 0; + } finally { LOCK.writeLock().unlock(); @@ -388,9 +376,9 @@ public class HiddenColumns { LOCK.writeLock().lock(); - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { - int regionIndex = cursor.findRegionForColumn(start) + int regionIndex = cursor.findRegionForColumn(start, false) .getRegionIndex(); if (regionIndex != -1 && regionIndex != hiddenColumns.size()) @@ -406,17 +394,7 @@ public class HiddenColumns } int colsToRemove = region[1] - region[0] + 1; hiddenColumns.remove(regionIndex); - - if (hiddenColumns.isEmpty()) - { - hiddenColumns = null; - numColumns = 0; - } - else - { - numColumns -= colsToRemove; - } - cursor.updateForDeletedRegion(hiddenColumns); + numColumns -= colsToRemove; } } } @@ -427,172 +405,6 @@ public class HiddenColumns } /** - * Add gaps into the sequences aligned to profileseq under the given - * AlignmentView - * - * @param profileseq - * sequence in al which sequences are aligned to - * @param al - * alignment to have gaps inserted into it - * @param input - * alignment view where sequence corresponding to profileseq is first - * entry - * @return new HiddenColumns for new alignment view, with insertions into - * profileseq marked as hidden. - */ - public static HiddenColumns propagateInsertions(SequenceI profileseq, - AlignmentI al, AlignmentView input) - { - int profsqpos = 0; - - char gc = al.getGapCharacter(); - Object[] alandhidden = input.getAlignmentAndHiddenColumns(gc); - HiddenColumns nview = (HiddenColumns) alandhidden[1]; - SequenceI origseq = ((SequenceI[]) alandhidden[0])[profsqpos]; - nview.propagateInsertions(profileseq, al, origseq); - return nview; - } - - /** - * - * @param profileseq - * sequence in al which corresponds to origseq - * @param al - * alignment which is to have gaps inserted into it - * @param origseq - * sequence corresponding to profileseq which defines gap map for - * modifying al - */ - private void propagateInsertions(SequenceI profileseq, AlignmentI al, - SequenceI origseq) - { - try - { - LOCK.writeLock().lock(); - - char gc = al.getGapCharacter(); - - // take the set of hidden columns, and the set of gaps in origseq, - // and remove all the hidden gaps from hiddenColumns - - // first get the gaps as a Bitset - BitSet gaps = origseq.gapBitset(); - - // now calculate hidden ^ not(gap) - BitSet hidden = new BitSet(); - markHiddenRegions(hidden); - hidden.andNot(gaps); - hiddenColumns = null; - this.hideMarkedBits(hidden); - - // for each sequence in the alignment, except the profile sequence, - // insert gaps corresponding to each hidden region but where each hidden - // column region is shifted backwards by the number of preceding visible - // gaps update hidden columns at the same time - Iterator regions = hiddenColumns.iterator(); - ArrayList newhidden = new ArrayList<>(); - - int numGapsBefore = 0; - int gapPosition = 0; - while (regions.hasNext()) - { - // get region coordinates accounting for gaps - // we can rely on gaps not being *in* hidden regions because we already - // removed those - int[] region = regions.next(); - while (gapPosition < region[0]) - { - gapPosition++; - if (gaps.get(gapPosition)) - { - numGapsBefore++; - } - } - - int left = region[0] - numGapsBefore; - int right = region[1] - numGapsBefore; - newhidden.add(new int[] { left, right }); - - // make a string with number of gaps = length of hidden region - StringBuffer sb = new StringBuffer(); - for (int s = 0; s < right - left + 1; s++) - { - sb.append(gc); - } - padGaps(sb, left, profileseq, al); - - } - hiddenColumns = newhidden; - cursor.resetCursor(hiddenColumns); - numColumns = 0; - } finally - { - LOCK.writeLock().unlock(); - } - } - - /** - * Pad gaps in all sequences in alignment except profileseq - * - * @param sb - * gap string to insert - * @param left - * position to insert at - * @param profileseq - * sequence not to pad - * @param al - * alignment to pad sequences in - */ - private void padGaps(StringBuffer sb, int pos, SequenceI profileseq, - AlignmentI al) - { - // loop over the sequences and pad with gaps where required - for (int s = 0, ns = al.getHeight(); s < ns; s++) - { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj != profileseq) - { - String sq = al.getSequenceAt(s).getSequenceAsString(); - if (sq.length() <= pos) - { - // pad sequence - int diff = pos - sq.length() - 1; - if (diff > 0) - { - // pad gaps - sq = sq + sb; - while ((diff = pos - sq.length() - 1) > 0) - { - if (diff >= sb.length()) - { - sq += sb.toString(); - } - else - { - char[] buf = new char[diff]; - sb.getChars(0, diff, buf, 0); - sq += buf.toString(); - } - } - } - sq += sb.toString(); - } - else - { - al.getSequenceAt(s).setSequence( - sq.substring(0, pos) + sb.toString() + sq.substring(pos)); - } - } - } - } - - /* - * Methods which only need read access to the hidden columns collection. - * These methods should use a readLock to prevent other threads changing - * the hidden columns collection while it is in use. - */ - - /** * Output regions data as a string. String is in the format: * reg0[0]reg0[1]reg1[0]reg1[1] ... regn[1] * @@ -608,20 +420,22 @@ public class HiddenColumns { LOCK.readLock().lock(); StringBuilder regionBuilder = new StringBuilder(); - if (hiddenColumns != null) + + boolean first = true; + for (int[] range : hiddenColumns) { - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) + if (!first) { - int[] range = it.next(); - regionBuilder.append(delimiter).append(range[0]).append(between) - .append(range[1]); - if (!it.hasNext()) - { - regionBuilder.deleteCharAt(0); - } + regionBuilder.append(delimiter); + } + else + { + first = false; } + regionBuilder.append(range[0]).append(between).append(range[1]); + } + return regionBuilder.toString(); } finally { @@ -636,30 +450,7 @@ public class HiddenColumns */ public int getSize() { - try - { - LOCK.readLock().lock(); - - if (numColumns == 0 && hiddenColumns != null) - { - // numColumns is out of date, so recalculate - int size = 0; - - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) - { - int[] range = it.next(); - size += range[1] - range[0] + 1; - } - - numColumns = size; - } - - return numColumns; - } finally - { - LOCK.readLock().unlock(); - } + return numColumns; } /** @@ -672,18 +463,17 @@ public class HiddenColumns try { LOCK.readLock().lock(); - int num = 0; - if (hasHiddenColumns()) - { - num = hiddenColumns.size(); - } - return num; + return hiddenColumns.size(); } finally { LOCK.readLock().unlock(); } } + /** + * Answers true if obj is an instance of HiddenColumns, and holds the same + * array of start-end column ranges as this, else answers false + */ @Override public boolean equals(Object obj) { @@ -700,28 +490,23 @@ public class HiddenColumns /* * check hidden columns are either both null, or match */ - if (this.hiddenColumns == null) - { - return (that.hiddenColumns == null); - } - if (that.hiddenColumns == null - || that.hiddenColumns.size() != this.hiddenColumns.size()) + + if (that.hiddenColumns.size() != this.hiddenColumns.size()) { return false; } - Iterator it = hiddenColumns.iterator(); + Iterator it = this.iterator(); Iterator thatit = that.iterator(); while (it.hasNext()) { - int[] thisRange = it.next(); - int[] thatRange = thatit.next(); - if (thisRange[0] != thatRange[0] || thisRange[1] != thatRange[1]) + if (!(Arrays.equals(it.next(), thatit.next()))) { return false; } } return true; + } finally { LOCK.readLock().unlock(); @@ -735,16 +520,16 @@ public class HiddenColumns * int column index in alignment view (count from zero) * @return alignment column index for column */ - public int adjustForHiddenColumns(int column) + public int visibleToAbsoluteColumn(int column) { try { LOCK.readLock().lock(); int result = column; - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { - result += cursor.findRegionForVisColumn(column).getHiddenSoFar(); + result += cursor.findRegionForColumn(column, true).getHiddenSoFar(); } return result; @@ -757,30 +542,31 @@ public class HiddenColumns /** * Use this method to find out where a column will appear in the visible * alignment when hidden columns exist. If the column is not visible, then the - * left-most visible column will always be returned. + * index of the next visible column on the left will be returned (or 0 if + * there is no visible column on the left) * * @param hiddenColumn * the column index in the full alignment including hidden columns * @return the position of the column in the visible alignment */ - public int findColumnPosition(int hiddenColumn) + public int absoluteToVisibleColumn(int hiddenColumn) { try { LOCK.readLock().lock(); int result = hiddenColumn; - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { HiddenCursorPosition cursorPos = cursor - .findRegionForColumn(hiddenColumn); + .findRegionForColumn(hiddenColumn, false); int index = cursorPos.getRegionIndex(); int hiddenBeforeCol = cursorPos.getHiddenSoFar(); - + // just subtract hidden cols count - this works fine if column is // visible result = hiddenColumn - hiddenBeforeCol; - + // now check in case column is hidden - it will be in the returned // hidden region if (index < hiddenColumns.size()) @@ -812,48 +598,25 @@ public class HiddenColumns /** * Find the visible column which is a given visible number of columns to the - * left of another visible column. i.e. for a startColumn x, the column which - * is distance 1 away will be column x-1. + * left (negative visibleDistance) or right (positive visibleDistance) of + * startColumn. If startColumn is not visible, we use the visible column at + * the left boundary of the hidden region containing startColumn. * * @param visibleDistance - * the number of visible columns to offset by + * the number of visible columns to offset by (left offset = negative + * value; right offset = positive value) * @param startColumn - * the column to start from - * @return the position of the column in the visible alignment + * the position of the column to start from (absolute position) + * @return the position of the column which is away + * (absolute position) */ - public int subtractVisibleColumns(int visibleDistance, int startColumn) + public int offsetByVisibleColumns(int visibleDistance, int startColumn) { try { LOCK.readLock().lock(); - int distance = visibleDistance; - - // in case startColumn is in a hidden region, move it to the left - int start = adjustForHiddenColumns(findColumnPosition(startColumn)); - - Iterator it = new ReverseRegionsIterator(0, start, - hiddenColumns); - - while (it.hasNext() && (distance > 0)) - { - int[] region = it.next(); - - if (start > region[1]) - { - // subtract the gap to right of region from distance - if (start - region[1] <= distance) - { - distance -= start - region[1]; - start = region[0] - 1; - } - else - { - start = start - distance; - distance = 0; - } - } - } - return start - distance; + int start = absoluteToVisibleColumn(startColumn); + return visibleToAbsoluteColumn(start + visibleDistance); } finally { @@ -871,15 +634,22 @@ public class HiddenColumns * @return the index of the next hidden column, or alPos if there is no next * hidden column */ - public int getHiddenBoundaryRight(int alPos) + public int getNextHiddenBoundary(boolean left, int alPos) { try { LOCK.readLock().lock(); - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { - int index = cursor.findRegionForColumn(alPos).getRegionIndex(); - if (index < hiddenColumns.size()) + int index = cursor.findRegionForColumn(alPos, false) + .getRegionIndex(); + + if (left && index > 0) + { + int[] region = hiddenColumns.get(index - 1); + return region[1]; + } + else if (!left && index < hiddenColumns.size()) { int[] region = hiddenColumns.get(index); if (alPos < region[0]) @@ -904,63 +674,54 @@ public class HiddenColumns } /** - * This method returns the leftmost limit of a region of an alignment with - * hidden columns. In otherwords, the previous hidden column. + * Answers if a column in the alignment is visible * - * @param alPos - * the absolute (visible) alignmentPosition to find the previous - * hidden column for + * @param column + * absolute position of column in the alignment + * @return true if column is visible */ - public int getHiddenBoundaryLeft(int alPos) + public boolean isVisible(int column) { try { LOCK.readLock().lock(); - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { - int index = cursor.findRegionForColumn(alPos).getRegionIndex(); - - if (index > 0) + int regionindex = cursor.findRegionForColumn(column, false) + .getRegionIndex(); + if (regionindex > -1 && regionindex < hiddenColumns.size()) { - int[] region = hiddenColumns.get(index - 1); - return region[1]; + int[] region = hiddenColumns.get(regionindex); + // already know that column <= region[1] as cursor returns containing + // region or region to right + if (column >= region[0]) + { + return false; + } } } - return alPos; + return true; + } finally { LOCK.readLock().unlock(); } } - /** - * Answers if a column in the alignment is visible * - * @param column - * absolute position of column in the alignment - * @return true if column is visible + * @return true if there are columns hidden */ - public boolean isVisible(int column) + public boolean hasHiddenColumns() { try { LOCK.readLock().lock(); - int regionindex = cursor.findRegionForColumn(column).getRegionIndex(); - if (regionindex > -1 && regionindex < hiddenColumns.size()) - { - int[] region = hiddenColumns.get(regionindex); - // already know that column <= region[1] as cursor returns containing - // region or region to right - if (column >= region[0]) - { - return false; - } - } - return true; - + // we don't use getSize()>0 here because it has to iterate over + // the full hiddenColumns collection and so will be much slower + return (!hiddenColumns.isEmpty()); } finally { LOCK.readLock().unlock(); @@ -968,60 +729,15 @@ public class HiddenColumns } /** - * Get the visible sections of a set of sequences * - * @param start - * sequence position to start from - * @param end - * sequence position to end at - * @param seqs - * an array of sequences - * @return an array of strings encoding the visible parts of each sequence + * @return true if there is more than one hidden column region */ - public String[] getVisibleSequenceStrings(int start, int end, - SequenceI[] seqs) + public boolean hasMultiHiddenColumnRegions() { try { LOCK.readLock().lock(); - int iSize = seqs.length; - String[] selections = new String[iSize]; - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - for (int i = 0; i < iSize; i++) - { - StringBuffer visibleSeq = new StringBuffer(); - - Iterator blocks = new VisibleContigsIterator(start, - end + 1, hiddenColumns); - - while (blocks.hasNext()) - { - int[] block = blocks.next(); - if (blocks.hasNext()) - { - visibleSeq - .append(seqs[i].getSequence(block[0], block[1] + 1)); - } - else - { - visibleSeq - .append(seqs[i].getSequence(block[0], block[1])); - } - } - - selections[i] = visibleSeq.toString(); - } - } - else - { - for (int i = 0; i < iSize; i++) - { - selections[i] = seqs[i].getSequenceAsString(start, end); - } - } - - return selections; + return !hiddenColumns.isEmpty() && hiddenColumns.size() > 1; } finally { LOCK.readLock().unlock(); @@ -1029,67 +745,22 @@ public class HiddenColumns } /** - * Locate the first position visible for this sequence. If seq isn't visible - * then return the position of the left side of the hidden boundary region. - * - * @param seq - * sequence to find position for - * @return visible start position + * Returns a hashCode built from hidden column ranges */ - public int locateVisibleStartOfSequence(SequenceI seq) + @Override + public int hashCode() { try { LOCK.readLock().lock(); - int start = 0; - - if (hiddenColumns == null || hiddenColumns.size() == 0) - { - return seq.findIndex(seq.getStart()) - 1; - } - - // Simply walk along the sequence whilst watching for hidden column - // boundaries - Iterator regions = hiddenColumns.iterator(); - int hideStart = seq.getLength(); - int hideEnd = -1; - int visPrev = 0; - int visNext = 0; - boolean foundStart = false; - - // step through the non-gapped positions of the sequence - for (int i = seq.getStart(); i <= seq.getEnd() && (!foundStart); i++) - { - // get alignment position of this residue in the sequence - int p = seq.findIndex(i) - 1; - - // update hidden region start/end - while (hideEnd < p && regions.hasNext()) - { - int[] region = regions.next(); - visPrev = visNext; - visNext += region[0] - visPrev; - hideStart = region[0]; - hideEnd = region[1]; - } - if (hideEnd < p) - { - hideStart = seq.getLength(); - } - // update visible boundary for sequence - if (p < hideStart) - { - start = p; - foundStart = true; - } - } + int hashCode = 1; - if (foundStart) + for (int[] hidden : hiddenColumns) { - return findColumnPosition(start); + hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; } - // otherwise, sequence was completely hidden - return visPrev; + return hashCode; } finally { LOCK.readLock().unlock(); @@ -1097,196 +768,129 @@ public class HiddenColumns } /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). + * Hide columns corresponding to the marked bits * - * @param alignmentAnnotation + * @param inserts + * - columns mapped to bits starting from zero */ - public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) + public void hideColumns(BitSet inserts) { - if (alignmentAnnotation != null - && alignmentAnnotation.annotations != null) - { - makeVisibleAnnotation(0, alignmentAnnotation.annotations.length, - alignmentAnnotation); - } + hideColumns(inserts, 0, inserts.length() - 1); } /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). + * Hide columns corresponding to the marked bits, within the range + * [start,end]. Entries in tohide which are outside [start,end] are ignored. * + * @param tohide + * columns mapped to bits starting from zero * @param start - * remove any annotation to the right of this column + * start of range to hide columns within * @param end - * remove any annotation to the left of this column - * @param alignmentAnnotation - * the annotation to operate on + * end of range to hide columns within */ - public void makeVisibleAnnotation(int start, int end, - AlignmentAnnotation alignmentAnnotation) + private void hideColumns(BitSet tohide, int start, int end) { try { - LOCK.readLock().lock(); - - int startFrom = start; - int endAt = end; - - if (alignmentAnnotation != null - && alignmentAnnotation.annotations != null) + LOCK.writeLock().lock(); + for (int firstSet = tohide + .nextSetBit(start), lastSet = start; firstSet >= start + && lastSet <= end; firstSet = tohide + .nextSetBit(lastSet)) { - if (hiddenColumns != null && hiddenColumns.size() > 0) + lastSet = tohide.nextClearBit(firstSet); + if (lastSet <= end) { - removeHiddenAnnotation(startFrom, endAt, alignmentAnnotation); + hideColumns(firstSet, lastSet - 1); } - else + else if (firstSet <= end) { - alignmentAnnotation.restrict(startFrom, endAt); + hideColumns(firstSet, end); } } + cursor = new HiddenColumnsCursor(hiddenColumns); } finally { - LOCK.readLock().unlock(); - } - } - - private void removeHiddenAnnotation(int start, int end, - AlignmentAnnotation alignmentAnnotation) - { - // mangle the alignmentAnnotation annotation array - ArrayList annels = new ArrayList<>(); - Annotation[] els = null; - - int w = 0; - - Iterator blocks = new VisibleContigsIterator(start, end + 1, - hiddenColumns); - - int copylength; - int annotationLength; - while (blocks.hasNext()) - { - int[] block = blocks.next(); - annotationLength = block[1] - block[0] + 1; - - if (blocks.hasNext()) - { - // copy just the visible segment of the annotation row - copylength = annotationLength; - } - else - { - if (annotationLength + block[0] <= alignmentAnnotation.annotations.length) - { - // copy just the visible segment of the annotation row - copylength = annotationLength; - } - else - { - // copy to the end of the annotation row - copylength = alignmentAnnotation.annotations.length - block[0]; - } - } - - els = new Annotation[annotationLength]; - annels.add(els); - System.arraycopy(alignmentAnnotation.annotations, block[0], els, 0, - copylength); - w += annotationLength; - } - - if (w != 0) - { - alignmentAnnotation.annotations = new Annotation[w]; - - w = 0; - for (Annotation[] chnk : annels) - { - System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, - chnk.length); - w += chnk.length; - } + LOCK.writeLock().unlock(); } } /** + * Hide columns corresponding to the marked bits, within the range + * [start,end]. Entries in tohide which are outside [start,end] are ignored. + * NB Existing entries in [start,end] are cleared. * - * @return true if there are columns hidden + * @param tohide + * columns mapped to bits starting from zero + * @param start + * start of range to hide columns within + * @param end + * end of range to hide columns within */ - public boolean hasHiddenColumns() + public void clearAndHideColumns(BitSet tohide, int start, int end) { - try - { - LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 0; - } finally - { - LOCK.readLock().unlock(); - } + clearHiddenColumnsInRange(start, end); + hideColumns(tohide, start, end); } /** + * Make all columns in the range [start,end] visible * - * @return true if there are more than one set of columns hidden + * @param start + * start of range to show columns + * @param end + * end of range to show columns */ - public boolean hasManyHiddenColumns() + private void clearHiddenColumnsInRange(int start, int end) { try { - LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 1; - } finally - { - LOCK.readLock().unlock(); - } - } - + LOCK.writeLock().lock(); - /** - * Returns a hashCode built from hidden column ranges - */ - @Override - public int hashCode() - { - try - { - LOCK.readLock().lock(); - int hashCode = 1; - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) + if (!hiddenColumns.isEmpty()) { - int[] hidden = it.next(); - hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; - hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; - } - return hashCode; - } finally - { - LOCK.readLock().unlock(); - } - } + HiddenCursorPosition pos = cursor.findRegionForColumn(start, false); + int index = pos.getRegionIndex(); - /** - * Hide columns corresponding to the marked bits - * - * @param inserts - * - columns map to bits starting from zero - */ - public void hideMarkedBits(BitSet inserts) - { - try - { - LOCK.writeLock().lock(); - for (int firstSet = inserts - .nextSetBit(0), lastSet = 0; firstSet >= 0; firstSet = inserts - .nextSetBit(lastSet)) - { - lastSet = inserts.nextClearBit(firstSet); - hideColumns(firstSet, lastSet - 1); + if (index != -1 && index != hiddenColumns.size()) + { + // regionIndex is the region which either contains start + // or lies to the right of start + int[] region = hiddenColumns.get(index); + if (region[0] < start && region[1] >= start) + { + // region contains start, truncate so that it ends just before start + numColumns -= region[1] - start + 1; + region[1] = start - 1; + index++; + } + + int endi = index; + while (endi < hiddenColumns.size()) + { + region = hiddenColumns.get(endi); + + if (region[1] > end) + { + if (region[0] <= end) + { + // region contains end, truncate so it starts just after end + numColumns -= end - region[0] + 1; + region[0] = end + 1; + } + break; + } + + numColumns -= region[1] - region[0] + 1; + endi++; + } + hiddenColumns.subList(index, endi).clear(); + + } + + cursor = new HiddenColumnsCursor(hiddenColumns); } - cursor.resetCursor(hiddenColumns); - numColumns = 0; } finally { LOCK.writeLock().unlock(); @@ -1295,27 +899,26 @@ public class HiddenColumns /** * - * @param inserts + * @param updates * BitSet where hidden columns will be marked */ - public void markHiddenRegions(BitSet inserts) + protected void andNot(BitSet updates) { try { - LOCK.readLock().lock(); - if (hiddenColumns == null) - { - return; - } - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) + LOCK.writeLock().lock(); + + BitSet hiddenBitSet = new BitSet(); + for (int[] range : hiddenColumns) { - int[] range = it.next(); - inserts.set(range[0], range[1] + 1); + hiddenBitSet.set(range[0], range[1] + 1); } + hiddenBitSet.andNot(updates); + hiddenColumns.clear(); + hideColumns(hiddenBitSet); } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1331,44 +934,27 @@ public class HiddenColumns try { LOCK.readLock().lock(); - int[] alignmentStartEnd = new int[] { 0, width - 1 }; - int startPos = alignmentStartEnd[0]; - int endPos = alignmentStartEnd[1]; - - int[] lowestRange = new int[] { -1, -1 }; - int[] higestRange = new int[] { -1, -1 }; - if (hiddenColumns == null) - { - return new int[] { startPos, endPos }; - } + int firstVisible = 0; + int lastVisible = width - 1; - Iterator it = hiddenColumns.iterator(); - while (it.hasNext()) + if (!hiddenColumns.isEmpty()) { - int[] range = it.next(); - lowestRange = (range[0] <= startPos) ? range : lowestRange; - higestRange = (range[1] >= endPos) ? range : higestRange; - } + // first visible col with index 0, convert to absolute index + firstVisible = visibleToAbsoluteColumn(0); - if (lowestRange[0] == -1) // includes (lowestRange[1] == -1) - { - startPos = alignmentStartEnd[0]; - } - else - { - startPos = lowestRange[1] + 1; + // last visible column is either immediately to left of + // last hidden region, or is just the last column in the alignment + int[] lastregion = hiddenColumns.get(hiddenColumns.size() - 1); + if (lastregion[1] == width - 1) + { + // last region is at very end of alignment + // last visible column immediately precedes it + lastVisible = lastregion[0] - 1; + } } + return new int[] { firstVisible, lastVisible }; - if (higestRange[0] == -1) // includes (higestRange[1] == -1) - { - endPos = alignmentStartEnd[1]; - } - else - { - endPos = higestRange[0] - 1; - } - return new int[] { startPos, endPos }; } finally { LOCK.readLock().unlock(); @@ -1380,21 +966,22 @@ public class HiddenColumns * * @param res * visible residue position, unadjusted for hidden columns - * @return region as [start,end] or null if no matching region is found + * @return region as [start,end] or null if no matching region is found. If + * res is adjacent to two regions, returns the left region. */ public int[] getRegionWithEdgeAtRes(int res) { try { LOCK.readLock().lock(); - int adjres = adjustForHiddenColumns(res); + int adjres = visibleToAbsoluteColumn(res); int[] reveal = null; - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { // look for a region ending just before adjres - int regionindex = cursor.findRegionForColumn(adjres - 1) + int regionindex = cursor.findRegionForColumn(adjres - 1, false) .getRegionIndex(); if (regionindex < hiddenColumns.size() && hiddenColumns.get(regionindex)[1] == adjres - 1) @@ -1424,7 +1011,7 @@ public class HiddenColumns try { LOCK.readLock().lock(); - return new BoundedHiddenColsIterator(hiddenColumns); + return new RangeIterator(hiddenColumns); } finally { LOCK.readLock().unlock(); @@ -1445,7 +1032,7 @@ public class HiddenColumns try { LOCK.readLock().lock(); - return new BoundedHiddenColsIterator(start, end, hiddenColumns); + return new RangeIterator(start, end, hiddenColumns); } finally { LOCK.readLock().unlock(); @@ -1461,14 +1048,14 @@ public class HiddenColumns * @param end * position to end at (inclusive, visible column position) */ - public Iterator getBoundedStartIterator(int start, int end) + public Iterator getStartRegionIterator(int start, int end) { try { LOCK.readLock().lock(); // get absolute position of column in alignment - int absoluteStart = adjustForHiddenColumns(start); + int absoluteStart = visibleToAbsoluteColumn(start); // Get cursor position and supply it to the iterator: // Since we want visible region start, we look for a cursor for the @@ -1476,10 +1063,9 @@ public class HiddenColumns // region we'll get the cursor pointing to the region before, which is // what we want HiddenCursorPosition pos = cursor - .findRegionForColumn(absoluteStart - 1); + .findRegionForColumn(absoluteStart - 1, false); - return new BoundedStartRegionIterator(pos, start, end, - hiddenColumns); + return new StartRegionIterator(pos, start, end, hiddenColumns); } finally { LOCK.readLock().unlock(); @@ -1500,7 +1086,8 @@ public class HiddenColumns try { LOCK.readLock().lock(); - return new VisibleColsIterator(start, end, hiddenColumns); + return new RangeElementsIterator( + new VisibleContigsIterator(start, end + 1, hiddenColumns)); } finally { LOCK.readLock().unlock(); @@ -1519,15 +1106,15 @@ public class HiddenColumns * if true, start and end are visible column positions, not absolute * positions* */ - public Iterator getVisContigsIterator(int start, int end, + public VisibleContigsIterator getVisContigsIterator(int start, int end, boolean useVisibleCoords) { int adjstart = start; int adjend = end; if (useVisibleCoords) { - adjstart = adjustForHiddenColumns(start); - adjend = adjustForHiddenColumns(end); + adjstart = visibleToAbsoluteColumn(start); + adjend = visibleToAbsoluteColumn(end); } try