X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=402ea2542a8a94d7b9c7550bac4457f7a51ee1e6;hb=6f39eb8080a04854744d9f167104a525b4a38520;hp=18afa5b802c10382e7e0b344999020f91362ec57;hpb=3a4b2f8436ac8f23d1681a4782209ae0fbb37fdd;p=jalview.git

diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java
index 18afa5b..402ea25 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,13 +33,13 @@ 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*
  * 
@@ -46,7 +47,20 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
  * 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
 {
@@ -69,7 +83,7 @@ public class HiddenColumns
    * list of hidden column [start, end] ranges; the list is maintained in
    * ascending start column order
    */
-  private List<int[]> hiddenColumns;
+  private List<int[]> hiddenColumns = new ArrayList<>();
 
   /**
    * Constructor
@@ -78,14 +92,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
    * 
@@ -94,29 +100,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<int[]> 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);
   }
 
   /**
@@ -141,7 +125,6 @@ public class HiddenColumns
       LOCK.writeLock().lock();
       if (copy != null)
       {
-        hiddenColumns = new ArrayList<>();
         numColumns = 0;
         Iterator<int[]> it = copy.getBoundedIterator(start, end);
         while (it.hasNext())
@@ -157,7 +140,7 @@ public class HiddenColumns
             numColumns += region[1] - region[0] + 1;
           }
         }
-        cursor.resetCursor(hiddenColumns);
+        cursor = new HiddenColumnsCursor(hiddenColumns);
       }
     } finally
     {
@@ -175,28 +158,14 @@ 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);
@@ -239,17 +208,15 @@ 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);
+      cursor = new HiddenColumnsCursor(hiddenColumns, previndex,
+              prevHiddenCount);
 
       // reset the number of columns so they will be recounted
       numColumns = 0;
 
     } finally
     {
-      if (!wasAlreadyLocked)
-      {
-        LOCK.writeLock().unlock();
-      }
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -312,9 +279,9 @@ public class HiddenColumns
         }
         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();
+        // in theory hiddenColumns.subList(i + 1, i + 2).clear() is faster than
+        // hiddenColumns.remove(i+1) but benchmarking results a bit ambivalent
+        hiddenColumns.remove(i + 1);
       }
       added = true;
     }
@@ -322,22 +289,20 @@ public class HiddenColumns
   }
 
   /**
-   * 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<int[]> ranges)
   {
     try
     {
       LOCK.writeLock().lock();
-      List<int[]> inserts = sr.getInsertions();
-      for (int[] r : inserts)
+      for (int[] r : ranges)
       {
         hideColumns(r[0], r[1]);
       }
-      cursor.resetCursor(hiddenColumns);
+      cursor = new HiddenColumnsCursor(hiddenColumns);
       numColumns = 0;
     } finally
     {
@@ -353,21 +318,18 @@ public class HiddenColumns
     try
     {
       LOCK.writeLock().lock();
-      if (hiddenColumns != null)
+
+      for (int[] region : hiddenColumns)
       {
-        Iterator<int[]> 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();
@@ -389,7 +351,7 @@ public class HiddenColumns
     {
       LOCK.writeLock().lock();
 
-      if (hiddenColumns != null)
+      if (!hiddenColumns.isEmpty())
       {
         int regionIndex = cursor.findRegionForColumn(start)
                 .getRegionIndex();
@@ -410,7 +372,6 @@ public class HiddenColumns
 
             if (hiddenColumns.isEmpty())
             {
-              hiddenColumns = null;
               numColumns = 0;
             }
             else
@@ -428,172 +389,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.hideColumns(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<int[]> regions = hiddenColumns.iterator();
-      List<int[]> 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]<between>reg0[1]<delimiter>reg1[0]<between>reg1[1] ... regn[1]
    * 
@@ -609,20 +404,22 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
       StringBuilder regionBuilder = new StringBuilder();
-      if (hiddenColumns != null)
+
+      boolean first = true;
+      for (int[] range : hiddenColumns)
       {
-        Iterator<int[]> 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
     {
@@ -641,15 +438,13 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
 
-      if (numColumns == 0 && hiddenColumns != null)
+      if (numColumns == 0)
       {
         // numColumns is out of date, so recalculate
         int size = 0;
 
-        Iterator<int[]> it = hiddenColumns.iterator();
-        while (it.hasNext())
+        for (int[] range : hiddenColumns)
         {
-          int[] range = it.next();
           size += range[1] - range[0] + 1;
         }
 
@@ -673,12 +468,7 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      int num = 0;
-      if (hasHiddenColumns())
-      {
-        num = hiddenColumns.size();
-      }
-      return num;
+      return hiddenColumns.size();
     } finally
     {
       LOCK.readLock().unlock();
@@ -701,28 +491,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<int[]> it = hiddenColumns.iterator();
+      Iterator<int[]> it = this.iterator();
       Iterator<int[]> 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();
@@ -743,7 +528,7 @@ public class HiddenColumns
       LOCK.readLock().lock();
       int result = column;
 
-      if (hiddenColumns != null)
+      if (!hiddenColumns.isEmpty())
       {
         result += cursor.findRegionForVisColumn(column).getHiddenSoFar();
       }
@@ -772,7 +557,7 @@ public class HiddenColumns
       LOCK.readLock().lock();
       int result = hiddenColumn;
 
-      if (hiddenColumns != null)
+      if (!hiddenColumns.isEmpty())
       {
         HiddenCursorPosition cursorPos = cursor
                 .findRegionForColumn(hiddenColumn);
@@ -814,48 +599,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 <visibleDistance> 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 = visibleToAbsoluteColumn(absoluteToVisibleColumn(startColumn));
-
-      Iterator<int[]> 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
     {
@@ -873,15 +635,21 @@ 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())
+
+        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])
@@ -906,38 +674,6 @@ public class HiddenColumns
   }
 
   /**
-   * This method returns the leftmost limit of a region of an alignment with
-   * hidden columns. In otherwords, the previous hidden column.
-   * 
-   * @param alPos
-   *          the absolute (visible) alignmentPosition to find the previous
-   *          hidden column for
-   */
-  public int getHiddenBoundaryLeft(int alPos)
-  {
-    try
-    {
-      LOCK.readLock().lock();
-
-      if (hiddenColumns != null)
-      {
-        int index = cursor.findRegionForColumn(alPos).getRegionIndex();
-
-        if (index > 0)
-        {
-          int[] region = hiddenColumns.get(index - 1);
-          return region[1];
-        }
-      }
-      return alPos;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-
-  /**
    * Answers if a column in the alignment is visible
    * 
    * @param column
@@ -970,249 +706,6 @@ 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
-   */
-  public String[] getVisibleSequenceStrings(int start, int end,
-          SequenceI[] seqs)
-  {
-    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<int[]> 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;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-  /**
-   * 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
-   */
-  public int locateVisibleStartOfSequence(SequenceI seq)
-  {
-    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<int[]> 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;
-        }
-      }
-
-      if (foundStart)
-      {
-        return absoluteToVisibleColumn(start);
-      }
-      // otherwise, sequence was completely hidden
-      return visPrev;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-  /**
-   * delete any columns in alignmentAnnotation that are hidden (including
-   * sequence associated annotation).
-   * 
-   * @param alignmentAnnotation
-   */
-  public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation)
-  {
-    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 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
-   */
-  public void makeVisibleAnnotation(int start, int end,
-          AlignmentAnnotation alignmentAnnotation)
-  {
-    try
-    {
-      LOCK.readLock().lock();
-
-      int startFrom = start;
-      int endAt = end;
-
-      if (alignmentAnnotation != null
-              && alignmentAnnotation.annotations != null)
-      {
-        if (hiddenColumns != null && hiddenColumns.size() > 0)
-        {
-          removeHiddenAnnotation(startFrom, endAt, alignmentAnnotation);
-        }
-        else
-        {
-          alignmentAnnotation.restrict(startFrom, endAt);
-        }
-      }
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-  private void removeHiddenAnnotation(int start, int end,
-          AlignmentAnnotation alignmentAnnotation)
-  {
-    // mangle the alignmentAnnotation annotation array
-    ArrayList<Annotation[]> annels = new ArrayList<>();
-    Annotation[] els = null;
-
-    int w = 0;
-    
-    Iterator<int[]> 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;
-      }
-    }
-  }
-
-  /**
    * 
    * @return true if there are columns hidden
    */
@@ -1224,7 +717,7 @@ public class HiddenColumns
 
       // 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;
+      return (!hiddenColumns.isEmpty());
     } finally
     {
       LOCK.readLock().unlock();
@@ -1240,7 +733,7 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      return hiddenColumns != null && hiddenColumns.size() > 1;
+      return !hiddenColumns.isEmpty() && hiddenColumns.size() > 1;
     } finally
     {
       LOCK.readLock().unlock();
@@ -1258,10 +751,9 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
       int hashCode = 1;
-      Iterator<int[]> it = hiddenColumns.iterator();
-      while (it.hasNext())
+
+      for (int[] hidden : hiddenColumns)
       {
-        int[] hidden = it.next();
         hashCode = HASH_MULTIPLIER * hashCode + hidden[0];
         hashCode = HASH_MULTIPLIER * hashCode + hidden[1];
       }
@@ -1276,7 +768,7 @@ public class HiddenColumns
    * Hide columns corresponding to the marked bits
    * 
    * @param inserts
-   *          - columns map to bits starting from zero
+   *          - columns mapped to bits starting from zero
    */
   public void hideColumns(BitSet inserts)
   {
@@ -1290,7 +782,7 @@ public class HiddenColumns
         lastSet = inserts.nextClearBit(firstSet);
         hideColumns(firstSet, lastSet - 1);
       }
-      cursor.resetCursor(hiddenColumns);
+      cursor = new HiddenColumnsCursor(hiddenColumns);
       numColumns = 0;
     } finally
     {
@@ -1299,28 +791,112 @@ public class HiddenColumns
   }
 
   /**
+   * Hide columns corresponding to the marked bits, within the range
+   * [start,end]. Entries in tohide which are outside [start,end] are ignored.
    * 
-   * @param inserts
-   *          BitSet where hidden columns will be marked
+   * @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 void markHiddenRegions(BitSet inserts)
+  public void hideColumns(BitSet tohide, int start, int end)
+  {
+    clearHiddenColumnsInRange(start, end);
+
+    // make sure only bits between start and end are set
+    if (!tohide.isEmpty())
+    {
+      tohide.clear(0, start);
+      tohide.clear(Math.min(end + 1, tohide.length() + 1),
+              tohide.length() + 1);
+    }
+
+    hideColumns(tohide);
+  }
+
+  /**
+   * Make all columns in the range [start,end] visible
+   * 
+   * @param start
+   *          start of range to show columns
+   * @param end
+   *          end of range to show columns
+   */
+  private void clearHiddenColumnsInRange(int start, int end)
   {
     try
     {
-      LOCK.readLock().lock();
-      if (hiddenColumns == null)
+      LOCK.writeLock().lock();
+      
+      if (!hiddenColumns.isEmpty())
       {
-        return;
+        HiddenCursorPosition pos = cursor.findRegionForColumn(start);
+        int index = pos.getRegionIndex();
+        int startindex = index; // first index in hiddenColumns to remove
+
+        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
+            region[1] = start - 1;
+            startindex++;
+          }
+        }
+
+        pos = cursor.findRegionForColumn(end);
+        index = pos.getRegionIndex();
+        int endindex = index - 1; // last index in hiddenColumns to remove
+
+        if (index != -1 && index != hiddenColumns.size())
+        {
+          // regionIndex is the region which either contains end
+          // or lies to the right of end
+          int[] region = hiddenColumns.get(index);
+          if (region[0] <= end && region[1] > end)
+          {
+            // region contains end, truncate so that it starts just after end
+            region[0] = end + 1;
+          }
+        }
+
+        hiddenColumns.subList(startindex, endindex + 1).clear();
+        cursor = new HiddenColumnsCursor(hiddenColumns);
+        numColumns = 0;
       }
-      Iterator<int[]> it = hiddenColumns.iterator();
-      while (it.hasNext())
+    } finally
+    {
+      LOCK.writeLock().unlock();
+    }
+  }
+
+  /**
+   * 
+   * @param updates
+   *          BitSet where hidden columns will be marked
+   */
+  protected void andNot(BitSet updates)
+  {
+    try
+    {
+      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();
     }
   }
 
@@ -1336,44 +912,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 };
+      int firstVisible = 0;
+      int lastVisible = width - 1;
 
-      if (hiddenColumns == null)
+      if (!hiddenColumns.isEmpty())
       {
-        return new int[] { startPos, endPos };
-      }
-
-      Iterator<int[]> it = hiddenColumns.iterator();
-      while (it.hasNext())
-      {
-        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();
@@ -1397,7 +956,7 @@ public class HiddenColumns
 
       int[] reveal = null;
 
-      if (hiddenColumns != null)
+      if (!hiddenColumns.isEmpty())
       {
         // look for a region ending just before adjres
         int regionindex = cursor.findRegionForColumn(adjres - 1)
@@ -1525,7 +1084,8 @@ public class HiddenColumns
    *          if true, start and end are visible column positions, not absolute
    *          positions*
    */
-  public Iterator<int[]> getVisContigsIterator(int start, int end,
+  public VisibleContigsIterator getVisContigsIterator(int start,
+          int end,
           boolean useVisibleCoords)
   {
     int adjstart = start;