X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=4c38bd206d49d355aa60e1f94c6de719380c91dc;hb=c8feb125d3a159bcf5a7fe196fb1b886a46e5b52;hp=1b7b72a70f267ed4539b43fe31957e9d9b8ca311;hpb=7bc226b58110fa26d9dbd3f0c78095d06909ffc3;p=jalview.git diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java index 1b7b72a..4c38bd2 100755 --- a/src/jalview/io/AnnotationFile.java +++ b/src/jalview/io/AnnotationFile.java @@ -1,22 +1,21 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * + * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) + * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * * This program 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 2 * of the License, or (at your option) any later version. - * + * * This program 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 this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ - package jalview.io; import java.io.*; @@ -29,19 +28,59 @@ import jalview.schemes.*; public class AnnotationFile { - StringBuffer text = new StringBuffer( - "JALVIEW_ANNOTATION\n" - + "# Created: " - + new java.util.Date() + "\n\n"); + StringBuffer text = new StringBuffer("JALVIEW_ANNOTATION\n" + + "# Created: " + new java.util.Date() + "\n\n"); + + /** + * convenience method for pre-2.4 feature files which have no view, hidden + * columns or hidden row keywords. + * + * @param annotations + * @param groups + * @param properties + * @return feature file as a string. + */ + public String printAnnotations(AlignmentAnnotation[] annotations, + Vector groups, Hashtable properties) + { + return printAnnotations(annotations, groups, properties, null); + + } + + /** + * hold all the information about a particular view definition read from or + * written out in an annotations file. + */ + public class ViewDef + { + public String viewname; + + public HiddenSequences hidseqs; + + public ColumnSelection hiddencols; + + public Vector visibleGroups; + public Hashtable hiddenRepSeqs; + + public ViewDef(String viewname, HiddenSequences hidseqs, + ColumnSelection hiddencols, Hashtable hiddenRepSeqs) + { + this.viewname = viewname; + this.hidseqs = hidseqs; + this.hiddencols = hiddencols; + this.hiddenRepSeqs = hiddenRepSeqs; + } + } public String printAnnotations(AlignmentAnnotation[] annotations, - Vector groups) + Vector groups, Hashtable properties, ViewDef[] views) { if (annotations != null) { + boolean oneColour = true; AlignmentAnnotation row; String comma; - SequenceI seqref = null; + SequenceI refSeq = null; StringBuffer colours = new StringBuffer(); StringBuffer graphLine = new StringBuffer(); @@ -54,27 +93,28 @@ public class AnnotationFile { row = annotations[i]; - if (!row.visible) + if (!row.visible && !row.hasScore()) { continue; } color = null; + oneColour = true; if (row.sequenceRef == null) { - if (seqref != null) + if (refSeq != null) { text.append("\nSEQUENCE_REF\tALIGNMENT\n"); } - seqref = null; + refSeq = null; } - else if (seqref == null || seqref != row.sequenceRef) + else if (refSeq == null || refSeq != row.sequenceRef) { - seqref = row.sequenceRef; - text.append("\nSEQUENCE_REF\t" + seqref.getName() + "\n"); + refSeq = row.sequenceRef; + text.append("\nSEQUENCE_REF\t" + refSeq.getName() + "\n"); } if (row.graph == AlignmentAnnotation.NO_GRAPH) @@ -94,13 +134,16 @@ public class AnnotationFile if (row.getThreshold() != null) { - graphLine.append("GRAPHLINE\t" - + row.label + "\t" - + row.getThreshold().value + "\t" - + row.getThreshold().label + "\t" - + jalview.util.Format.getHexString( - row.getThreshold().colour) + "\n" - ); + graphLine + .append("GRAPHLINE\t" + + row.label + + "\t" + + row.getThreshold().value + + "\t" + + row.getThreshold().label + + "\t" + + jalview.util.Format.getHexString(row + .getThreshold().colour) + "\n"); } if (row.graphGroup > -1) @@ -108,8 +151,7 @@ public class AnnotationFile String key = String.valueOf(row.graphGroup); if (graphGroup.containsKey(key)) { - graphGroup.put(key, graphGroup.get(key) - + "\t" + row.label); + graphGroup.put(key, graphGroup.get(key) + "\t" + row.label); } else { @@ -124,10 +166,11 @@ public class AnnotationFile text.append(row.description + "\t"); } - for (int j = 0; j < row.annotations.length; j++) + for (int j = 0; row.annotations != null + && j < row.annotations.length; j++) { - if (seqref != null && - jalview.util.Comparison.isGap(seqref.getCharAt(j))) + if (refSeq != null + && jalview.util.Comparison.isGap(refSeq.getCharAt(j))) { continue; } @@ -140,8 +183,9 @@ public class AnnotationFile text.append(comma + row.annotations[j].secondaryStructure); comma = ","; } - if (row.annotations[j].displayCharacter.length() > 0 - && !row.annotations[j].displayCharacter.equals(" ")) + if (row.annotations[j].displayCharacter != null + && row.annotations[j].displayCharacter.length() > 0 + && !row.annotations[j].displayCharacter.equals(" ")) { text.append(comma + row.annotations[j].displayCharacter); comma = ","; @@ -149,23 +193,41 @@ public class AnnotationFile if (row.annotations[j] != null) { + if (color != null && !color.equals(row.annotations[j].colour)) + { + oneColour = false; + } + color = row.annotations[j].colour; - if (row.annotations[j].value != 0f) + if (row.annotations[j].value != 0f + && row.annotations[j].value != Float.NaN) { text.append(comma + row.annotations[j].value); } } + + if (row.annotations[j].colour != null + && row.annotations[j].colour != java.awt.Color.black) + { + text.append(comma + + "[" + + jalview.util.Format + .getHexString(row.annotations[j].colour) + + "]"); + } } text.append("|"); } + if (row.hasScore()) + text.append("\t" + row.score); + text.append("\n"); - if (color != null && color != java.awt.Color.black) + if (color != null && color != java.awt.Color.black && oneColour) { - colours.append("COLOUR\t" - + row.label + "\t" - + jalview.util.Format.getHexString(color) + "\n"); + colours.append("COLOUR\t" + row.label + "\t" + + jalview.util.Format.getHexString(color) + "\n"); } } @@ -190,19 +252,42 @@ public class AnnotationFile printGroups(groups); } + if (properties != null) + { + text.append("\n\nALIGNMENT"); + Enumeration en = properties.keys(); + while (en.hasMoreElements()) + { + String key = en.nextElement().toString(); + text.append("\t" + key + "=" + properties.get(key)); + } + // TODO: output alignment visualization settings here if required + + } + return text.toString(); } public void printGroups(Vector sequenceGroups) { SequenceGroup sg; + SequenceI seqrep=null; for (int i = 0; i < sequenceGroups.size(); i++) { sg = (SequenceGroup) sequenceGroups.elementAt(i); - text.append("SEQUENCE_GROUP\t" - + sg.getName() + "\t" - + (sg.getStartRes() + 1) + "\t" - + (sg.getEndRes() + 1) + "\t" + "-1\t"); + if (!sg.hasSeqrep()) + { + text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t" + + (sg.getStartRes() + 1) + "\t" + (sg.getEndRes() + 1) + "\t" + + "-1\t"); + seqrep = null; + } else { + seqrep = sg.getSeqrep(); + text.append("SEQUENCE_REF\t"+seqrep.getName()+"\n"); + text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t" + + (seqrep.findPosition(sg.getStartRes())) + "\t" + (seqrep.findPosition(sg.getEndRes())) + "\t" + + "-1\t"); + } for (int s = 0; s < sg.getSize(); s++) { text.append(sg.getSequenceAt(s).getName() + "\t"); @@ -216,8 +301,8 @@ public class AnnotationFile } if (sg.cs != null) { - text.append("colour=" + ColourSchemeProperty.getColourName(sg.cs) + - "\t"); + text.append("colour=" + ColourSchemeProperty.getColourName(sg.cs) + + "\t"); if (sg.cs.getThreshold() != 0) { text.append("pidThreshold=" + sg.cs.getThreshold()); @@ -227,38 +312,57 @@ public class AnnotationFile text.append("consThreshold=" + sg.cs.getConservationInc() + "\t"); } } - text.append("outlineColour=" + - jalview.util.Format.getHexString(sg.getOutlineColour()) + - "\t"); + text.append("outlineColour=" + + jalview.util.Format.getHexString(sg.getOutlineColour()) + + "\t"); text.append("displayBoxes=" + sg.getDisplayBoxes() + "\t"); text.append("displayText=" + sg.getDisplayText() + "\t"); text.append("colourText=" + sg.getColourText() + "\t"); - + text.append("showUnconserved="+sg.getShowunconserved()+"\t"); if (sg.textColour != java.awt.Color.black) { - text.append("textCol1=" + - jalview.util.Format.getHexString(sg.textColour) + "\t"); + text.append("textCol1=" + + jalview.util.Format.getHexString(sg.textColour) + "\t"); } if (sg.textColour2 != java.awt.Color.white) { - text.append("textCol2=" + - jalview.util.Format.getHexString(sg.textColour2) + "\t"); + text.append("textCol2=" + + jalview.util.Format.getHexString(sg.textColour2) + "\t"); } if (sg.thresholdTextColour != 0) { - text.append("textColThreshold=" + sg.thresholdTextColour); + text.append("textColThreshold=" + sg.thresholdTextColour+"\t"); + } + if (sg.idColour != null) + { + text.append("idColour=" + + jalview.util.Format.getHexString(sg.idColour) + "\t"); + } + if (sg.isHidereps()) + { + text.append("hide=true\t"); + } + if (sg.isHideCols()) + { + text.append("hidecols=true\t"); + } + if (seqrep!=null) + { + // terminate the last line and clear the sequence ref for the group + text.append("\nSEQUENCE_REF"); } - text.append("\n\n"); } } SequenceI refSeq = null; - public boolean readAnnotationFile(AlignmentI al, - String file, - String protocol) + + String refSeqId = null; + + public boolean readAnnotationFile(AlignmentI al, String file, + String protocol) { try { @@ -302,7 +406,7 @@ public class AnnotationFile // First confirm this is an Annotation file boolean jvAnnotationFile = false; - while ( (line = in.readLine()) != null) + while ((line = in.readLine()) != null) { if (line.indexOf("#") == 0) { @@ -322,11 +426,11 @@ public class AnnotationFile return false; } - while ( (line = in.readLine()) != null) + while ((line = in.readLine()) != null) { if (line.indexOf("#") == 0 - || line.indexOf("JALVIEW_ANNOTATION") > -1 - || line.length() == 0) + || line.indexOf("JALVIEW_ANNOTATION") > -1 + || line.length() == 0) { continue; } @@ -335,6 +439,7 @@ public class AnnotationFile token = st.nextToken(); if (token.equalsIgnoreCase("COLOUR")) { + // TODO: use graduated colour def'n here too colourAnnotations(al, st.nextToken(), st.nextToken()); continue; } @@ -353,23 +458,33 @@ public class AnnotationFile else if (token.equalsIgnoreCase("SEQUENCE_REF")) { - refSeq = al.findName(st.nextToken()); - try + if (st.hasMoreTokens()) { - refSeqIndex = Integer.parseInt(st.nextToken()); - if (refSeqIndex < 1) + refSeq = al.findName(refSeqId = st.nextToken()); + if (refSeq == null) + { + refSeqId = null; + } + try + { + refSeqIndex = Integer.parseInt(st.nextToken()); + if (refSeqIndex < 1) + { + refSeqIndex = 1; + System.out + .println("WARNING: SEQUENCE_REF index must be > 0 in AnnotationFile"); + } + } catch (Exception ex) { refSeqIndex = 1; - System.out.println( - "WARNING: SEQUENCE_REF index must be > 0 in AnnotationFile"); } } - catch (Exception ex) + else { - refSeqIndex = 1; + refSeq = null; + refSeqId = null; } - - continue ; + continue; } else if (token.equalsIgnoreCase("SEQUENCE_GROUP")) @@ -384,67 +499,119 @@ public class AnnotationFile continue; } - graphStyle = AlignmentAnnotation.getGraphValueFromString(token); - label = st.nextToken(); - - if (st.countTokens() > 1) + else if (token.equalsIgnoreCase("BELOW_ALIGNMENT")) { - description = st.nextToken(); + setBelowAlignment(al, st); + continue; } - else + else if (token.equalsIgnoreCase("ALIGNMENT")) { - description = null; + addAlignmentDetails(al, st); + continue; } - line = st.nextToken(); - - st = new StringTokenizer(line, "|", true); - annotations = new Annotation[alWidth]; + graphStyle = AlignmentAnnotation.getGraphValueFromString(token); + label = st.nextToken(); index = 0; - boolean emptyColumn = true; + annotations = new Annotation[alWidth]; + description = null; + float score = Float.NaN; - while (st.hasMoreElements() && index < alWidth) + if (st.hasMoreTokens()) { - token = st.nextToken().trim(); - if (token.equals("|")) + line = st.nextToken(); + + if (line.indexOf("|") == -1) { - if (emptyColumn) - { - index++; - } + description = line; + if (st.hasMoreTokens()) + line = st.nextToken(); + } - emptyColumn = true; + if (st.hasMoreTokens()) + { + // This must be the score + score = Float.valueOf(st.nextToken()).floatValue(); } - else + + st = new StringTokenizer(line, "|", true); + + boolean emptyColumn = true; + boolean onlyOneElement = (st.countTokens() == 1); + + while (st.hasMoreElements() && index < alWidth) { - annotations[index++] = parseAnnotation(token); - emptyColumn = false; + token = st.nextToken().trim(); + + if (onlyOneElement) + { + try + { + score = Float.valueOf(token).floatValue(); + break; + } catch (NumberFormatException ex) + { + } + } + + if (token.equals("|")) + { + if (emptyColumn) + { + index++; + } + + emptyColumn = true; + } + else + { + annotations[index++] = parseAnnotation(token); + emptyColumn = false; + } } + } - annotation = new AlignmentAnnotation(label, - description, - annotations, - 0, - 0, - graphStyle); + annotation = new AlignmentAnnotation(label, description, + (index == 0) ? null : annotations, 0, 0, graphStyle); + + annotation.score = score; if (refSeq != null) { - annotation.createSequenceMapping(refSeq, refSeqIndex, false); - refSeq.addAlignmentAnnotation(annotation); + annotation.belowAlignment = false; + // make a copy of refSeq so we can find other matches in the alignment + SequenceI referedSeq = refSeq; + do + { + // copy before we do any mapping business. + // TODO: verify that undo/redo with 1:many sequence associated + // annotations can be undone correctly + AlignmentAnnotation ann = new AlignmentAnnotation(annotation); + annotation.createSequenceMapping(referedSeq, refSeqIndex, false); + annotation.adjustForAlignment(); + referedSeq.addAlignmentAnnotation(annotation); + al.addAnnotation(annotation); + al.setAnnotationIndex(annotation, + al.getAlignmentAnnotation().length + - existingAnnotations - 1); + // and recover our virgin copy to use again if necessary. + annotation = ann; + + } while (refSeqId != null + && (referedSeq = al.findName(referedSeq, refSeqId, true)) != null); + } + else + { + al.addAnnotation(annotation); + al.setAnnotationIndex(annotation, + al.getAlignmentAnnotation().length - existingAnnotations + - 1); } - - al.addAnnotation(annotation); - - al.setAnnotationIndex(annotation, - al.getAlignmentAnnotation().length - existingAnnotations - - 1); } - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); System.out.println("Problem reading annotation file: " + ex); @@ -455,10 +622,24 @@ public class AnnotationFile Annotation parseAnnotation(String string) { - String desc = null, displayChar = ""; + String desc = null, displayChar = null; char ss = ' '; // secondaryStructure float value = 0; - boolean parsedValue = false; + boolean parsedValue = false,dcset=false; + + // find colour here + java.awt.Color colour = null; + int i = string.indexOf("["); + int j = string.indexOf("]"); + if (i > -1 && j > -1) + { + UserColourScheme ucs = new UserColourScheme(); + + colour = ucs.getColourFromString(string.substring(i + 1, j)); + + string = string.substring(0, i) + string.substring(j + 1); + } + StringTokenizer st = new StringTokenizer(string, ","); String token; while (st.hasMoreTokens()) @@ -466,6 +647,12 @@ public class AnnotationFile token = st.nextToken().trim(); if (token.length() == 0) { + if (parsedValue && !dcset) + { + // allow the value below the bar/line to be empty + dcset=true; + displayChar = ""; + } continue; } @@ -477,9 +664,9 @@ public class AnnotationFile value = new Float(token).floatValue(); parsedValue = true; continue; + } catch (NumberFormatException ex) + { } - catch (NumberFormatException ex) - {} } if (token.equals("H") || token.equals("E")) @@ -499,19 +686,24 @@ public class AnnotationFile } - if (desc == null) - { - desc = value + ""; - } - - if (displayChar.length() > 1 && desc.length() == 1) + if (displayChar != null && displayChar.length() > 1 && desc != null + && desc.length() == 1) { String tmp = displayChar; displayChar = desc; desc = tmp; } + /* + * In principle, this code will ensure that the Annotation element generated + * is renderable by any of the applet or application rendering code but + * instead we check for null strings when the display character is rendered. + * if (displayChar==null) { displayChar=""; } + */ + Annotation anot = new Annotation(displayChar, desc, ss, value); + + anot.colour = colour; - return new Annotation(displayChar, desc, ss, value); + return anot; } void colourAnnotations(AlignmentI al, String label, String colour) @@ -538,7 +730,7 @@ public class AnnotationFile { int graphGroup = -1; String group = st.nextToken(); - //First make sure we are not overwriting the graphIndex + // First make sure we are not overwriting the graphIndex for (int i = 0; i < al.getAlignmentAnnotation().length; i++) { if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group)) @@ -549,7 +741,7 @@ public class AnnotationFile } } - //Now update groups + // Now update groups while (st.hasMoreTokens()) { group = st.nextToken(); @@ -593,13 +785,33 @@ public class AnnotationFile annotation.setThreshold(new GraphLine(value, label, colour)); } - void addGroup(AlignmentI al, StringTokenizer st) { SequenceGroup sg = new SequenceGroup(); sg.setName(st.nextToken()); - sg.setStartRes(Integer.parseInt(st.nextToken()) - 1); - sg.setEndRes(Integer.parseInt(st.nextToken()) - 1); + String rng =""; + try { + rng = st.nextToken(); + if (rng.length()>0 && !rng.startsWith("*")) + { + sg.setStartRes(Integer.parseInt(rng) - 1); + } else { + sg.setStartRes(0); + } + rng = st.nextToken(); + if (rng.length()>0 && !rng.startsWith("*")) + { + sg.setEndRes(Integer.parseInt(rng) - 1); + } else { + sg.setEndRes(al.getWidth()-1); + } + } catch (Exception e) + { + System.err.println("Couldn't parse Group Start or End Field as '*' or a valid column or sequence index: '"+rng+"' - assuming alignment width for group."); + // assume group is full width + sg.setStartRes(0); + sg.setEndRes(al.getWidth()-1); + } String index = st.nextToken(); if (index.equals("-1")) @@ -640,7 +852,9 @@ public class AnnotationFile } else { - sg.addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), false); + sg + .addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), + false); } } } @@ -649,6 +863,7 @@ public class AnnotationFile { sg.setStartRes(refSeq.findIndex(sg.getStartRes() + 1) - 1); sg.setEndRes(refSeq.findIndex(sg.getEndRes() + 1) - 1); + sg.setSeqrep(refSeq); } if (sg.getSize() > 0) @@ -660,9 +875,9 @@ public class AnnotationFile void addProperties(AlignmentI al, StringTokenizer st) { - //So far we have only added groups to the annotationHash, - //the idea is in the future properties can be added to - //alignments, other annotations etc + // So far we have only added groups to the annotationHash, + // the idea is in the future properties can be added to + // alignments, other annotations etc if (al.getGroups() == null) { return; @@ -688,6 +903,8 @@ public class AnnotationFile if (sg != null) { String keyValue, key, value; + ColourSchemeI def = sg.cs; + sg.cs = null; while (st.hasMoreTokens()) { keyValue = st.nextToken(); @@ -711,10 +928,8 @@ public class AnnotationFile { sg.cs.setConservationInc(Integer.parseInt(value)); Conservation c = new Conservation("Group", - ResidueProperties.propHash, 3, - sg.getSequences(null), - sg.getStartRes(), - sg.getEndRes() + 1); + ResidueProperties.propHash, 3, sg.getSequences(null), sg + .getStartRes(), sg.getEndRes() + 1); c.calculate(); c.verdict(false, 25); @@ -730,6 +945,10 @@ public class AnnotationFile { sg.setDisplayBoxes(Boolean.valueOf(value).booleanValue()); } + else if (key.equalsIgnoreCase("showUnconserved")) + { + sg.setShowunconserved(Boolean.valueOf(value).booleanValue()); + } else if (key.equalsIgnoreCase("displayText")) { sg.setDisplayText(Boolean.valueOf(value).booleanValue()); @@ -750,9 +969,92 @@ public class AnnotationFile { sg.thresholdTextColour = Integer.parseInt(value); } - + else if (key.equalsIgnoreCase("idColour")) + { + // consider warning if colour doesn't resolve to a real colour + sg.setIdColour((def = new UserColourScheme(value)) + .findColour('A')); + } + else if (key.equalsIgnoreCase("hide")) + { + // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847 + sg.setHidereps(true); + } + else if (key.equalsIgnoreCase("hidecols")) + { + // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847 + sg.setHideCols(true); + } sg.recalcConservation(); } + if (sg.cs == null) + { + sg.cs = def; + } + } + } + + void setBelowAlignment(AlignmentI al, StringTokenizer st) + { + String token; + AlignmentAnnotation aa; + while (st.hasMoreTokens()) + { + token = st.nextToken(); + for (int i = 0; i < al.getAlignmentAnnotation().length; i++) + { + aa = al.getAlignmentAnnotation()[i]; + if (aa.sequenceRef == refSeq && aa.label.equals(token)) + { + aa.belowAlignment = true; + } + } + } + } + + void addAlignmentDetails(AlignmentI al, StringTokenizer st) + { + String keyValue, key, value; + while (st.hasMoreTokens()) + { + keyValue = st.nextToken(); + key = keyValue.substring(0, keyValue.indexOf("=")); + value = keyValue.substring(keyValue.indexOf("=") + 1); + al.setProperty(key, value); + } + } + + /** + * Write annotations as a CSV file of the form 'label, value, value, ...' for + * each row. + * + * @param annotations + * @return CSV file as a string. + */ + public String printCSVAnnotations(AlignmentAnnotation[] annotations) + { + StringBuffer sp = new StringBuffer(); + for (int i = 0; i < annotations.length; i++) + { + String atos = annotations[i].toString(); + int p = 0; + do + { + int cp = atos.indexOf("\n", p); + sp.append(annotations[i].label); + sp.append(","); + if (cp > p) + { + sp.append(atos.substring(p, cp + 1)); + } + else + { + sp.append(atos.substring(p)); + sp.append("\n"); + } + p = cp + 1; + } while (p > 0); } + return sp.toString(); } }