X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=9a21fbb2e855a60b79421c3459ec43b4cee80c2c;hb=b2f9a8d7bce642ff4011bc6d49e02bb0569fbb11;hp=3d42475fb3dfe765def8761c77bb28eef6777ee0;hpb=db7a726e4cf2c7d5f650085bd07b7f19254688e9;p=jalview.git diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java index 3d42475..9a21fbb 100755 --- a/src/jalview/io/AnnotationFile.java +++ b/src/jalview/io/AnnotationFile.java @@ -1,6 +1,6 @@ /* - * 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.1) + * Copyright (C) 2014 The Jalview Authors * * This file is part of Jalview. * @@ -14,6 +14,7 @@ * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.io; @@ -131,7 +132,8 @@ public class AnnotationFile StringBuffer colours = new StringBuffer(); StringBuffer graphLine = new StringBuffer(); StringBuffer rowprops = new StringBuffer(); - Hashtable graphGroup = new Hashtable(); + Hashtable graphGroup = new Hashtable(); + Hashtable graphGroup_refs = new Hashtable(); BitSet graphGroupSeen = new BitSet(); java.awt.Color color; @@ -147,54 +149,13 @@ 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. @@ -253,13 +214,15 @@ public class AnnotationFile if (row.graphGroup > -1) { graphGroupSeen.set(row.graphGroup); - String key = String.valueOf(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); } } @@ -376,21 +339,37 @@ 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) { - Enumeration en = graphGroup.elements(); - while (en.hasMoreElements()) - { + SequenceI oldRefSeq = refSeq; + SequenceGroup oldRefGroup = refGroup; + for (Map.Entry combine_statement:graphGroup.entrySet()) + { + 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(en.nextElement()); + text.append(combine_statement.getValue()); text.append(newline); } + writeSequence_Ref(refSeq, oldRefSeq); + refSeq = oldRefSeq; + + writeGroup_Ref(refGroup, oldRefGroup); + refGroup = oldRefGroup; } text.append(rowprops.toString()); } @@ -421,6 +400,62 @@ 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 list) { SequenceI seqrep = null; @@ -590,14 +625,13 @@ public class AnnotationFile } long nlinesread=0; String lastread=""; + private static String GRAPHLINE="GRAPHLINE", COMBINE="COMBINE"; public boolean parseAnnotationFrom(AlignmentI al, BufferedReader in) throws Exception { nlinesread = 0; - /** - * number of combine statements in this annotation file. Used to create new groups for combined annotation graphs without disturbing existing ones - */ - int combinecount = 0; + ArrayList combineAnnotation_calls = new ArrayList(); + ArrayList deferredAnnotation_calls = new ArrayList(); boolean modified = false; String groupRef = null; Hashtable groupRefRows = new Hashtable(); @@ -681,9 +715,10 @@ public class AnnotationFile continue; } - else if (token.equalsIgnoreCase("COMBINE")) + else if (token.equalsIgnoreCase(COMBINE)) { - combineAnnotations(al, combinecount++, st); + // keep a record of current state and resolve groupRef at end + combineAnnotation_calls.add(new Object[] { st, refSeq, groupRef}); modified = true; continue; } @@ -693,9 +728,10 @@ 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; } @@ -755,6 +791,7 @@ public class AnnotationFile else if (token.equalsIgnoreCase("SEQUENCE_GROUP")) { addGroup(al, st); + modified=true; continue; } @@ -898,7 +935,8 @@ public class AnnotationFile // and set modification flag modified = true; } - // Finally, resolve the groupRefs + // Resolve the groupRefs + Hashtable groupRefLookup=new Hashtable(); Enumeration en = groupRefRows.keys(); while (en.hasMoreElements()) @@ -922,6 +960,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; @@ -936,6 +975,34 @@ 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; } @@ -1092,7 +1159,7 @@ public class AnnotationFile } } - void combineAnnotations(AlignmentI al, int combineCount, StringTokenizer st) + void combineAnnotations(AlignmentI al, int combineCount, StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef) { String group = st.nextToken(); // First make sure we are not overwriting the graphIndex @@ -1102,20 +1169,21 @@ public class AnnotationFile for (int i = 0; i < al.getAlignmentAnnotation().length; i++) { AlignmentAnnotation aa = al.getAlignmentAnnotation()[i]; + if (aa.graphGroup>graphGroup) { // try to number graphGroups in order of occurence. - graphGroup=aa.graphGroup; + graphGroup=aa.graphGroup+1; } - if (aa.label.equalsIgnoreCase(group)) + if (aa.sequenceRef==seqRef && aa.groupRef==groupRef && aa.label.equalsIgnoreCase(group)) { if (aa.graphGroup>-1) { graphGroup = aa.graphGroup; } else { - if (graphGroup >= combineCount) + if (graphGroup <= combineCount) { - graphGroup++; + graphGroup=combineCount+1; } aa.graphGroup = graphGroup; } @@ -1129,9 +1197,10 @@ 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; } } @@ -1144,19 +1213,26 @@ 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)); } } } @@ -1164,16 +1240,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)