X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=f66b3daddde830fc51ec45962393284333bc7100;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=a94bd3c73d57c3199b78b42a6e05b63146923778;hpb=3a737f9769e1d0abbf973730b4f240c4abd5f475;p=jalview.git

diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java
index a94bd3c..f66b3da 100755
--- a/src/jalview/io/AnnotationFile.java
+++ b/src/jalview/io/AnnotationFile.java
@@ -1,19 +1,22 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1)
+ * Copyright (C) 2014 The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
  * Jalview is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License 
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
  *  
  * Jalview is distributed in the hope that it will be useful, but 
  * WITHOUT ANY WARRANTY; without even the implied warranty 
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
  * PURPOSE.  See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.io;
 
@@ -131,7 +134,9 @@ public class AnnotationFile
       StringBuffer colours = new StringBuffer();
       StringBuffer graphLine = new StringBuffer();
       StringBuffer rowprops = new StringBuffer();
-      Hashtable graphGroup = new Hashtable();
+      Hashtable<Integer, String> graphGroup = new Hashtable<Integer, String>();
+      Hashtable<Integer, Object[]> graphGroup_refs = new Hashtable<Integer, Object[]>();
+      BitSet graphGroupSeen = new BitSet();
 
       java.awt.Color color;
 
@@ -139,7 +144,10 @@ public class AnnotationFile
       {
         row = annotations[i];
 
-        if (!row.visible && !row.hasScore())
+        if (!row.visible
+                && !row.hasScore()
+                && !(row.graphGroup > -1 && graphGroupSeen
+                        .get(row.graphGroup)))
         {
           continue;
         }
@@ -147,53 +155,12 @@ public class AnnotationFile
         color = null;
         oneColour = true;
 
-        if (row.sequenceRef == null)
-        {
-          if (refSeq != null)
-          {
-            text.append(newline);
-            text.append("SEQUENCE_REF\tALIGNMENT");
-            text.append(newline);
-          }
-
-          refSeq = null;
-        }
-
-        else
-        {
-          if (refSeq == null || refSeq != row.sequenceRef)
-          {
-            refSeq = row.sequenceRef;
-            text.append(newline);
-            text.append("SEQUENCE_REF\t");
-            text.append(refSeq.getName());
-            text.append(newline);
-          }
-        }
+        // mark any sequence references for the row
+        writeSequence_Ref(refSeq, row.sequenceRef);
+        refSeq = row.sequenceRef;
         // mark any group references for the row
-        if (row.groupRef == null)
-        {
-
-          if (refGroup != null)
-          {
-            text.append(newline);
-            text.append("GROUP_REF\tALIGNMENT");
-            text.append(newline);
-          }
-
-          refGroup = null;
-        }
-        else
-        {
-          if (refGroup == null || refGroup != row.groupRef)
-          {
-            refGroup = row.groupRef;
-            text.append(newline);
-            text.append("GROUP_REF\t");
-            text.append(refGroup.getName());
-            text.append(newline);
-          }
-        }
+        writeGroup_Ref(refGroup, row.groupRef);
+        refGroup = row.groupRef;
 
         boolean hasGlyphs = row.hasIcons, hasLabels = row.hasText, hasValues = row.hasScore, hasText = false;
         // lookahead to check what the annotation row object actually contains.
@@ -251,13 +218,17 @@ public class AnnotationFile
 
           if (row.graphGroup > -1)
           {
-            String key = String.valueOf(row.graphGroup);
+            graphGroupSeen.set(row.graphGroup);
+            Integer key = new Integer(row.graphGroup);
             if (graphGroup.containsKey(key))
             {
               graphGroup.put(key, graphGroup.get(key) + "\t" + row.label);
+
             }
             else
             {
+              graphGroup_refs.put(key, new Object[]
+              { refSeq, refGroup });
               graphGroup.put(key, row.label);
             }
           }
@@ -374,21 +345,40 @@ public class AnnotationFile
           rowprops.append(row.centreColLabels);
           rowprops.append(newline);
         }
+        if (graphLine.length() > 0)
+        {
+          text.append(graphLine.toString());
+          graphLine.setLength(0);
+        }
       }
 
       text.append(newline);
 
       text.append(colours.toString());
-      text.append(graphLine.toString());
       if (graphGroup.size() > 0)
       {
-        text.append("COMBINE\t");
-        Enumeration en = graphGroup.elements();
-        while (en.hasMoreElements())
+        SequenceI oldRefSeq = refSeq;
+        SequenceGroup oldRefGroup = refGroup;
+        for (Map.Entry<Integer, String> combine_statement : graphGroup
+                .entrySet())
         {
-          text.append(en.nextElement());
+          Object[] seqRefAndGroup = graphGroup_refs.get(combine_statement
+                  .getKey());
+
+          writeSequence_Ref(refSeq, (SequenceI) seqRefAndGroup[0]);
+          refSeq = (SequenceI) seqRefAndGroup[0];
+
+          writeGroup_Ref(refGroup, (SequenceGroup) seqRefAndGroup[1]);
+          refGroup = (SequenceGroup) seqRefAndGroup[1];
+          text.append("COMBINE\t");
+          text.append(combine_statement.getValue());
           text.append(newline);
         }
+        writeSequence_Ref(refSeq, oldRefSeq);
+        refSeq = oldRefSeq;
+
+        writeGroup_Ref(refGroup, oldRefGroup);
+        refGroup = oldRefGroup;
       }
       text.append(rowprops.toString());
     }
@@ -419,6 +409,63 @@ public class AnnotationFile
     return text.toString();
   }
 
+  private Object writeGroup_Ref(SequenceGroup refGroup,
+          SequenceGroup next_refGroup)
+  {
+    if (next_refGroup == null)
+    {
+
+      if (refGroup != null)
+      {
+        text.append(newline);
+        text.append("GROUP_REF\t");
+        text.append("ALIGNMENT");
+        text.append(newline);
+      }
+      return true;
+    }
+    else
+    {
+      if (refGroup == null || refGroup != next_refGroup)
+      {
+        text.append(newline);
+        text.append("GROUP_REF\t");
+        text.append(next_refGroup.getName());
+        text.append(newline);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean writeSequence_Ref(SequenceI refSeq, SequenceI next_refSeq)
+  {
+
+    if (next_refSeq == null)
+    {
+      if (refSeq != null)
+      {
+        text.append(newline);
+        text.append("SEQUENCE_REF\t");
+        text.append("ALIGNMENT");
+        text.append(newline);
+        return true;
+      }
+    }
+    else
+    {
+      if (refSeq == null || refSeq != next_refSeq)
+      {
+        text.append(newline);
+        text.append("SEQUENCE_REF\t");
+        text.append(next_refSeq.getName());
+        text.append(newline);
+        return true;
+      }
+    }
+    return false;
+  }
+
   public void printGroups(List<SequenceGroup> list)
   {
     SequenceI seqrep = null;
@@ -579,19 +626,28 @@ public class AnnotationFile
     {
       ex.printStackTrace();
       System.out.println("Problem reading annotation file: " + ex);
-      if (nlinesread>0) {
-        System.out.println("Last read line "+nlinesread+": '"+lastread+"' (first 80 chars) ...");
+      if (nlinesread > 0)
+      {
+        System.out.println("Last read line " + nlinesread + ": '"
+                + lastread + "' (first 80 chars) ...");
       }
       return false;
     }
     return false;
   }
-  long nlinesread=0;
-  String lastread="";
+
+  long nlinesread = 0;
+
+  String lastread = "";
+
+  private static String GRAPHLINE = "GRAPHLINE", COMBINE = "COMBINE";
+
   public boolean parseAnnotationFrom(AlignmentI al, BufferedReader in)
           throws Exception
   {
     nlinesread = 0;
+    ArrayList<Object[]> combineAnnotation_calls = new ArrayList<Object[]>();
+    ArrayList<Object[]> deferredAnnotation_calls = new ArrayList<Object[]>();
     boolean modified = false;
     String groupRef = null;
     Hashtable groupRefRows = new Hashtable();
@@ -636,7 +692,8 @@ public class AnnotationFile
       boolean jvAnnotationFile = false;
       while ((line = in.readLine()) != null)
       {
-        nlinesread++;lastread = new String(line);
+        nlinesread++;
+        lastread = new String(line);
         if (line.indexOf("#") == 0)
         {
           continue;
@@ -657,7 +714,8 @@ public class AnnotationFile
 
       while ((line = in.readLine()) != null)
       {
-        nlinesread++;lastread = new String(line);
+        nlinesread++;
+        lastread = new String(line);
         if (line.indexOf("#") == 0
                 || line.indexOf("JALVIEW_ANNOTATION") > -1
                 || line.length() == 0)
@@ -675,9 +733,11 @@ public class AnnotationFile
           continue;
         }
 
-        else if (token.equalsIgnoreCase("COMBINE"))
+        else if (token.equalsIgnoreCase(COMBINE))
         {
-          combineAnnotations(al, st);
+          // keep a record of current state and resolve groupRef at end
+          combineAnnotation_calls.add(new Object[]
+          { st, refSeq, groupRef });
           modified = true;
           continue;
         }
@@ -687,9 +747,11 @@ public class AnnotationFile
           modified = true;
           continue;
         }
-        else if (token.equalsIgnoreCase("GRAPHLINE"))
+        else if (token.equalsIgnoreCase(GRAPHLINE))
         {
-          addLine(al, st);
+          // resolve at end
+          deferredAnnotation_calls.add(new Object[]
+          { GRAPHLINE, st, refSeq, groupRef });
           modified = true;
           continue;
         }
@@ -749,6 +811,7 @@ public class AnnotationFile
         else if (token.equalsIgnoreCase("SEQUENCE_GROUP"))
         {
           addGroup(al, st);
+          modified = true;
           continue;
         }
 
@@ -892,7 +955,8 @@ public class AnnotationFile
         // and set modification flag
         modified = true;
       }
-      // Finally, resolve the groupRefs
+      // Resolve the groupRefs
+      Hashtable<String, SequenceGroup> groupRefLookup = new Hashtable<String, SequenceGroup>();
       Enumeration en = groupRefRows.keys();
 
       while (en.hasMoreElements())
@@ -916,6 +980,7 @@ public class AnnotationFile
             {
               matched = true;
               Vector rowset = (Vector) groupRefRows.get(groupRef);
+              groupRefLookup.put(groupRef, theGroup);
               if (rowset != null && rowset.size() > 0)
               {
                 AlignmentAnnotation alan = null;
@@ -930,6 +995,39 @@ public class AnnotationFile
         }
         ((Vector) groupRefRows.get(groupRef)).removeAllElements();
       }
+      // process any deferred attribute settings for each context
+      for (Object[] _deferred_args : deferredAnnotation_calls)
+      {
+        if (_deferred_args[0] == GRAPHLINE)
+        {
+          addLine(al,
+                  (StringTokenizer) _deferred_args[1], // st
+                  (SequenceI) _deferred_args[2], // refSeq
+                  (_deferred_args[3] == null) ? null : groupRefLookup
+                          .get((String) _deferred_args[3]) // the reference
+                                                           // group, or null
+          );
+        }
+      }
+
+      // finally, combine all the annotation rows within each context.
+      /**
+       * number of combine statements in this annotation file. Used to create
+       * new groups for combined annotation graphs without disturbing existing
+       * ones
+       */
+      int combinecount = 0;
+      for (Object[] _combine_args : combineAnnotation_calls)
+      {
+        combineAnnotations(al,
+                ++combinecount,
+                (StringTokenizer) _combine_args[0], // st
+                (SequenceI) _combine_args[1], // refSeq
+                (_combine_args[2] == null) ? null : groupRefLookup
+                        .get((String) _combine_args[2]) // the reference group,
+                                                        // or null
+        );
+      }
     }
     return modified;
   }
@@ -1086,19 +1184,38 @@ public class AnnotationFile
     }
   }
 
-  void combineAnnotations(AlignmentI al, StringTokenizer st)
+  void combineAnnotations(AlignmentI al, int combineCount,
+          StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef)
   {
-    int graphGroup = -1;
     String group = st.nextToken();
     // First make sure we are not overwriting the graphIndex
+    int graphGroup = 0;
     if (al.getAlignmentAnnotation() != null)
     {
       for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
       {
-        if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+        AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
+
+        if (aa.graphGroup > graphGroup)
         {
-          graphGroup = al.getAlignmentAnnotation()[i].graphGroup + 1;
-          al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
+          // try to number graphGroups in order of occurence.
+          graphGroup = aa.graphGroup + 1;
+        }
+        if (aa.sequenceRef == seqRef && aa.groupRef == groupRef
+                && aa.label.equalsIgnoreCase(group))
+        {
+          if (aa.graphGroup > -1)
+          {
+            graphGroup = aa.graphGroup;
+          }
+          else
+          {
+            if (graphGroup <= combineCount)
+            {
+              graphGroup = combineCount + 1;
+            }
+            aa.graphGroup = graphGroup;
+          }
           break;
         }
       }
@@ -1109,9 +1226,11 @@ public class AnnotationFile
         group = st.nextToken();
         for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
         {
-          if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+          AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
+          if (aa.sequenceRef == seqRef && aa.groupRef == groupRef
+                  && aa.label.equalsIgnoreCase(group))
           {
-            al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
+            aa.graphGroup = graphGroup;
             break;
           }
         }
@@ -1124,19 +1243,29 @@ public class AnnotationFile
     }
   }
 
-  void addLine(AlignmentI al, StringTokenizer st)
+  void addLine(AlignmentI al, StringTokenizer st, SequenceI seqRef,
+          SequenceGroup groupRef)
   {
     String group = st.nextToken();
     AlignmentAnnotation annotation = null, alannot[] = al
             .getAlignmentAnnotation();
+    float value = new Float(st.nextToken()).floatValue();
+    String label = st.hasMoreTokens() ? st.nextToken() : null;
+    java.awt.Color colour = null;
+    if (st.hasMoreTokens())
+    {
+      UserColourScheme ucs = new UserColourScheme(st.nextToken());
+      colour = ucs.findColour('A');
+    }
     if (alannot != null)
     {
       for (int i = 0; i < alannot.length; i++)
       {
-        if (alannot[i].label.equalsIgnoreCase(group))
+        if (alannot[i].label.equalsIgnoreCase(group)
+                && (seqRef == null || alannot[i].sequenceRef == seqRef)
+                && (groupRef == null || alannot[i].groupRef == groupRef))
         {
-          annotation = alannot[i];
-          break;
+          alannot[i].setThreshold(new GraphLine(value, label, colour));
         }
       }
     }
@@ -1144,16 +1273,6 @@ public class AnnotationFile
     {
       return;
     }
-    float value = new Float(st.nextToken()).floatValue();
-    String label = st.hasMoreTokens() ? st.nextToken() : null;
-    java.awt.Color colour = null;
-    if (st.hasMoreTokens())
-    {
-      UserColourScheme ucs = new UserColourScheme(st.nextToken());
-      colour = ucs.findColour('A');
-    }
-
-    annotation.setThreshold(new GraphLine(value, label, colour));
   }
 
   void addGroup(AlignmentI al, StringTokenizer st)