X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=eca27a727c3b625c333ee8a1f0deafcbd24b54b2;hb=refs%2Fheads%2Ffeatures%2FJAL-2040_JAL-2137_phyre2;hp=668aa3cdb717897b02f801945862204a1dc7f2cd;hpb=47168f025aefdaa044802bd5f8f510ffe43a4808;p=jalview.git diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java index 668aa3c..eca27a7 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.2) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,13 +20,38 @@ */ package jalview.io; -import java.io.*; -import java.net.*; -import java.util.*; - -import jalview.analysis.*; -import jalview.datamodel.*; -import jalview.schemes.*; +import jalview.analysis.Conservation; +import jalview.api.AlignViewportI; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.Annotation; +import jalview.datamodel.ColumnSelection; +import jalview.datamodel.GraphLine; +import jalview.datamodel.HiddenSequences; +import jalview.datamodel.PDBEntry; +import jalview.datamodel.PDBEntry.Type; +import jalview.datamodel.SequenceGroup; +import jalview.datamodel.SequenceI; +import jalview.schemes.ColourSchemeI; +import jalview.schemes.ColourSchemeProperty; +import jalview.schemes.UserColourScheme; +import jalview.structure.StructureSelectionManager; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.StringReader; +import java.net.URL; +import java.util.ArrayList; +import java.util.BitSet; +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.StringTokenizer; +import java.util.Vector; public class AnnotationFile { @@ -67,18 +92,18 @@ public class AnnotationFile } /** - * convenience method for pre-2.4 feature files which have no view, hidden + * convenience method for pre-2.9 annotation files which have no view, hidden * columns or hidden row keywords. * * @param annotations * @param list * @param properties - * @return feature file as a string. + * @return annotation file as a string. */ public String printAnnotations(AlignmentAnnotation[] annotations, List list, Hashtable properties) { - return printAnnotations(annotations, list, properties, null); + return printAnnotations(annotations, list, properties, null, null, null); } @@ -119,10 +144,56 @@ public class AnnotationFile * @return annotation file */ public String printAnnotations(AlignmentAnnotation[] annotations, - List list, Hashtable properties, ViewDef[] views) + List list, Hashtable properties, + ColumnSelection cs, AlignmentI al, ViewDef view) { - // TODO: resolve views issue : annotationFile could contain visible region, - // or full data + hidden region specifications for a view. + if (view != null) + { + if (view.viewname != null) + { + text.append("VIEW_DEF\t" + view.viewname + "\n"); + } + if (list == null) + { + list = view.visibleGroups; + } + if (cs == null) + { + cs = view.hiddencols; + } + if (al == null) + { + // add hidden rep sequences. + } + } + // first target - store and restore all settings for a view. + if (al != null && al.hasSeqrep()) + { + text.append("VIEW_SETREF\t" + al.getSeqrep().getName() + "\n"); + } + if (cs != null && cs.hasHiddenColumns()) + { + text.append("VIEW_HIDECOLS\t"); + List hc = cs.getHiddenColumns(); + boolean comma = false; + for (int[] r : hc) + { + if (!comma) + { + comma = true; + } + else + { + text.append(","); + } + text.append(r[0]); + text.append("-"); + text.append(r[1]); + } + text.append("\n"); + } + // TODO: allow efficient recovery of annotation data shown in several + // different views if (annotations != null) { boolean oneColour = true; @@ -134,8 +205,8 @@ public class AnnotationFile StringBuffer colours = new StringBuffer(); StringBuffer graphLine = new StringBuffer(); StringBuffer rowprops = new StringBuffer(); - Hashtable graphGroup = new Hashtable(); - Hashtable graphGroup_refs = new Hashtable(); + Hashtable graphGroup = new Hashtable(); + Hashtable graphGroup_refs = new Hashtable(); BitSet graphGroupSeen = new BitSet(); java.awt.Color color; @@ -144,16 +215,19 @@ public class AnnotationFile { row = annotations[i]; - if (!row.visible && !row.hasScore() && !(row.graphGroup>-1 && graphGroupSeen.get(row.graphGroup))) + if (!row.visible + && !row.hasScore() + && !(row.graphGroup > -1 && graphGroupSeen + .get(row.graphGroup))) { continue; } color = null; oneColour = true; - + // mark any sequence references for the row - writeSequence_Ref(refSeq ,row.sequenceRef); + writeSequence_Ref(refSeq, row.sequenceRef); refSeq = row.sequenceRef; // mark any group references for the row writeGroup_Ref(refGroup, row.groupRef); @@ -171,7 +245,7 @@ public class AnnotationFile && row.annotations[j].displayCharacter.length() > 0 && !row.annotations[j].displayCharacter .equals(" ")); hasGlyphs |= (row.annotations[j].secondaryStructure != 0 && row.annotations[j].secondaryStructure != ' '); - hasValues |= (row.annotations[j].value != Float.NaN); // NaNs can't + hasValues |= (!Float.isNaN(row.annotations[j].value)); // NaNs can't // be // rendered.. hasText |= (row.annotations[j].description != null && row.annotations[j].description @@ -220,11 +294,11 @@ public class AnnotationFile if (graphGroup.containsKey(key)) { graphGroup.put(key, graphGroup.get(key) + "\t" + row.label); - + } else { - graphGroup_refs.put(key, new Object[] { refSeq, refGroup}); + graphGroup_refs.put(key, new Object[] { refSeq, refGroup }); graphGroup.put(key, row.label); } } @@ -260,13 +334,13 @@ public class AnnotationFile } if (hasValues) { - if (row.annotations[j].value != Float.NaN) + if (!Float.isNaN(row.annotations[j].value)) { text.append(comma + row.annotations[j].value); } else { - System.err.println("Skipping NaN - not valid value."); + // System.err.println("Skipping NaN - not valid value."); text.append(comma + 0f);// row.annotations[j].value); } comma = ","; @@ -316,7 +390,9 @@ public class AnnotationFile } if (row.hasScore()) + { text.append("\t" + row.score); + } text.append(newline); @@ -341,7 +417,8 @@ public class AnnotationFile rowprops.append(row.centreColLabels); rowprops.append(newline); } - if (graphLine.length()>0) { + if (graphLine.length() > 0) + { text.append(graphLine.toString()); graphLine.setLength(0); } @@ -354,22 +431,24 @@ public class AnnotationFile { 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]; + 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(combine_statement.getValue()); text.append(newline); } writeSequence_Ref(refSeq, oldRefSeq); refSeq = oldRefSeq; - + writeGroup_Ref(refGroup, oldRefGroup); refGroup = oldRefGroup; } @@ -396,13 +475,16 @@ public class AnnotationFile text.append(properties.get(key)); } // TODO: output alignment visualization settings here if required - + // iterate through one or more views, defining, marking columns and rows + // as visible/hidden, and emmitting view properties. + // View specific annotation is } return text.toString(); } - private Object writeGroup_Ref(SequenceGroup refGroup, SequenceGroup next_refGroup) + private Object writeGroup_Ref(SequenceGroup refGroup, + SequenceGroup next_refGroup) { if (next_refGroup == null) { @@ -427,13 +509,13 @@ public class AnnotationFile return true; } } - return false; + return false; } - + private boolean writeSequence_Ref(SequenceI refSeq, SequenceI next_refSeq) { - if (next_refSeq==null) + if (next_refSeq == null) { if (refSeq != null) { @@ -582,24 +664,68 @@ public class AnnotationFile String refSeqId = null; + public boolean annotateAlignmentView(AlignViewportI viewport, + String file, String protocol) + { + ColumnSelection colSel = viewport.getColumnSelection(); + if (colSel == null) + { + colSel = new ColumnSelection(); + } + boolean rslt = readAnnotationFile(viewport.getAlignment(), colSel, + file, protocol); + if (rslt && (colSel.hasSelectedColumns() || colSel.hasHiddenColumns())) + { + viewport.setColumnSelection(colSel); + } + + return rslt; + } + public boolean readAnnotationFile(AlignmentI al, String file, String protocol) { + return readAnnotationFile(al, null, file, protocol); + } + + public boolean readAnnotationFile(AlignmentI al, ColumnSelection colSel, + String file, String protocol) + { + baseUri = ""; BufferedReader in = null; try { if (protocol.equals(AppletFormatAdapter.FILE)) { in = new BufferedReader(new FileReader(file)); + baseUri = new File(file).getParent(); + if (baseUri == null) + { + baseUri = ""; + } + else + { + baseUri += "/"; + } } else if (protocol.equals(AppletFormatAdapter.URL)) { URL url = new URL(file); in = new BufferedReader(new InputStreamReader(url.openStream())); + String bs = url.toExternalForm(); + baseUri = bs.substring(0, bs.indexOf(url.getHost()) + + url.getHost().length()); + baseUri += url.toURI().getPath(); + if (baseUri.lastIndexOf("/") > -1) + { + baseUri = baseUri.substring(0, baseUri.lastIndexOf("/")) + "/"; + } } else if (protocol.equals(AppletFormatAdapter.PASTE)) { in = new BufferedReader(new StringReader(file)); + // TODO - support mimencoded PDBs for a paste.. ? + baseUri = ""; } else if (protocol.equals(AppletFormatAdapter.CLASSLOADER)) { @@ -607,29 +733,44 @@ public class AnnotationFile if (is != null) { in = new BufferedReader(new java.io.InputStreamReader(is)); + // TODO: this probably doesn't work for classloader - needs a test + baseUri = new File("/" + file).getParent() + "/"; } } if (in != null) { - return parseAnnotationFrom(al, in); + return parseAnnotationFrom(al, colSel, in); } } catch (Exception ex) { 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=""; - private static String GRAPHLINE="GRAPHLINE", COMBINE="COMBINE"; - public boolean parseAnnotationFrom(AlignmentI al, BufferedReader in) - throws Exception + + long nlinesread = 0; + + String lastread = ""; + + /** + * used for resolving absolute references to resources relative to + * annotationFile location + */ + String baseUri = ""; + + private static String GRAPHLINE = "GRAPHLINE", COMBINE = "COMBINE", + STRUCTMODEL = "STRUCTMODEL"; + + public boolean parseAnnotationFrom(AlignmentI al, ColumnSelection colSel, + BufferedReader in) throws Exception { nlinesread = 0; ArrayList combineAnnotation_calls = new ArrayList(); @@ -678,7 +819,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; @@ -699,7 +841,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) @@ -720,7 +863,8 @@ public class AnnotationFile else if (token.equalsIgnoreCase(COMBINE)) { // keep a record of current state and resolve groupRef at end - combineAnnotation_calls.add(new Object[] { st, refSeq, groupRef}); + combineAnnotation_calls + .add(new Object[] { st, refSeq, groupRef }); modified = true; continue; } @@ -733,7 +877,8 @@ public class AnnotationFile else if (token.equalsIgnoreCase(GRAPHLINE)) { // resolve at end - deferredAnnotation_calls.add(new Object[] { GRAPHLINE, st, refSeq, groupRef}); + deferredAnnotation_calls.add(new Object[] { GRAPHLINE, st, + refSeq, groupRef }); modified = true; continue; } @@ -793,7 +938,7 @@ public class AnnotationFile else if (token.equalsIgnoreCase("SEQUENCE_GROUP")) { addGroup(al, st); - modified=true; + modified = true; continue; } @@ -816,7 +961,95 @@ public class AnnotationFile modified = true; continue; } - + // else if (token.equalsIgnoreCase("VIEW_DEF")) + // { + // addOrSetView(al,st); + // modified = true; + // continue; + // } + else if (token.equalsIgnoreCase("VIEW_SETREF")) + { + if (refSeq != null) + { + al.setSeqrep(refSeq); + } + modified = true; + continue; + } + else if (token.equalsIgnoreCase("VIEW_HIDECOLS")) + { + if (st.hasMoreTokens()) + { + if (colSel == null) + { + colSel = new ColumnSelection(); + } + parseHideCols(colSel, st.nextToken()); + } + modified = true; + continue; + } + else if (token.equalsIgnoreCase("HIDE_INSERTIONS")) + { + SequenceI sr = refSeq == null ? al.getSeqrep() : refSeq; + if (sr == null) + { + sr = al.getSequenceAt(0); + } + if (sr != null) + { + if (colSel == null) + { + System.err + .println("Cannot process HIDE_INSERTIONS without an alignment view: Ignoring line: " + + line); + } + else + { + // consider deferring this till after the file has been parsed ? + colSel.hideInsertionsFor(sr); + } + } + modified = true; + continue; + } + else if (token.equalsIgnoreCase(STRUCTMODEL)) + { + boolean failedtoadd = true; + // expect + // STRUCTMODEL + if (st.hasMoreTokens()) { + refSeq = al.findName(refSeqId = st.nextToken()); + if (refSeq == null) + { + System.err.println("Couldn't locate " + refSeqId + + " in the alignment for STRUCTMODEL"); + refSeqId = null; + } + else + { + String tempId = st.nextToken(); + String urlToModel = st.nextToken(); + String urlToPairwise = st.hasMoreTokens() ? st.nextToken() + : ""; + if (add_structmodel(al, refSeq, tempId, urlToModel, + urlToPairwise)) + { + failedtoadd = false; + } + } + } + if (failedtoadd) + { + System.err + .println("Need [] as tab separated fields after " + + STRUCTMODEL); + } else { + modified = true; + } + continue; + } // Parse out the annotation row graphStyle = AlignmentAnnotation.getGraphValueFromString(token); label = st.nextToken(); @@ -834,7 +1067,9 @@ public class AnnotationFile { description = line; if (st.hasMoreTokens()) + { line = st.nextToken(); + } } if (st.hasMoreTokens()) @@ -938,7 +1173,7 @@ public class AnnotationFile modified = true; } // Resolve the groupRefs - Hashtable groupRefLookup=new Hashtable(); + Hashtable groupRefLookup = new Hashtable(); Enumeration en = groupRefRows.keys(); while (en.hasMoreElements()) @@ -962,7 +1197,7 @@ public class AnnotationFile { matched = true; Vector rowset = (Vector) groupRefRows.get(groupRef); - groupRefLookup.put(groupRef, theGroup); + groupRefLookup.put(groupRef, theGroup); if (rowset != null && rowset.size() > 0) { AlignmentAnnotation alan = null; @@ -986,29 +1221,169 @@ public class AnnotationFile (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 + .get(_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 + * 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, + 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 - ); + (_combine_args[2] == null) ? null : groupRefLookup + .get(_combine_args[2]) // the reference group, + // or null + ); } } return modified; } + /** + * resolve a structural model and generate and add an alignment sequence for + * it + * + * @param refSeq2 + * @param tempId + * @param urlToModel + * @param urlToPairwise + * @return true if model and sequence was added + */ + private boolean add_structmodel(AlignmentI al, SequenceI refSeq2, String tempId, + String urlToModel, String urlToPairwise) + { + String warningMessage = null, modelPath = null, modelProt = null, aliPath = null, aliProt = null; + boolean added = false; + try { + // locate tempId. if it exists, will need to merge, otherwise: + SequenceI templateSeq = al.findName(tempId); + // 1. load urlToModel + modelPath = resolveAbsolute(urlToModel); + modelProt = AppletFormatAdapter.checkProtocol(modelPath); + // need to transfer to local temp file ? + PDBEntry modelpe = new PDBEntry(tempId, null, Type.FILE, modelPath); + PDBEntry templpe = new PDBEntry(tempId, null, Type.FILE, modelPath); + refSeq2.addPDBId(modelpe); + aliPath = resolveAbsolute(urlToPairwise); + aliProt = AppletFormatAdapter.checkProtocol(aliPath); + // 2. load urlToPairwise + AlignmentI pwa = new AppletFormatAdapter().readFile(aliPath, aliProt, + "FASTA"); + SequenceI qPw = null, tPw = null; + if (pwa != null) + { + // resolve query/template sequences in provided alignment + qPw = pwa.findName(refSeqId); + tPw = pwa.findName(tempId); + } + if (false) + // (qPw != null && tPw != null) + { + // not yet complete + // refalQ vvva--addrvvvtttddd + // refalT ---aaaa---sss---ddd + // profalQ ---v-v-v-a.-.-a---dd--r--vvvtt--td--dd + // profalT ---.-.-.-aa-a-a---..--.--sss..--.d--dd + // Pragmatic solution here: + // Map templpe onto refalT only where refalT and refalQ are both + // non-gaps + + // columns for start..end in refSeq2 + int[] gapMap = refSeq2.gapMap(); + // insert gaps in tPw + int curi = 0, width = refSeq2.getLength(); + // TBC + } + else + { + // assume 1:1 - so synthesise sequences to use to construct mapping + StructureFile pdbf = StructureSelectionManager + .getStructureSelectionManager().setMapping(false, + new SequenceI[] { refSeq2.getDatasetSequence() }, + null, modelPath, modelProt); + refSeq2.getDatasetSequence().addPDBId(modelpe); + if (templateSeq == null && tPw != null) + { + tPw.createDatasetSequence(); + tPw.getDatasetSequence().addPDBId(templpe); // needs to set mapping based on model yet... + al.addSequence(tPw); + added = true; + } + } + // 3. pad/insert gaps in urlToPairwise according to gaps already present in + // refSeq2 + // 4. add padded tempId sequence to alignment + // 4. associate urlToModel with refSeq2 based on position map provided by + // urlToPairwise + // 5. associate urlToModel with tempId based on position map provided by + // urlToPairwise + // start a thread to load urlToModel and process/annotate sequences. + } catch (IOException x) + { + warningMessage = x.toString(); + } finally { + if (warningMessage !=null) + { + System.err.println("Warnings whilst processing STRUCTMODEL: "+warningMessage); + } + return added; + } + } + + private String resolveAbsolute(String relURI) + { + if (relURI.indexOf(":/") > -1 || relURI.startsWith("/") + || "".equals(baseUri) || relURI.startsWith(baseUri)) + { + return relURI; + } + return baseUri + relURI; + } + + private void parseHideCols(ColumnSelection colSel, String nextToken) + { + StringTokenizer inval = new StringTokenizer(nextToken, ","); + while (inval.hasMoreTokens()) + { + String range = inval.nextToken().trim(); + int from, to = range.indexOf("-"); + if (to == -1) + { + from = to = Integer.parseInt(range); + if (from >= 0) + { + colSel.hideColumns(from, to); + } + } + else + { + from = Integer.parseInt(range.substring(0, to)); + if (to < range.length() - 1) + { + to = Integer.parseInt(range.substring(to + 1)); + } + else + { + to = from; + } + if (from > 0 && to >= from) + { + colSel.hideColumns(from, to); + } + } + } + } + private Object autoAnnotsKey(AlignmentAnnotation annotation, SequenceI refSeq, String groupRef) { @@ -1095,8 +1470,8 @@ public class AnnotationFile } } if (hasSymbols - && (token.equals("H") || token.equals("E") - || token.equals("S") || token.equals(" "))) + && (token.length() == 1 && "()<>[]{}AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz" + .contains(token))) { // Either this character represents a helix or sheet // or an integer which can be displayed @@ -1161,31 +1536,35 @@ public class AnnotationFile } } - void combineAnnotations(AlignmentI al, int combineCount, StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef) + 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 - int graphGroup=0; + int graphGroup = 0; if (al.getAlignmentAnnotation() != null) { for (int i = 0; i < al.getAlignmentAnnotation().length; i++) { AlignmentAnnotation aa = al.getAlignmentAnnotation()[i]; - - if (aa.graphGroup>graphGroup) + + if (aa.graphGroup > graphGroup) { // try to number graphGroups in order of occurence. - graphGroup=aa.graphGroup+1; + graphGroup = aa.graphGroup + 1; } - if (aa.sequenceRef==seqRef && aa.groupRef==groupRef && aa.label.equalsIgnoreCase(group)) + if (aa.sequenceRef == seqRef && aa.groupRef == groupRef + && aa.label.equalsIgnoreCase(group)) { - if (aa.graphGroup>-1) + if (aa.graphGroup > -1) { graphGroup = aa.graphGroup; - } else { + } + else + { if (graphGroup <= combineCount) { - graphGroup=combineCount+1; + graphGroup = combineCount + 1; } aa.graphGroup = graphGroup; } @@ -1200,7 +1579,8 @@ public class AnnotationFile for (int i = 0; i < al.getAlignmentAnnotation().length; i++) { AlignmentAnnotation aa = al.getAlignmentAnnotation()[i]; - if (aa.sequenceRef==seqRef && aa.groupRef==groupRef && aa.label.equalsIgnoreCase(group)) + if (aa.sequenceRef == seqRef && aa.groupRef == groupRef + && aa.label.equalsIgnoreCase(group)) { aa.graphGroup = graphGroup; break; @@ -1215,7 +1595,8 @@ public class AnnotationFile } } - void addLine(AlignmentI al, StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef) + void addLine(AlignmentI al, StringTokenizer st, SequenceI seqRef, + SequenceGroup groupRef) { String group = st.nextToken(); AlignmentAnnotation annotation = null, alannot[] = al @@ -1232,7 +1613,9 @@ public class AnnotationFile { for (int i = 0; i < alannot.length; i++) { - if (alannot[i].label.equalsIgnoreCase(group) && (seqRef==null || alannot[i].sequenceRef==seqRef) && (groupRef==null || alannot[i].groupRef==groupRef)) + if (alannot[i].label.equalsIgnoreCase(group) + && (seqRef == null || alannot[i].sequenceRef == seqRef) + && (groupRef == null || alannot[i].groupRef == groupRef)) { alannot[i].setThreshold(new GraphLine(value, label, colour)); } @@ -1425,9 +1808,9 @@ public class AnnotationFile else if (key.equalsIgnoreCase("consThreshold")) { sg.cs.setConservationInc(Integer.parseInt(value)); - Conservation c = new Conservation("Group", - ResidueProperties.propHash, 3, sg.getSequences(null), - sg.getStartRes(), sg.getEndRes() + 1); + Conservation c = new Conservation("Group", 3, + sg.getSequences(null), sg.getStartRes(), + sg.getEndRes() + 1); c.calculate(); c.verdict(false, 25); // TODO: refer to conservation percent threshold @@ -1547,6 +1930,10 @@ public class AnnotationFile */ public String printCSVAnnotations(AlignmentAnnotation[] annotations) { + if (annotations == null) + { + return ""; + } StringBuffer sp = new StringBuffer(); for (int i = 0; i < annotations.length; i++) { @@ -1571,4 +1958,19 @@ public class AnnotationFile } return sp.toString(); } + + public String printAnnotationsForView(AlignViewportI viewport) + { + return printAnnotations(viewport.isShowAnnotation() ? viewport + .getAlignment().getAlignmentAnnotation() : null, viewport + .getAlignment().getGroups(), viewport.getAlignment() + .getProperties(), viewport.getColumnSelection(), + viewport.getAlignment(), null); + } + + public String printAnnotationsForAlignment(AlignmentI al) + { + return printAnnotations(al.getAlignmentAnnotation(), al.getGroups(), + al.getProperties(), null, al, null); + } }