X-Git-Url: http://source.jalview.org/gitweb/?p=jalview.git;a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignmentAnnotation.java;h=0f418508abdd229bde007483606a24e5b448a996;hp=7990a5cfb6afb30796bdb60f1e1ca6945d1f0611;hb=0ae965fc73680bdc69b06986c060ff17342c4787;hpb=4ff572f7cf17f5ca9c23f82bbe41005af8af55cc

diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java
index 7990a5c..0f41850 100755
--- a/src/jalview/datamodel/AlignmentAnnotation.java
+++ b/src/jalview/datamodel/AlignmentAnnotation.java
@@ -20,18 +20,21 @@
  */
 package jalview.datamodel;
 
-import jalview.analysis.Rna;
-import jalview.analysis.SecStrConsensus.SimpleBP;
-import jalview.analysis.WUSSParseException;
-
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import jalview.analysis.Rna;
+import jalview.analysis.SecStrConsensus.SimpleBP;
+import jalview.analysis.WUSSParseException;
+
 /**
  * DOCUMENT ME!
  * 
@@ -79,7 +82,7 @@ public class AlignmentAnnotation
   /** Array of annotations placed in the current coordinate system */
   public Annotation[] annotations;
 
-  public ArrayList<SimpleBP> bps = null;
+  public List<SimpleBP> bps = null;
 
   /**
    * RNA secondary structure contact positions
@@ -96,14 +99,13 @@ public class AlignmentAnnotation
    * Updates the _rnasecstr field Determines the positions that base pair and
    * the positions of helices based on secondary structure from a Stockholm file
    * 
-   * @param RNAannot
+   * @param rnaAnnotation
    */
-  private void _updateRnaSecStr(CharSequence RNAannot)
+  private void _updateRnaSecStr(CharSequence rnaAnnotation)
   {
     try
     {
-      _rnasecstr = Rna.GetBasePairs(RNAannot);
-      bps = Rna.GetModeleBP(RNAannot);
+      _rnasecstr = Rna.getHelixMap(rnaAnnotation);
       invalidrnastruc = -1;
     } catch (WUSSParseException px)
     {
@@ -114,8 +116,6 @@ public class AlignmentAnnotation
     {
       return;
     }
-    Rna.HelixMap(_rnasecstr);
-    // setRNAStruc(RNAannot);
 
     if (_rnasecstr != null && _rnasecstr.length > 0)
     {
@@ -166,14 +166,84 @@ public class AlignmentAnnotation
   }
 
   /**
+   * Get the RNA Secondary Structure SequenceFeature Array if present
+   */
+  public SequenceFeature[] getRnaSecondaryStructure()
+  {
+    return this._rnasecstr;
+  }
+
+  /**
+   * Check the RNA Secondary Structure is equivalent to one in given
+   * AlignmentAnnotation param
+   */
+  public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that)
+  {
+    return rnaSecondaryStructureEquivalent(that, true);
+  }
+
+  public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that,
+          boolean compareType)
+  {
+    SequenceFeature[] thisSfArray = this.getRnaSecondaryStructure();
+    SequenceFeature[] thatSfArray = that.getRnaSecondaryStructure();
+    if (thisSfArray == null || thatSfArray == null)
+    {
+      return thisSfArray == null && thatSfArray == null;
+    }
+    if (thisSfArray.length != thatSfArray.length)
+    {
+      return false;
+    }
+    Arrays.sort(thisSfArray, new SFSortByEnd()); // probably already sorted
+                                                 // like this
+    Arrays.sort(thatSfArray, new SFSortByEnd()); // probably already sorted
+                                                 // like this
+    for (int i = 0; i < thisSfArray.length; i++)
+    {
+      SequenceFeature thisSf = thisSfArray[i];
+      SequenceFeature thatSf = thatSfArray[i];
+      if (compareType)
+      {
+        if (thisSf.getType() == null || thatSf.getType() == null)
+        {
+          if (thisSf.getType() == null && thatSf.getType() == null)
+          {
+            continue;
+          }
+          else
+          {
+            return false;
+          }
+        }
+        if (!thisSf.getType().equals(thatSf.getType()))
+        {
+          return false;
+        }
+      }
+      if (!(thisSf.getBegin() == thatSf.getBegin()
+              && thisSf.getEnd() == thatSf.getEnd()))
+      {
+        return false;
+      }
+    }
+    return true;
+
+  }
+
+  /**
    * map of positions in the associated annotation
    */
   private Map<Integer, Annotation> sequenceMapping;
 
-  /** DOCUMENT ME!! */
+  /**
+   * lower range for quantitative data
+   */
   public float graphMin;
 
-  /** DOCUMENT ME!! */
+  /**
+   * Upper range for quantitative data
+   */
   public float graphMax;
 
   /**
@@ -240,19 +310,6 @@ public class AlignmentAnnotation
 
   private boolean isrna;
 
-  /*
-   * (non-Javadoc)
-   * 
-   * @see java.lang.Object#finalize()
-   */
-  @Override
-  protected void finalize() throws Throwable
-  {
-    sequenceRef = null;
-    groupRef = null;
-    super.finalize();
-  }
-
   public static int getGraphValueFromString(String string)
   {
     if (string.equalsIgnoreCase("BAR_GRAPH"))
@@ -269,12 +326,6 @@ public class AlignmentAnnotation
     }
   }
 
-  // JBPNote: what does this do ?
-  public void ConcenStru(CharSequence RNAannot) throws WUSSParseException
-  {
-    bps = Rna.GetModeleBP(RNAannot);
-  }
-
   /**
    * Creates a new AlignmentAnnotation object.
    * 
@@ -311,6 +362,7 @@ public class AlignmentAnnotation
     char firstChar = 0;
     for (int i = 0; i < annotations.length; i++)
     {
+      // DEBUG System.out.println(i + ": " + annotations[i]);
       if (annotations[i] == null)
       {
         continue;
@@ -318,27 +370,35 @@ public class AlignmentAnnotation
       if (annotations[i].secondaryStructure == 'H'
               || annotations[i].secondaryStructure == 'E')
       {
+        // DEBUG System.out.println( "/H|E/ '" +
+        // annotations[i].secondaryStructure + "'");
         hasIcons |= true;
       }
       else
       // Check for RNA secondary structure
       {
-        // System.out.println(annotations[i].secondaryStructure);
+        // DEBUG System.out.println( "/else/ '" +
+        // annotations[i].secondaryStructure + "'");
         // TODO: 2.8.2 should this ss symbol validation check be a function in
         // RNA/ResidueProperties ?
+        // allow for DSSP extended code:
+        // https://www.wikidoc.org/index.php/Secondary_structure#The_DSSP_code
+        // GHITEBS as well as C and X (for missing?)
         if (annotations[i].secondaryStructure == '('
                 || annotations[i].secondaryStructure == '['
                 || annotations[i].secondaryStructure == '<'
                 || annotations[i].secondaryStructure == '{'
                 || annotations[i].secondaryStructure == 'A'
-                || annotations[i].secondaryStructure == 'B'
-                || annotations[i].secondaryStructure == 'C'
+                // || annotations[i].secondaryStructure == 'B'
+                // || annotations[i].secondaryStructure == 'C'
                 || annotations[i].secondaryStructure == 'D'
-                || annotations[i].secondaryStructure == 'E'
+                // || annotations[i].secondaryStructure == 'E' // ambiguous on
+                // its own -- already checked above
                 || annotations[i].secondaryStructure == 'F'
-                || annotations[i].secondaryStructure == 'G'
-                || annotations[i].secondaryStructure == 'H'
-                || annotations[i].secondaryStructure == 'I'
+                // || annotations[i].secondaryStructure == 'G'
+                // || annotations[i].secondaryStructure == 'H' // ambiguous on
+                // its own -- already checked above
+                // || annotations[i].secondaryStructure == 'I'
                 || annotations[i].secondaryStructure == 'J'
                 || annotations[i].secondaryStructure == 'K'
                 || annotations[i].secondaryStructure == 'L'
@@ -348,12 +408,12 @@ public class AlignmentAnnotation
                 || annotations[i].secondaryStructure == 'P'
                 || annotations[i].secondaryStructure == 'Q'
                 || annotations[i].secondaryStructure == 'R'
-                || annotations[i].secondaryStructure == 'S'
-                || annotations[i].secondaryStructure == 'T'
+                // || annotations[i].secondaryStructure == 'S'
+                // || annotations[i].secondaryStructure == 'T'
                 || annotations[i].secondaryStructure == 'U'
                 || annotations[i].secondaryStructure == 'V'
                 || annotations[i].secondaryStructure == 'W'
-                || annotations[i].secondaryStructure == 'X'
+                // || annotations[i].secondaryStructure == 'X'
                 || annotations[i].secondaryStructure == 'Y'
                 || annotations[i].secondaryStructure == 'Z')
         {
@@ -375,49 +435,25 @@ public class AlignmentAnnotation
         firstChar = annotations[i].displayCharacter.charAt(0);
         // check to see if it looks like a sequence or is secondary structure
         // labelling.
-        if (annotations[i].secondaryStructure != ' '
-                && !hasIcons
-                &&
-                // Uncomment to only catch case where
-                // displayCharacter==secondary
-                // Structure
-                // to correctly redisplay SS annotation imported from Stockholm,
-                // exported to JalviewXML and read back in again.
-                // &&
-                // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure
-                firstChar != ' '
-                && firstChar != '$'
-                && firstChar != 0xCE
-                && firstChar != '('
-                && firstChar != '['
-                && firstChar != '>'
-                && firstChar != '{'
-                && firstChar != 'A'
-                && firstChar != 'B'
-                && firstChar != 'C'
-                && firstChar != 'D'
-                && firstChar != 'E'
-                && firstChar != 'F'
-                && firstChar != 'G'
-                && firstChar != 'H'
-                && firstChar != 'I'
-                && firstChar != 'J'
-                && firstChar != 'K'
-                && firstChar != 'L'
-                && firstChar != 'M'
-                && firstChar != 'N'
-                && firstChar != 'O'
-                && firstChar != 'P'
-                && firstChar != 'Q'
-                && firstChar != 'R'
-                && firstChar != 'S'
-                && firstChar != 'T'
-                && firstChar != 'U'
-                && firstChar != 'V'
-                && firstChar != 'W'
-                && firstChar != 'X'
-                && firstChar != 'Y'
-                && firstChar != 'Z'
+        if (annotations[i].secondaryStructure != ' ' && !hasIcons &&
+        // Uncomment to only catch case where
+        // displayCharacter==secondary
+        // Structure
+        // to correctly redisplay SS annotation imported from Stockholm,
+        // exported to JalviewXML and read back in again.
+        // &&
+        // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure
+                firstChar != ' ' && firstChar != '$' && firstChar != 0xCE
+                && firstChar != '(' && firstChar != '[' && firstChar != '<'
+                && firstChar != '{' && firstChar != 'A' && firstChar != 'B'
+                && firstChar != 'C' && firstChar != 'D' && firstChar != 'E'
+                && firstChar != 'F' && firstChar != 'G' && firstChar != 'H'
+                && firstChar != 'I' && firstChar != 'J' && firstChar != 'K'
+                && firstChar != 'L' && firstChar != 'M' && firstChar != 'N'
+                && firstChar != 'O' && firstChar != 'P' && firstChar != 'Q'
+                && firstChar != 'R' && firstChar != 'S' && firstChar != 'T'
+                && firstChar != 'U' && firstChar != 'V' && firstChar != 'W'
+                && firstChar != 'X' && firstChar != 'Y' && firstChar != 'Z'
                 && firstChar != '-'
                 && firstChar < jalview.schemes.ResidueProperties.aaIndex.length)
         {
@@ -485,7 +521,7 @@ public class AlignmentAnnotation
       this(0, annotations.length);
     }
 
-    public AnnotCharSequence(int start, int end)
+    AnnotCharSequence(int start, int end)
     {
       offset = start;
       max = end;
@@ -508,12 +544,17 @@ public class AlignmentAnnotation
     {
       return ((index + offset < 0) || (index + offset) >= max
               || annotations[index + offset] == null
-              || (annotations[index + offset].secondaryStructure <= ' ') ? ' '
-              : annotations[index + offset].displayCharacter == null
-                      || annotations[index + offset].displayCharacter
-                              .length() == 0 ? annotations[index + offset].secondaryStructure
-                      : annotations[index + offset].displayCharacter
-                              .charAt(0));
+              || (annotations[index + offset].secondaryStructure <= ' ')
+                      ? ' '
+                      : annotations[index + offset].displayCharacter == null
+                              || annotations[index
+                                      + offset].displayCharacter
+                                      .length() == 0
+                                              ? annotations[index
+                                                      + offset].secondaryStructure
+                                              : annotations[index
+                                                      + offset].displayCharacter
+                                                      .charAt(0));
     }
 
     @Override
@@ -524,10 +565,15 @@ public class AlignmentAnnotation
 
       for (int i = offset; i < mx; i++)
       {
-        string[i] = (annotations[i] == null || (annotations[i].secondaryStructure <= 32)) ? ' '
-                : (annotations[i].displayCharacter == null
-                        || annotations[i].displayCharacter.length() == 0 ? annotations[i].secondaryStructure
-                        : annotations[i].displayCharacter.charAt(0));
+        string[i] = (annotations[i] == null
+                || (annotations[i].secondaryStructure <= 32))
+                        ? ' '
+                        : (annotations[i].displayCharacter == null
+                                || annotations[i].displayCharacter
+                                        .length() == 0
+                                                ? annotations[i].secondaryStructure
+                                                : annotations[i].displayCharacter
+                                                        .charAt(0));
       }
       return new String(string);
     }
@@ -593,6 +639,7 @@ public class AlignmentAnnotation
     if (annotations == null)
     {
       visible = false; // try to prevent renderer from displaying.
+      invalidrnastruc = -1;
       return; // this is a non-annotation row annotation - ie a sequence score.
     }
 
@@ -696,7 +743,7 @@ public class AlignmentAnnotation
     this.calcId = annotation.calcId;
     if (annotation.properties != null)
     {
-      properties = new HashMap<String, String>();
+      properties = new HashMap<>();
       for (Map.Entry<String, String> val : annotation.properties.entrySet())
       {
         properties.put(val.getKey(), val.getValue());
@@ -732,7 +779,7 @@ public class AlignmentAnnotation
       if (annotation.sequenceMapping != null)
       {
         Integer p = null;
-        sequenceMapping = new HashMap<Integer, Annotation>();
+        sequenceMapping = new HashMap<>();
         Iterator<Integer> pos = annotation.sequenceMapping.keySet()
                 .iterator();
         while (pos.hasNext())
@@ -802,8 +849,8 @@ public class AlignmentAnnotation
     Annotation[] temp = new Annotation[endRes - startRes + 1];
     if (startRes < annotations.length)
     {
-      System.arraycopy(annotations, startRes, temp, 0, endRes - startRes
-              + 1);
+      System.arraycopy(annotations, startRes, temp, 0,
+              endRes - startRes + 1);
     }
     if (sequenceRef != null)
     {
@@ -812,7 +859,7 @@ public class AlignmentAnnotation
       int epos = sequenceRef.findPosition(endRes);
       if (sequenceMapping != null)
       {
-        Map<Integer, Annotation> newmapping = new HashMap<Integer, Annotation>();
+        Map<Integer, Annotation> newmapping = new HashMap<>();
         Iterator<Integer> e = sequenceMapping.keySet().iterator();
         while (e.hasNext())
         {
@@ -862,6 +909,10 @@ public class AlignmentAnnotation
   @Override
   public String toString()
   {
+    if (annotations == null)
+    {
+      return "";
+    }
     StringBuilder buffer = new StringBuilder(256);
 
     for (int i = 0; i < annotations.length; i++)
@@ -935,7 +986,7 @@ public class AlignmentAnnotation
     {
       return;
     }
-    sequenceMapping = new HashMap<Integer, Annotation>();
+    sequenceMapping = new HashMap<>();
 
     int seqPos;
 
@@ -952,7 +1003,7 @@ public class AlignmentAnnotation
           seqPos = i + startRes;
         }
 
-        sequenceMapping.put(new Integer(seqPos), annotations[i]);
+        sequenceMapping.put(Integer.valueOf(seqPos), annotations[i]);
       }
     }
 
@@ -991,7 +1042,7 @@ public class AlignmentAnnotation
     {
       for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++)
       {
-        index = new Integer(a);
+        index = Integer.valueOf(a);
         Annotation annot = sequenceMapping.get(index);
         if (annot != null)
         {
@@ -1019,8 +1070,8 @@ public class AlignmentAnnotation
       {
         if (i + 1 < iSize)
         {
-          System.arraycopy(annotations, i + 1, annotations, i, iSize - i
-                  - 1);
+          System.arraycopy(annotations, i + 1, annotations, i,
+                  iSize - i - 1);
         }
         iSize--;
       }
@@ -1052,14 +1103,16 @@ public class AlignmentAnnotation
     {
       if (sequenceRef != null)
       {
-        boolean rIsDs = sequenceRef.getDatasetSequence() == null, tIsDs = sequenceI
-                .getDatasetSequence() == null;
+        boolean rIsDs = sequenceRef.getDatasetSequence() == null,
+                tIsDs = sequenceI.getDatasetSequence() == null;
         if (sequenceRef != sequenceI
-                && (rIsDs && !tIsDs && sequenceRef != sequenceI
-                        .getDatasetSequence())
-                && (!rIsDs && tIsDs && sequenceRef.getDatasetSequence() != sequenceI)
-                && (!rIsDs && !tIsDs && sequenceRef.getDatasetSequence() != sequenceI
-                        .getDatasetSequence())
+                && (rIsDs && !tIsDs
+                        && sequenceRef != sequenceI.getDatasetSequence())
+                && (!rIsDs && tIsDs
+                        && sequenceRef.getDatasetSequence() != sequenceI)
+                && (!rIsDs && !tIsDs
+                        && sequenceRef.getDatasetSequence() != sequenceI
+                                .getDatasetSequence())
                 && !sequenceRef.equals(sequenceI))
         {
           // if sequenceRef isn't intersecting with sequenceI
@@ -1141,14 +1194,14 @@ public class AlignmentAnnotation
    * @param colSel
    */
   public AlignmentAnnotation(AlignmentAnnotation alignmentAnnotation,
-          ColumnSelection colSel)
+          HiddenColumns hidden)
   {
     this(alignmentAnnotation);
     if (annotations == null)
     {
       return;
     }
-    colSel.makeVisibleAnnotation(this);
+    makeVisibleAnnotation(hidden);
   }
 
   public void setPadGaps(boolean padgaps, char gapchar)
@@ -1184,7 +1237,7 @@ public class AlignmentAnnotation
   {
     if (seqname && this.sequenceRef != null)
     {
-      int i = description.toLowerCase().indexOf("<html>");
+      int i = description.toLowerCase(Locale.ROOT).indexOf("<html>");
       if (i > -1)
       {
         // move the html tag to before the sequence reference.
@@ -1214,7 +1267,7 @@ public class AlignmentAnnotation
   /**
    * properties associated with the calcId
    */
-  protected Map<String, String> properties = new HashMap<String, String>();
+  protected Map<String, String> properties = new HashMap<>();
 
   /**
    * base colour for line graphs. If null, will be set automatically by
@@ -1254,20 +1307,22 @@ public class AlignmentAnnotation
       throw new Error(
               "liftOver currently not implemented for transfer of annotation between different types of seqeunce");
     }
-    boolean mapIsTo = (sp2sq != null) ? (sp2sq.getTo() == sq || sp2sq
-            .getTo() == sq.getDatasetSequence()) : false;
+    boolean mapIsTo = (sp2sq != null)
+            ? (sp2sq.getTo() == sq
+                    || sp2sq.getTo() == sq.getDatasetSequence())
+            : false;
 
     // TODO build a better annotation element map and get rid of annotations[]
-    Map<Integer, Annotation> mapForsq = new HashMap<Integer, Annotation>();
+    Map<Integer, Annotation> mapForsq = new HashMap<>();
     if (sequenceMapping != null)
     {
       if (sp2sq != null)
       {
         for (Entry<Integer, Annotation> ie : sequenceMapping.entrySet())
         {
-          Integer mpos = Integer.valueOf(mapIsTo ? sp2sq
-                  .getMappedPosition(ie.getKey()) : sp2sq.getPosition(ie
-                  .getKey()));
+          Integer mpos = Integer
+                  .valueOf(mapIsTo ? sp2sq.getMappedPosition(ie.getKey())
+                          : sp2sq.getPosition(ie.getKey()));
           if (mpos >= sq.getStart() && mpos <= sq.getEnd())
           {
             mapForsq.put(mpos, ie.getValue());
@@ -1306,13 +1361,12 @@ public class AlignmentAnnotation
    *       already
    */
   public void remap(SequenceI newref, HashMap<Integer, int[]> mapping,
-          int from, int to,
-          int idxoffset)
+          int from, int to, int idxoffset)
   {
     if (mapping != null)
     {
       Map<Integer, Annotation> old = sequenceMapping;
-      Map<Integer, Annotation> remap = new HashMap<Integer, Annotation>();
+      Map<Integer, Annotation> remap = new HashMap<>();
       int index = -1;
       for (int mp[] : mapping.values())
       {
@@ -1370,7 +1424,7 @@ public class AlignmentAnnotation
   {
     if (properties == null)
     {
-      properties = new HashMap<String, String>();
+      properties = new HashMap<>();
     }
     properties.put(property, value);
   }
@@ -1411,8 +1465,265 @@ public class AlignmentAnnotation
     this.annotationId = ANNOTATION_ID_PREFIX + Long.toString(nextId());
   }
 
+  /**
+   * Returns the match for the last unmatched opening RNA helix pair symbol
+   * preceding the given column, or '(' if nothing found to match.
+   * 
+   * @param column
+   * @return
+   */
+  public String getDefaultRnaHelixSymbol(int column)
+  {
+    String result = "(";
+    if (annotations == null)
+    {
+      return result;
+    }
+
+    /*
+     * for each preceding column, if it contains an open bracket, 
+     * count whether it is still unmatched at column, if so return its pair
+     * (likely faster than the fancy alternative using stacks)
+     */
+    for (int col = column - 1; col >= 0; col--)
+    {
+      Annotation annotation = annotations[col];
+      if (annotation == null)
+      {
+        continue;
+      }
+      String displayed = annotation.displayCharacter;
+      if (displayed == null || displayed.length() != 1)
+      {
+        continue;
+      }
+      char symbol = displayed.charAt(0);
+      if (!Rna.isOpeningParenthesis(symbol))
+      {
+        continue;
+      }
+
+      /*
+       * found an opening bracket symbol
+       * count (closing-opening) symbols of this type that follow it,
+       * up to and excluding the target column; if the count is less
+       * than 1, the opening bracket is unmatched, so return its match
+       */
+      String closer = String
+              .valueOf(Rna.getMatchingClosingParenthesis(symbol));
+      String opener = String.valueOf(symbol);
+      int count = 0;
+      for (int j = col + 1; j < column; j++)
+      {
+        if (annotations[j] != null)
+        {
+          String s = annotations[j].displayCharacter;
+          if (closer.equals(s))
+          {
+            count++;
+          }
+          else if (opener.equals(s))
+          {
+            count--;
+          }
+        }
+      }
+      if (count < 1)
+      {
+        return closer;
+      }
+    }
+    return result;
+  }
+
   protected static synchronized long nextId()
   {
     return counter++;
   }
+
+  /**
+   * 
+   * @return true for rows that have a range of values in their annotation set
+   */
+  public boolean isQuantitative()
+  {
+    return graphMin < graphMax;
+  }
+
+  /**
+   * delete any columns in alignmentAnnotation that are hidden (including
+   * sequence associated annotation).
+   * 
+   * @param hiddenColumns
+   *          the set of hidden columns
+   */
+  public void makeVisibleAnnotation(HiddenColumns hiddenColumns)
+  {
+    if (annotations != null)
+    {
+      makeVisibleAnnotation(0, annotations.length, hiddenColumns);
+    }
+  }
+
+  /**
+   * 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 hiddenColumns
+   *          the set of hidden columns
+   */
+  public void makeVisibleAnnotation(int start, int end,
+          HiddenColumns hiddenColumns)
+  {
+    if (annotations != null)
+    {
+      if (hiddenColumns.hasHiddenColumns())
+      {
+        removeHiddenAnnotation(start, end, hiddenColumns);
+      }
+      else
+      {
+        restrict(start, end);
+      }
+    }
+  }
+
+  /**
+   * The actual implementation of deleting hidden annotation columns
+   * 
+   * @param start
+   *          remove any annotation to the right of this column
+   * @param end
+   *          remove any annotation to the left of this column
+   * @param hiddenColumns
+   *          the set of hidden columns
+   */
+  private void removeHiddenAnnotation(int start, int end,
+          HiddenColumns hiddenColumns)
+  {
+    // mangle the alignmentAnnotation annotation array
+    ArrayList<Annotation[]> annels = new ArrayList<>();
+    Annotation[] els = null;
+
+    int w = 0;
+
+    Iterator<int[]> blocks = hiddenColumns.getVisContigsIterator(start,
+            end + 1, false);
+
+    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] <= annotations.length)
+        {
+          // copy just the visible segment of the annotation row
+          copylength = annotationLength;
+        }
+        else
+        {
+          // copy to the end of the annotation row
+          copylength = annotations.length - block[0];
+        }
+      }
+
+      els = new Annotation[annotationLength];
+      annels.add(els);
+      System.arraycopy(annotations, block[0], els, 0, copylength);
+      w += annotationLength;
+    }
+
+    if (w != 0)
+    {
+      annotations = new Annotation[w];
+
+      w = 0;
+      for (Annotation[] chnk : annels)
+      {
+        System.arraycopy(chnk, 0, annotations, w, chnk.length);
+        w += chnk.length;
+      }
+    }
+  }
+
+  public static Iterable<AlignmentAnnotation> findAnnotations(
+          Iterable<AlignmentAnnotation> list, SequenceI seq, String calcId,
+          String label)
+  {
+
+    ArrayList<AlignmentAnnotation> aa = new ArrayList<>();
+    for (AlignmentAnnotation ann : list)
+    {
+      if ((calcId == null || (ann.getCalcId() != null
+              && ann.getCalcId().equals(calcId)))
+              && (seq == null || (ann.sequenceRef != null
+                      && ann.sequenceRef == seq))
+              && (label == null
+                      || (ann.label != null && ann.label.equals(label))))
+      {
+        aa.add(ann);
+      }
+    }
+    return aa;
+  }
+
+  /**
+   * Answer true if any annotation matches the calcId passed in (if not null).
+   * 
+   * @param list
+   *          annotation to search
+   * @param calcId
+   * @return
+   */
+  public static boolean hasAnnotation(List<AlignmentAnnotation> list,
+          String calcId)
+  {
+
+    if (calcId != null && !"".equals(calcId))
+    {
+      for (AlignmentAnnotation a : list)
+      {
+        if (a.getCalcId() == calcId)
+        {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  public static Iterable<AlignmentAnnotation> findAnnotation(
+          List<AlignmentAnnotation> list, String calcId)
+  {
+
+    List<AlignmentAnnotation> aa = new ArrayList<>();
+    if (calcId == null)
+    {
+      return aa;
+    }
+    for (AlignmentAnnotation a : list)
+    {
+
+      if (a.getCalcId() == calcId || (a.getCalcId() != null
+              && calcId != null && a.getCalcId().equals(calcId)))
+      {
+        aa.add(a);
+      }
+    }
+    return aa;
+  }
+
 }