X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=93791e44f8691559f2895f28ceff4f1b32c2de6c;hb=d4e62e67024759a6452c10521a113f578832b9c0;hp=305a6f195ea832a16694d6bb9c6ef366a641715f;hpb=290417727ff37c2d08bbe8962c6a6cd6a187cfe0;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index 305a6f1..93791e4 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -20,21 +20,51 @@ */ package jalview.datamodel; -import jalview.util.Comparison; -import jalview.util.ShiftList; - import java.util.ArrayList; import java.util.BitSet; -import java.util.Collections; +import java.util.Iterator; import java.util.List; -import java.util.Vector; import java.util.concurrent.locks.ReentrantReadWriteLock; +/** + * This class manages the collection of hidden columns associated with an + * alignment. To iterate over the collection, or over visible columns/regions, + * use an iterator obtained from one of: + * + * - getBoundedIterator: iterates over the hidden regions, within some bounds, + * returning absolute positions + * + * - getBoundedStartIterator: iterates over the start positions of hidden + * regions, within some bounds, returning visible positions + * + * - getVisContigsIterator: iterates over visible regions in a range, returning + * absolute positions + * + * - getVisibleColsIterator: iterates over the visible *columns* + * + * For performance reasons, provide bounds where possible. + * + * @author kmourao + * + */ public class HiddenColumns { + private static final int HASH_MULTIPLIER = 31; + private static final ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock(); /* + * Cursor which tracks the last used hidden columns region, and the number + * of hidden columns up to (but not including) that region. + */ + private HiddenColumnsCursor cursor = new HiddenColumnsCursor(); + + /* + * cache of the number of hidden columns + */ + private int numColumns = 0; + + /* * list of hidden column [start, end] ranges; the list is maintained in * ascending start column order */ @@ -47,21 +77,39 @@ 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 * * @param copy + * the HiddenColumns object to copy from */ public HiddenColumns(HiddenColumns copy) { try { LOCK.writeLock().lock(); + numColumns = 0; if (copy != null) { if (copy.hiddenColumns != null) { - hiddenColumns = copy.copyHiddenRegionsToArrayList(); + 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 @@ -71,829 +119,635 @@ public class HiddenColumns } /** - * This method is used to return all the HiddenColumn regions and is intended - * to remain private. External callers which need a copy of the regions can - * call getHiddenColumnsCopyAsList. + * Copy constructor within bounds and with offset. Copies hidden column + * regions fully contained between start and end, and offsets positions by + * subtracting offset. * - * @return empty list or List of hidden column intervals - */ - private List getHiddenRegions() - { - return hiddenColumns == null ? Collections. emptyList() - : hiddenColumns; - } - - /** - * Output regions data as a string. String is in the format: - * reg0[0]reg0[1]reg1[0]reg1[1] ... regn[1] + * @param copy + * HiddenColumns instance to copy from + * @param start + * lower bound to copy from + * @param end + * upper bound to copy to + * @param offset + * offset to subtract from each region boundary position * - * @param delimiter - * string to delimit regions - * @param betweenstring - * to put between start and end region values - * @return regions formatted according to delimiter and between strings */ - public String regionsToString(String delimiter, String between) + public HiddenColumns(HiddenColumns copy, int start, int end, int offset) { try { - LOCK.readLock().lock(); - StringBuilder regionBuilder = new StringBuilder(); - if (hiddenColumns != null) + LOCK.writeLock().lock(); + if (copy != null) { - for (int[] range : hiddenColumns) + hiddenColumns = new ArrayList<>(); + numColumns = 0; + Iterator it = copy.getBoundedIterator(start, end); + while (it.hasNext()) { - regionBuilder.append(delimiter).append(range[0]).append(between) - .append(range[1]); + int[] region = it.next(); + // still need to check boundaries because iterator returns + // 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 }); + numColumns += region[1] - region[0] + 1; + } } - - regionBuilder.deleteCharAt(0); + cursor.resetCursor(hiddenColumns); } - return regionBuilder.toString(); } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } /** - * Find the number of hidden columns + * Adds the specified column range to the hidden columns collection * - * @return number of hidden columns + * @param start + * start of range to add (absolute position in alignment) + * @param end + * end of range to add (absolute position in alignment) */ - public int getSize() + public void hideColumns(int start, int end) { + boolean wasAlreadyLocked = false; try { - LOCK.readLock().lock(); - int size = 0; - if (hasHiddenColumns()) + // 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()) { - for (int[] range : hiddenColumns) - { - size += range[1] - range[0] + 1; - } + LOCK.writeLock().lock(); + } + else + { + wasAlreadyLocked = true; } - return size; - } finally - { - LOCK.readLock().unlock(); - } - } - - @Override - public boolean equals(Object obj) - { - try - { - LOCK.readLock().lock(); - if (!(obj instanceof HiddenColumns)) + int previndex = 0; + int prevHiddenCount = 0; + int regionindex = 0; + if (hiddenColumns == null) { - return false; + hiddenColumns = new ArrayList<>(); + } + else + { + // set up cursor reset values + HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start); + regionindex = cursorPos.getRegionIndex(); + + if (regionindex > 0) + { + // get previous index and hidden count for updating the cursor later + previndex = regionindex - 1; + int[] prevRegion = hiddenColumns.get(previndex); + prevHiddenCount = cursorPos.getHiddenSoFar() + - (prevRegion[1] - prevRegion[0] + 1); + } } - HiddenColumns that = (HiddenColumns) obj; /* - * check hidden columns are either both null, or match + * new range follows everything else; check first to avoid looping over whole hiddenColumns collection */ - if (this.hiddenColumns == null) - { - return (that.hiddenColumns == null); - } - if (that.hiddenColumns == null - || that.hiddenColumns.size() != this.hiddenColumns.size()) + if (hiddenColumns.isEmpty() + || start > hiddenColumns.get(hiddenColumns.size() - 1)[1]) { - return false; + hiddenColumns.add(new int[] { start, end }); } - int i = 0; - for (int[] thisRange : hiddenColumns) + else { - int[] thatRange = that.hiddenColumns.get(i++); - if (thisRange[0] != thatRange[0] || thisRange[1] != thatRange[1]) + /* + * traverse existing hidden ranges and insert / amend / append as + * appropriate + */ + boolean added = false; + if (regionindex > 0) { - return false; + added = insertRangeAtRegion(regionindex - 1, start, end); + } + if (!added && regionindex < hiddenColumns.size()) + { + insertRangeAtRegion(regionindex, start, end); } } - return true; + + // 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; + } finally { - LOCK.readLock().unlock(); + if (!wasAlreadyLocked) + { + LOCK.writeLock().unlock(); + } } } /** - * Return absolute column index for a visible column index + * Insert [start, range] at the region at index i in hiddenColumns, if + * feasible * - * @param column - * int column index in alignment view (count from zero) - * @return alignment column index for column + * @param i + * index to insert at + * @param start + * start of range to insert + * @param end + * end of range to insert + * @return true if range was successfully inserted */ - public int adjustForHiddenColumns(int column) + private boolean insertRangeAtRegion(int i, int start, int end) { - try + boolean added = false; + + int[] region = hiddenColumns.get(i); + if (end < region[0] - 1) { - LOCK.readLock().lock(); - int result = column; - if (hiddenColumns != null) + /* + * insert discontiguous preceding range + */ + hiddenColumns.add(i, new int[] { start, end }); + added = true; + } + else if (end <= region[1]) + { + /* + * new range overlaps existing, or is contiguous preceding it - adjust + * start column + */ + region[0] = Math.min(region[0], start); + added = true; + } + else if (start <= region[1] + 1) + { + /* + * 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); + + /* + * also update or remove any subsequent ranges + * that are overlapped + */ + while (i < hiddenColumns.size() - 1) { - for (int i = 0; i < hiddenColumns.size(); i++) + int[] nextRegion = hiddenColumns.get(i + 1); + if (nextRegion[0] > end + 1) { - int[] region = hiddenColumns.get(i); - if (result >= region[0]) - { - result += region[1] - region[0] + 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(); } - return result; - } finally - { - LOCK.readLock().unlock(); + added = true; } + return added; } /** - * 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. + * mark the columns corresponding to gap characters as hidden in the column + * selection * - * @param hiddenColumn - * the column index in the full alignment including hidden columns - * @return the position of the column in the visible alignment + * @param sr */ - public int findColumnPosition(int hiddenColumn) + public void hideInsertionsFor(SequenceI sr) { try { - LOCK.readLock().lock(); - int result = hiddenColumn; - if (hiddenColumns != null) + LOCK.writeLock().lock(); + List inserts = sr.getInsertions(); + for (int[] r : inserts) { - int index = 0; - int[] region; - do - { - region = hiddenColumns.get(index++); - if (hiddenColumn > region[1]) - { - result -= region[1] + 1 - region[0]; - } - } while ((hiddenColumn > region[1]) - && (index < hiddenColumns.size())); - - if (hiddenColumn >= region[0] && hiddenColumn <= region[1]) - { - // Here the hidden column is within a region, so - // we want to return the position of region[0]-1, adjusted for any - // earlier hidden columns. - // Calculate the difference between the actual hidden col position - // and region[0]-1, and then subtract from result to convert result - // from - // the adjusted hiddenColumn value to the adjusted region[0]-1 value - - // However, if the region begins at 0 we cannot return region[0]-1 - // just return 0 - if (region[0] == 0) - { - return 0; - } - else - { - return result - (hiddenColumn - region[0] + 1); - } - } + hideColumns(r[0], r[1]); } - return result; // return the shifted position after removing hidden - // columns. + cursor.resetCursor(hiddenColumns); + numColumns = 0; } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } /** - * 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. - * - * @param visibleDistance - * the number of visible columns to offset by - * @param startColumn - * the column to start from - * @return the position of the column in the visible alignment + * Unhides, and adds to the selection list, all hidden columns */ - public int subtractVisibleColumns(int visibleDistance, int startColumn) + public void revealAllHiddenColumns(ColumnSelection sel) { 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)); - - // get index of hidden region to left of start - int index = getHiddenIndexLeft(start); - if (index == -1) - { - // no hidden regions to left of startColumn - return start - distance; - } - - // walk backwards through the alignment subtracting the counts of visible - // columns from distance - int[] region; - int gap = 0; - int nextstart = start; - - while ((index > -1) && (distance - gap > 0)) - { - // subtract the gap to right of region from distance - distance -= gap; - start = nextstart; - - // calculate the next gap - region = hiddenColumns.get(index); - gap = start - region[1]; - - // set start to just to left of current region - nextstart = region[0] - 1; - index--; - } - - if (distance - gap > 0) + LOCK.writeLock().lock(); + if (hiddenColumns != null) { - // fell out of loop because there are no more hidden regions - distance -= gap; - return nextstart - distance; + Iterator it = hiddenColumns.iterator(); + while (it.hasNext()) + { + int[] region = it.next(); + for (int j = region[0]; j < region[1] + 1; j++) + { + sel.addElement(j); + } + } + hiddenColumns = null; + cursor.resetCursor(hiddenColumns); + numColumns = 0; } - return start - distance; } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } - } /** - * Use this method to determine the set of hiddenRegion start positions + * Reveals, and marks as selected, the hidden column range with the given + * start column * - * @return list of column number in visible view where hidden regions start + * @param start + * the start column to look for + * @param sel + * the column selection to add the hidden column range to */ - public List findHiddenRegionPositions() + public void revealHiddenColumns(int start, ColumnSelection sel) { try { - LOCK.readLock().lock(); - List positions = null; + LOCK.writeLock().lock(); if (hiddenColumns != null) { - positions = new ArrayList<>(hiddenColumns.size()); + int regionIndex = cursor.findRegionForColumn(start) + .getRegionIndex(); - positions.add(hiddenColumns.get(0)[0]); - for (int i = 1; i < hiddenColumns.size(); ++i) + if (regionIndex != -1 && regionIndex != hiddenColumns.size()) { - - int result = 0; - if (hiddenColumns != null) + // regionIndex is the region which either contains start + // or lies to the right of start + int[] region = hiddenColumns.get(regionIndex); + if (start == region[0]) { - int index = 0; - int gaps = 0; - do + for (int j = region[0]; j < region[1] + 1; j++) { - int[] region = hiddenColumns.get(index); - gaps += region[1] + 1 - region[0]; - result = region[1] + 1; - index++; - } while (index <= i); + sel.addElement(j); + } + int colsToRemove = region[1] - region[0] + 1; + hiddenColumns.remove(regionIndex); - result -= gaps; + if (hiddenColumns.isEmpty()) + { + hiddenColumns = null; + numColumns = 0; + } + else + { + numColumns -= colsToRemove; + } + cursor.updateForDeletedRegion(hiddenColumns); } - positions.add(result); } } - else - { - positions = new ArrayList<>(); - } - - return positions; } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } /** - * This method returns the rightmost limit of a region of an alignment with - * hidden columns. In otherwords, the next hidden column. + * Add gaps into the sequences aligned to profileseq under the given + * AlignmentView * - * @param index - * int + * @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 int getHiddenBoundaryRight(int alPos) + public static HiddenColumns propagateInsertions(SequenceI profileseq, + AlignmentI al, AlignmentView input) { - try - { - LOCK.readLock().lock(); - if (hiddenColumns != null) - { - int index = 0; - do - { - int[] region = hiddenColumns.get(index); - if (alPos < region[0]) - { - return region[0]; - } - - index++; - } while (index < hiddenColumns.size()); - } - - return alPos; - } finally - { - LOCK.readLock().unlock(); - } + 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; } /** - * This method returns the leftmost limit of a region of an alignment with - * hidden columns. In otherwords, the previous hidden column. * - * @param index - * int + * @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 */ - public int getHiddenBoundaryLeft(int alPos) + private void propagateInsertions(SequenceI profileseq, AlignmentI al, + SequenceI origseq) { try { - LOCK.readLock().lock(); - - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do - { - int[] region = hiddenColumns.get(index); - if (alPos > region[1]) - { - return region[1]; - } + LOCK.writeLock().lock(); - index--; - } while (index > -1); - } + char gc = al.getGapCharacter(); - return alPos; - } finally - { - LOCK.readLock().unlock(); - } - } + // take the set of hidden columns, and the set of gaps in origseq, + // and remove all the hidden gaps from hiddenColumns - /** - * This method returns the index of the hidden region to the left of a column - * position. If the column is in a hidden region it returns the index of the - * region to the left. If there is no hidden region to the left it returns -1. - * - * @param pos - * int - */ - private int getHiddenIndexLeft(int pos) - { - try - { + // first get the gaps as a Bitset + BitSet gaps = origseq.gapBitset(); - LOCK.readLock().lock(); - if (hiddenColumns != null) + // 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()) { - int index = hiddenColumns.size() - 1; - do + // 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]) { - int[] region = hiddenColumns.get(index); - if (pos > region[1]) + gapPosition++; + if (gaps.get(gapPosition)) { - return index; + numGapsBefore++; } + } - index--; - } while (index > -1); - } + 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); - return -1; + } + hiddenColumns = newhidden; + cursor.resetCursor(hiddenColumns); + numColumns = 0; } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } - } /** - * Adds the specified column range to the hidden columns + * Pad gaps in all sequences in alignment except profileseq * - * @param start - * @param end + * @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 */ - public void hideColumns(int start, int end) + private void padGaps(StringBuffer sb, int pos, SequenceI profileseq, + AlignmentI al) { - boolean wasAlreadyLocked = false; - try + // loop over the sequences and pad with gaps where required + for (int s = 0, ns = al.getHeight(); s < ns; s++) { - // 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()) + SequenceI sqobj = al.getSequenceAt(s); + if (sqobj != profileseq) { - LOCK.writeLock().lock(); - } - else - { - wasAlreadyLocked = true; - } - - if (hiddenColumns == null) - { - hiddenColumns = new ArrayList<>(); - } - - /* - * traverse existing hidden ranges and insert / amend / append as - * appropriate - */ - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.get(i); - - if (end < region[0] - 1) + String sq = al.getSequenceAt(s).getSequenceAsString(); + if (sq.length() <= pos) { - /* - * insert discontiguous preceding range - */ - hiddenColumns.add(i, new int[] { start, end }); - return; - } - - if (end <= region[1]) - { - /* - * new range overlaps existing, or is contiguous preceding it - adjust - * start column - */ - region[0] = Math.min(region[0], start); - return; - } - - if (start <= region[1] + 1) - { - /* - * 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); - - /* - * also update or remove any subsequent ranges - * that are overlapped - */ - while (i < hiddenColumns.size() - 1) + // pad sequence + int diff = pos - sq.length() - 1; + if (diff > 0) { - int[] nextRegion = hiddenColumns.get(i + 1); - if (nextRegion[0] > end + 1) + // pad gaps + sq = sq + sb; + while ((diff = pos - sq.length() - 1) > 0) { - /* - * gap to next hidden range - no more to update - */ - break; + if (diff >= sb.length()) + { + sq += sb.toString(); + } + else + { + char[] buf = new char[diff]; + sb.getChars(0, diff, buf, 0); + sq += buf.toString(); + } } - region[1] = Math.max(nextRegion[1], end); - hiddenColumns.remove(i + 1); } - return; + sq += sb.toString(); + } + else + { + al.getSequenceAt(s).setSequence( + sq.substring(0, pos) + sb.toString() + sq.substring(pos)); } - } - - /* - * remaining case is that the new range follows everything else - */ - hiddenColumns.add(new int[] { start, end }); - } finally - { - if (!wasAlreadyLocked) - { - LOCK.writeLock().unlock(); } } } - public boolean isVisible(int column) + /* + * 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] + * + * @param delimiter + * string to delimit regions + * @param betweenstring + * to put between start and end region values + * @return regions formatted according to delimiter and between strings + */ + public String regionsToString(String delimiter, String between) { try { LOCK.readLock().lock(); - + StringBuilder regionBuilder = new StringBuilder(); if (hiddenColumns != null) { - for (int[] region : hiddenColumns) + Iterator it = hiddenColumns.iterator(); + while (it.hasNext()) { - if (column >= region[0] && column <= region[1]) + int[] range = it.next(); + regionBuilder.append(delimiter).append(range[0]).append(between) + .append(range[1]); + if (!it.hasNext()) { - return false; + regionBuilder.deleteCharAt(0); } } } - - return true; + return regionBuilder.toString(); } finally { LOCK.readLock().unlock(); } } - private ArrayList copyHiddenRegionsToArrayList() - { - int size = 0; - if (hiddenColumns != null) - { - size = hiddenColumns.size(); - } - ArrayList copy = new ArrayList<>(size); - - for (int i = 0, j = size; i < j; i++) - { - int[] rh; - int[] cp; - rh = hiddenColumns.get(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - copy.add(cp); - } - } - - return copy; - } - /** - * Returns a copy of the vector of hidden regions, as an ArrayList. Before - * using this method please consider if you really need access to the hidden - * regions - a new (or existing!) method on HiddenColumns might be more - * appropriate. + * Find the number of hidden columns * - * @return hidden regions as an ArrayList of [start,end] pairs + * @return number of hidden columns */ - public ArrayList getHiddenColumnsCopy() + public int getSize() { try { LOCK.readLock().lock(); - return copyHiddenRegionsToArrayList(); - } finally - { - LOCK.readLock().unlock(); - } - } - - /** - * propagate shift in alignment columns to column selection - * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) - */ - public List compensateForEdit(int start, int change, - ColumnSelection sel) - { - try - { - LOCK.writeLock().lock(); - List deletedHiddenColumns = null; - if (hiddenColumns != null) + if (numColumns == 0 && hiddenColumns != null) { - deletedHiddenColumns = new ArrayList<>(); - int hSize = hiddenColumns.size(); - for (int i = 0; i < hSize; i++) - { - int[] region = hiddenColumns.get(i); - if (region[0] > start && start + change > region[1]) - { - deletedHiddenColumns.add(region); - - hiddenColumns.remove(i); - i--; - hSize--; - continue; - } - - if (region[0] > start) - { - region[0] -= change; - region[1] -= change; - } - - if (region[0] < 0) - { - region[0] = 0; - } + // 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; } - this.revealHiddenColumns(0, sel); + numColumns = size; } - return deletedHiddenColumns; + return numColumns; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * propagate shift in alignment columns to column selection special version of - * compensateForEdit - allowing for edits within hidden regions + * Get the number of distinct hidden regions * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) + * @return number of regions */ - public void compensateForDelEdits(int start, int change) + public int getNumberOfRegions() { try { - LOCK.writeLock().lock(); - if (hiddenColumns != null) + LOCK.readLock().lock(); + int num = 0; + if (hasHiddenColumns()) { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.get(i); - if (region[0] >= start) - { - region[0] -= change; - } - if (region[1] >= start) - { - region[1] -= change; - } - if (region[1] < region[0]) - { - hiddenColumns.remove(i--); - } - - if (region[0] < 0) - { - region[0] = 0; - } - if (region[1] < 0) - { - region[1] = 0; - } - } + num = hiddenColumns.size(); } + return num; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } - /** - * return all visible segments between the given start and end boundaries - * - * @param start - * (first column inclusive from 0) - * @param end - * (last column - not inclusive) - * @return int[] {i_start, i_end, ..} where intervals lie in - * start<=i_start<=i_end 0) - { - List visiblecontigs = new ArrayList<>(); - List regions = getHiddenRegions(); - - int vstart = start; - int[] region; - int hideStart; - int hideEnd; - for (int j = 0; vstart < end && j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; + if (!(obj instanceof HiddenColumns)) + { + return false; + } + HiddenColumns that = (HiddenColumns) obj; - if (hideEnd < vstart) - { - continue; - } - if (hideStart > vstart) - { - visiblecontigs.add(new int[] { vstart, hideStart - 1 }); - } - vstart = hideEnd + 1; - } + /* + * 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()) + { + return false; + } - if (vstart < end) - { - visiblecontigs.add(new int[] { vstart, end - 1 }); - } - int[] vcontigs = new int[visiblecontigs.size() * 2]; - for (int i = 0, j = visiblecontigs.size(); i < j; i++) + Iterator it = hiddenColumns.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]) { - int[] vc = visiblecontigs.get(i); - visiblecontigs.set(i, null); - vcontigs[i * 2] = vc[0]; - vcontigs[i * 2 + 1] = vc[1]; + return false; } - visiblecontigs.clear(); - return vcontigs; - } - else - { - return new int[] { start, end - 1 }; } + return true; } finally { LOCK.readLock().unlock(); } } - public String[] getVisibleSequenceStrings(int start, int end, - SequenceI[] seqs) + /** + * Return absolute column index for a visible column index + * + * @param column + * int column index in alignment view (count from zero) + * @return alignment column index for column + */ + public int visibleToAbsoluteColumn(int column) { 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(); - List regions = getHiddenRegions(); - - int blockStart = start; - int blockEnd = end; - int[] region; - int hideStart; - int hideEnd; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); - - if (blockStart > blockEnd) - { - break; - } - - visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd)); - - blockStart = hideEnd + 1; - blockEnd = end; - } - - if (end > blockStart) - { - visibleSeq.append(seqs[i].getSequence(blockStart, end)); - } + int result = column; - selections[i] = visibleSeq.toString(); - } - } - else + if (hiddenColumns != null) { - for (int i = 0; i < iSize; i++) - { - selections[i] = seqs[i].getSequenceAsString(start, end); - } + result += cursor.findRegionForVisColumn(column).getHiddenSoFar(); } - return selections; + return result; } finally { LOCK.readLock().unlock(); @@ -901,91 +755,56 @@ public class HiddenColumns } /** - * Locate the first and last position visible for this sequence. if seq isn't - * visible then return the position of the left and right of the hidden - * boundary region, and the corresponding alignment column indices for the - * extent of the sequence + * 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 + * index of the next visible column on the left will be returned (or 0 if + * there is no visible column on the left) * - * @param seq - * @return int[] { visible start, visible end, first seqpos, last seqpos, - * alignment index for seq start, alignment index for seq end } + * @param hiddenColumn + * the column index in the full alignment including hidden columns + * @return the position of the column in the visible alignment */ - public int[] locateVisibleBoundsOfSequence(SequenceI seq) + public int absoluteToVisibleColumn(int hiddenColumn) { try { LOCK.readLock().lock(); - int fpos = seq.getStart(); - int lpos = seq.getEnd(); - int start = 0; - - if (hiddenColumns == null || hiddenColumns.size() == 0) - { - int ifpos = seq.findIndex(fpos) - 1; - int ilpos = seq.findIndex(lpos) - 1; - return new int[] { ifpos, ifpos, ilpos }; - } + int result = hiddenColumn; - // Simply walk along the sequence whilst watching for hidden column - // boundaries - List regions = getHiddenRegions(); - int spos = fpos; - int lastvispos = -1; - int rcount = 0; - int hideStart = seq.getLength(); - int hideEnd = -1; - int visPrev = 0; - int visNext = 0; - int firstP = -1; - int lastP = -1; - boolean foundStart = false; - for (int p = 0, pLen = seq.getLength(); spos <= seq.getEnd() - && p < pLen; p++) + if (hiddenColumns != null) { - if (!Comparison.isGap(seq.getCharAt(p))) + HiddenCursorPosition cursorPos = cursor + .findRegionForColumn(hiddenColumn); + 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()) { - // keep track of first/last column - // containing sequence data regardless of visibility - if (firstP == -1) - { - firstP = p; - } - lastP = p; - // update hidden region start/end - while (hideEnd < p && rcount < regions.size()) - { - int[] region = regions.get(rcount++); - 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) + int[] region = hiddenColumns.get(index); + if (hiddenColumn >= region[0] && hiddenColumn <= region[1]) { - if (!foundStart) + // actually col is hidden, return region[0]-1 + // unless region[0]==0 in which case return 0 + if (region[0] == 0) { - fpos = spos; - start = p; - foundStart = true; + result = 0; + } + else + { + result = region[0] - 1 - hiddenBeforeCol; } - lastvispos = p; - lpos = spos; } - // look for next sequence position - spos++; } } - if (foundStart) - { - return new int[] { findColumnPosition(start), firstP, lastP }; - } - // otherwise, sequence was completely hidden - return new int[] { visPrev, firstP, lastP }; + + return result; // return the shifted position after removing hidden + // columns. } finally { LOCK.readLock().unlock(); @@ -993,120 +812,50 @@ public class HiddenColumns } /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). - * - * @param alignmentAnnotation - */ - public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) - { - makeVisibleAnnotation(-1, -1, alignmentAnnotation); - } - - /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). + * 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. * - * @param start - * remove any annotation to the right of this column - * @param end - * remove any annotation to the left of this column - * @param alignmentAnnotation - * the annotation to operate on + * @param visibleDistance + * the number of visible columns to offset by + * @param startColumn + * the column to start from + * @return the position of the column in the visible alignment */ - public void makeVisibleAnnotation(int start, int end, - AlignmentAnnotation alignmentAnnotation) + public int subtractVisibleColumns(int visibleDistance, int startColumn) { try { LOCK.readLock().lock(); - if (alignmentAnnotation.annotations == null) - { - return; - } - if (start == end && end == -1) - { - start = 0; - end = alignmentAnnotation.annotations.length; - } - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - // then mangle the alignmentAnnotation annotation array - Vector annels = new Vector<>(); - Annotation[] els = null; - List regions = getHiddenRegions(); - int blockStart = start; - int blockEnd = end; - int[] region; - int hideStart; - int hideEnd; - int w = 0; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } + int distance = visibleDistance; - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); + // in case startColumn is in a hidden region, move it to the left + int start = visibleToAbsoluteColumn(absoluteToVisibleColumn(startColumn)); - if (blockStart > blockEnd) - { - break; - } + Iterator it = new ReverseRegionsIterator(0, start, + hiddenColumns); - annels.addElement(els = new Annotation[blockEnd - blockStart]); - System.arraycopy(alignmentAnnotation.annotations, blockStart, els, - 0, els.length); - w += els.length; - blockStart = hideEnd + 1; - blockEnd = end; - } + while (it.hasNext() && (distance > 0)) + { + int[] region = it.next(); - if (end > blockStart) + if (start > region[1]) { - annels.addElement(els = new Annotation[end - blockStart + 1]); - if ((els.length - + blockStart) <= alignmentAnnotation.annotations.length) + // subtract the gap to right of region from distance + if (start - region[1] <= distance) { - // copy just the visible segment of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, els.length); + distance -= start - region[1]; + start = region[0] - 1; } else { - // copy to the end of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, - (alignmentAnnotation.annotations.length - blockStart)); + start = start - distance; + distance = 0; } - w += els.length; - } - if (w == 0) - { - return; - } - - alignmentAnnotation.annotations = new Annotation[w]; - w = 0; - - for (Annotation[] chnk : annels) - { - System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, - chnk.length); - w += chnk.length; } } - else - { - alignmentAnnotation.restrict(start, end); - } + return start - distance; + } finally { LOCK.readLock().unlock(); @@ -1114,15 +863,41 @@ public class HiddenColumns } /** + * This method returns the rightmost limit of a region of an alignment with + * hidden columns. In otherwords, the next hidden column. * - * @return true if there are columns hidden + * @param alPos + * the absolute (visible) alignmentPosition to find the next hidden + * column for + * @return the index of the next hidden column, or alPos if there is no next + * hidden column */ - public boolean hasHiddenColumns() + public int getHiddenBoundaryRight(int alPos) { try { LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 0; + if (hiddenColumns != null) + { + int index = cursor.findRegionForColumn(alPos).getRegionIndex(); + if (index < hiddenColumns.size()) + { + int[] region = hiddenColumns.get(index); + if (alPos < region[0]) + { + return region[0]; + } + else if ((alPos <= region[1]) + && (index + 1 < hiddenColumns.size())) + { + // alPos is within a hidden region, return the next one + // if there is one + region = hiddenColumns.get(index + 1); + return region[0]; + } + } + } + return alPos; } finally { LOCK.readLock().unlock(); @@ -1130,418 +905,348 @@ public class HiddenColumns } /** + * This method returns the leftmost limit of a region of an alignment with + * hidden columns. In otherwords, the previous hidden column. * - * @return true if there are more than one set of columns hidden + * @param alPos + * the absolute (visible) alignmentPosition to find the previous + * hidden column for */ - public boolean hasManyHiddenColumns() + public int getHiddenBoundaryLeft(int alPos) { try { LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 1; - } finally - { - LOCK.readLock().unlock(); - } - } - /** - * mark the columns corresponding to gap characters as hidden in the column - * selection - * - * @param sr - */ - public void hideInsertionsFor(SequenceI sr) - { - try - { - LOCK.writeLock().lock(); - List inserts = sr.getInsertions(); - for (int[] r : inserts) + if (hiddenColumns != null) { - hideColumns(r[0], r[1]); + int index = cursor.findRegionForColumn(alPos).getRegionIndex(); + + if (index > 0) + { + int[] region = hiddenColumns.get(index - 1); + return region[1]; + } } + return alPos; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } + /** - * Unhides, and adds to the selection list, all hidden columns + * Answers if a column in the alignment is visible + * + * @param column + * absolute position of column in the alignment + * @return true if column is visible */ - public void revealAllHiddenColumns(ColumnSelection sel) + public boolean isVisible(int column) { try { - LOCK.writeLock().lock(); - if (hiddenColumns != null) + LOCK.readLock().lock(); + + int regionindex = cursor.findRegionForColumn(column).getRegionIndex(); + if (regionindex > -1 && regionindex < hiddenColumns.size()) { - for (int i = 0; i < hiddenColumns.size(); i++) + int[] region = hiddenColumns.get(regionindex); + // already know that column <= region[1] as cursor returns containing + // region or region to right + if (column >= region[0]) { - int[] region = hiddenColumns.get(i); - for (int j = region[0]; j < region[1] + 1; j++) - { - sel.addElement(j); - } + return false; } } + return true; - hiddenColumns = null; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * Reveals, and marks as selected, the hidden column range with the given - * start column + * 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 */ - public void revealHiddenColumns(int start, ColumnSelection sel) + public String[] getVisibleSequenceStrings(int start, int end, + SequenceI[] seqs) { try { - LOCK.writeLock().lock(); - for (int i = 0; i < hiddenColumns.size(); i++) + LOCK.readLock().lock(); + int iSize = seqs.length; + String[] selections = new String[iSize]; + if (hiddenColumns != null && hiddenColumns.size() > 0) { - int[] region = hiddenColumns.get(i); - if (start == region[0]) + for (int i = 0; i < iSize; i++) { - for (int j = region[0]; j < region[1] + 1; j++) + StringBuffer visibleSeq = new StringBuffer(); + + Iterator blocks = new VisibleContigsIterator(start, + end + 1, hiddenColumns); + + while (blocks.hasNext()) { - sel.addElement(j); + 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])); + } } - hiddenColumns.remove(region); - break; + selections[i] = visibleSeq.toString(); } } - if (hiddenColumns.size() == 0) + else { - hiddenColumns = null; + for (int i = 0; i < iSize; i++) + { + selections[i] = seqs[i].getSequenceAsString(start, end); + } } + + return selections; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * removes intersection of position,length ranges in deletions from the - * start,end regions marked in intervals. + * 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 shifts - * @param intervals - * @return + * @param seq + * sequence to find position for + * @return visible start position */ - private boolean pruneIntervalList(final List shifts, - ArrayList intervals) + public int locateVisibleStartOfSequence(SequenceI seq) { - boolean pruned = false; - int i = 0; - int j = intervals.size() - 1; - int s = 0; - int t = shifts.size() - 1; - int[] hr = intervals.get(i); - int[] sr = shifts.get(s); - while (i <= j && s <= t) - { - boolean trailinghn = hr[1] >= sr[0]; - if (!trailinghn) + try + { + LOCK.readLock().lock(); + int start = 0; + + if (hiddenColumns == null || hiddenColumns.size() == 0) { - if (i < j) - { - hr = intervals.get(++i); - } - else - { - i++; - } - continue; - } - int endshift = sr[0] + sr[1]; // deletion ranges - -ve means an insert - if (endshift < hr[0] || endshift < sr[0]) - { // leadinghc disjoint or not a deletion - if (s < t) - { - sr = shifts.get(++s); - } - else - { - s++; - } - continue; + return seq.findIndex(seq.getStart()) - 1; } - boolean leadinghn = hr[0] >= sr[0]; - boolean leadinghc = hr[0] < endshift; - boolean trailinghc = hr[1] < endshift; - if (leadinghn) + + // 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++) { - if (trailinghc) - { // deleted hidden region. - intervals.remove(i); - pruned = true; - j--; - if (i <= j) - { - hr = intervals.get(i); - } - continue; - } - if (leadinghc) + // 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()) { - hr[0] = endshift; // clip c terminal region - leadinghn = !leadinghn; - pruned = true; + int[] region = regions.next(); + visPrev = visNext; + visNext += region[0] - visPrev; + hideStart = region[0]; + hideEnd = region[1]; } - } - if (!leadinghn) - { - if (trailinghc) + if (hideEnd < p) { - if (trailinghn) - { - hr[1] = sr[0] - 1; - pruned = true; - } + hideStart = seq.getLength(); } - else + // update visible boundary for sequence + if (p < hideStart) { - // sr contained in hr - if (s < t) - { - sr = shifts.get(++s); - } - else - { - s++; - } - continue; + start = p; + foundStart = true; } } - } - return pruned; // true if any interval was removed or modified by - // operations. - } - /** - * remove any hiddenColumns or selected columns and shift remaining based on a - * series of position, range deletions. - * - * @param deletions - */ - public void pruneDeletions(List shifts) - { - try - { - LOCK.writeLock().lock(); - // delete any intervals intersecting. - if (hiddenColumns != null) + if (foundStart) { - pruneIntervalList(shifts, hiddenColumns); - if (hiddenColumns != null && hiddenColumns.size() == 0) - { - hiddenColumns = null; - } + return absoluteToVisibleColumn(start); } + // otherwise, sequence was completely hidden + return visPrev; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * Add gaps into the sequences aligned to profileseq under the given - * AlignmentView + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). * - * @param profileseq - * @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. + * @param alignmentAnnotation */ - public static HiddenColumns propagateInsertions(SequenceI profileseq, - AlignmentI al, AlignmentView input) + public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) { - 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; + if (alignmentAnnotation != null + && alignmentAnnotation.annotations != null) + { + makeVisibleAnnotation(0, alignmentAnnotation.annotations.length, + alignmentAnnotation); + } } /** + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). * - * @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 + * @param start + * remove any annotation to the right of this column + * @param end + * remove any annotation to the left of this column + * @param alignmentAnnotation + * the annotation to operate on */ - private void propagateInsertions(SequenceI profileseq, AlignmentI al, - SequenceI origseq) + public void makeVisibleAnnotation(int start, int end, + AlignmentAnnotation alignmentAnnotation) { - char gc = al.getGapCharacter(); - // recover mapping between sequence's non-gap positions and positions - // mapping to view. - pruneDeletions(ShiftList.parseMap(origseq.gapMap())); - int[] viscontigs = getVisibleContigs(0, profileseq.getLength()); - int spos = 0; - int offset = 0; - - // add profile to visible contigs - for (int v = 0; v < viscontigs.length; v += 2) + try { - if (viscontigs[v] > spos) + LOCK.readLock().lock(); + + int startFrom = start; + int endAt = end; + + if (alignmentAnnotation != null + && alignmentAnnotation.annotations != null) { - StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++) + if (hiddenColumns != null && hiddenColumns.size() > 0) { - sb.append(gc); + removeHiddenAnnotation(startFrom, endAt, alignmentAnnotation); } - for (int s = 0, ns = al.getHeight(); s < ns; s++) + else { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj != profileseq) - { - String sq = al.getSequenceAt(s).getSequenceAsString(); - if (sq.length() <= spos + offset) - { - // pad sequence - int diff = spos + offset - sq.length() - 1; - if (diff > 0) - { - // pad gaps - sq = sq + sb; - while ((diff = spos + offset - sq.length() - 1) > 0) - { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - 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, spos + offset) - + sb.toString() + sq.substring(spos + offset)); - } - } + alignmentAnnotation.restrict(startFrom, endAt); } - // offset+=sb.length(); } - spos = viscontigs[v + 1] + 1; - } - if ((offset + spos) < profileseq.getLength()) + } finally { - // pad the final region with gaps. - StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = profileseq.getLength() - spos - - offset; s < ns; s++) + 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()) { - sb.append(gc); + // copy just the visible segment of the annotation row + copylength = annotationLength; } - for (int s = 0, ns = al.getHeight(); s < ns; s++) + else { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj == profileseq) + if (annotationLength + block[0] <= alignmentAnnotation.annotations.length) { - continue; + // copy just the visible segment of the annotation row + copylength = annotationLength; } - String sq = sqobj.getSequenceAsString(); - // pad sequence - int diff = origseq.getLength() - sq.length(); - while (diff > 0) + else { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - if (diff >= sb.length()) - { - sq += sb.toString(); - } - else - { - char[] buf = new char[diff]; - sb.getChars(0, diff, buf, 0); - sq += buf.toString(); - } - diff = origseq.getLength() - sq.length(); + // 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; + } } } /** - * remove any hiddenColumns or selected columns and shift remaining based on a - * series of position, range deletions. * - * @param deletions + * @return true if there are columns hidden */ - private void pruneDeletions(ShiftList deletions) + public boolean hasHiddenColumns() { - if (deletions != null) + try { - final List shifts = deletions.getShifts(); - if (shifts != null && shifts.size() > 0) - { - pruneDeletions(shifts); + LOCK.readLock().lock(); - // and shift the rest. - this.compensateForEdits(deletions); - } + // 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 != null && hiddenColumns.size() > 0; + } finally + { + LOCK.readLock().unlock(); } } /** - * Adjust hidden column boundaries based on a series of column additions or - * deletions in visible regions. * - * @param shiftrecord - * @return + * @return true if there is more than one hidden column region */ - private ShiftList compensateForEdits(ShiftList shiftrecord) + public boolean hasMultiHiddenColumnRegions() { - if (shiftrecord != null) + try { - final List shifts = shiftrecord.getShifts(); - if (shifts != null && shifts.size() > 0) - { - int shifted = 0; - for (int i = 0, j = shifts.size(); i < j; i++) - { - int[] sh = shifts.get(i); - compensateForDelEdits(shifted + sh[0], sh[1]); - shifted -= sh[1]; - } - } - return shiftrecord.getInverse(); + LOCK.readLock().lock(); + return hiddenColumns != null && hiddenColumns.size() > 1; + } finally + { + LOCK.readLock().unlock(); } - return null; } + /** * Returns a hashCode built from hidden column ranges */ @@ -1552,13 +1257,12 @@ public class HiddenColumns { LOCK.readLock().lock(); int hashCode = 1; - if (hiddenColumns != null) + Iterator it = hiddenColumns.iterator(); + while (it.hasNext()) { - for (int[] hidden : hiddenColumns) - { - hashCode = 31 * hashCode + hidden[0]; - hashCode = 31 * hashCode + hidden[1]; - } + int[] hidden = it.next(); + hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; } return hashCode; } finally @@ -1585,6 +1289,8 @@ public class HiddenColumns lastSet = inserts.nextClearBit(firstSet); hideColumns(firstSet, lastSet - 1); } + cursor.resetCursor(hiddenColumns); + numColumns = 0; } finally { LOCK.writeLock().unlock(); @@ -1605,8 +1311,10 @@ public class HiddenColumns { return; } - for (int[] range : hiddenColumns) + Iterator it = hiddenColumns.iterator(); + while (it.hasNext()) { + int[] range = it.next(); inserts.set(range[0], range[1] + 1); } } finally @@ -1639,13 +1347,15 @@ public class HiddenColumns return new int[] { startPos, endPos }; } - for (int[] hiddenCol : hiddenColumns) + Iterator it = hiddenColumns.iterator(); + while (it.hasNext()) { - lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange; - higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange; + int[] range = it.next(); + lowestRange = (range[0] <= startPos) ? range : lowestRange; + higestRange = (range[1] >= endPos) ? range : higestRange; } - if (lowestRange[0] == -1 && lowestRange[1] == -1) + if (lowestRange[0] == -1) // includes (lowestRange[1] == -1) { startPos = alignmentStartEnd[0]; } @@ -1654,7 +1364,7 @@ public class HiddenColumns startPos = lowestRange[1] + 1; } - if (higestRange[0] == -1 && higestRange[1] == -1) + if (higestRange[0] == -1) // includes (higestRange[1] == -1) { endPos = alignmentStartEnd[1]; } @@ -1667,7 +1377,6 @@ public class HiddenColumns { LOCK.readLock().unlock(); } - } /** @@ -1682,25 +1391,156 @@ public class HiddenColumns try { LOCK.readLock().lock(); - int adjres = adjustForHiddenColumns(res); + int adjres = visibleToAbsoluteColumn(res); int[] reveal = null; + if (hiddenColumns != null) { - for (int[] region : hiddenColumns) + // look for a region ending just before adjres + int regionindex = cursor.findRegionForColumn(adjres - 1) + .getRegionIndex(); + if (regionindex < hiddenColumns.size() + && hiddenColumns.get(regionindex)[1] == adjres - 1) { - if (adjres + 1 == region[0] || adjres - 1 == region[1]) - { - reveal = region; - break; - } + reveal = hiddenColumns.get(regionindex); + } + // check if the region ends just after adjres + else if (regionindex < hiddenColumns.size() + && hiddenColumns.get(regionindex)[0] == adjres + 1) + { + reveal = hiddenColumns.get(regionindex); } } return reveal; + + } finally + { + LOCK.readLock().unlock(); + } + } + + /** + * Return an iterator over the hidden regions + */ + public Iterator iterator() + { + try + { + LOCK.readLock().lock(); + return new HiddenColsIterator(hiddenColumns); + } finally + { + LOCK.readLock().unlock(); + } + } + + /** + * Return a bounded iterator over the hidden regions + * + * @param start + * position to start from (inclusive, absolute column position) + * @param end + * position to end at (inclusive, absolute column position) + * @return + */ + public Iterator getBoundedIterator(int start, int end) + { + try + { + LOCK.readLock().lock(); + return new HiddenColsIterator(start, end, hiddenColumns); + } finally + { + LOCK.readLock().unlock(); + } + } + + /** + * Return a bounded iterator over the *visible* start positions of hidden + * regions + * + * @param start + * position to start from (inclusive, visible column position) + * @param end + * position to end at (inclusive, visible column position) + */ + public Iterator getBoundedStartIterator(int start, int end) + { + try + { + LOCK.readLock().lock(); + + // get absolute position of column in alignment + 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 + // (absoluteStart-1), then if absoluteStart is the start of a visible + // region we'll get the cursor pointing to the region before, which is + // what we want + HiddenCursorPosition pos = cursor + .findRegionForColumn(absoluteStart - 1); + + return new BoundedStartRegionIterator(pos, start, end, + hiddenColumns); } finally { LOCK.readLock().unlock(); } } + /** + * Return an iterator over visible *columns* (not regions) between the given + * start and end boundaries + * + * @param start + * first column (inclusive) + * @param end + * last column (inclusive) + */ + public Iterator getVisibleColsIterator(int start, int end) + { + try + { + LOCK.readLock().lock(); + return new VisibleColsIterator(start, end, hiddenColumns); + } finally + { + LOCK.readLock().unlock(); + } + } + + /** + * return an iterator over visible segments between the given start and end + * boundaries + * + * @param start + * first column, inclusive from 0 + * @param end + * last column - not inclusive + * @param useVisibleCoords + * if true, start and end are visible column positions, not absolute + * positions* + */ + public Iterator getVisContigsIterator(int start, int end, + boolean useVisibleCoords) + { + int adjstart = start; + int adjend = end; + if (useVisibleCoords) + { + adjstart = visibleToAbsoluteColumn(start); + adjend = visibleToAbsoluteColumn(end); + } + + try + { + LOCK.readLock().lock(); + return new VisibleContigsIterator(adjstart, adjend, hiddenColumns); + } finally + { + LOCK.readLock().unlock(); + } + } }