/*
- * 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;
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;
{
row = annotations[i];
- if (!row.visible && !row.hasScore())
+ if (!row.visible
+ && !row.hasScore()
+ && !(row.graphGroup > -1 && graphGroupSeen
+ .get(row.graphGroup)))
{
continue;
}
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.
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);
}
}
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());
}
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;
{
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();
boolean jvAnnotationFile = false;
while ((line = in.readLine()) != null)
{
- nlinesread++;lastread = new String(line);
+ nlinesread++;
+ lastread = new String(line);
if (line.indexOf("#") == 0)
{
continue;
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)
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;
}
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;
}
else if (token.equalsIgnoreCase("SEQUENCE_GROUP"))
{
addGroup(al, st);
+ modified = true;
continue;
}
// 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())
{
matched = true;
Vector rowset = (Vector) groupRefRows.get(groupRef);
+ groupRefLookup.put(groupRef, theGroup);
if (rowset != null && rowset.size() > 0)
{
AlignmentAnnotation alan = null;
}
((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;
}
}
}
- 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;
}
}
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;
}
}
}
}
- 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));
}
}
}
{
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)
git://source.jalview.org / jalview.git / blobdiff