X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignmentAnnotation.java;h=f36a5c4584eab1b045896d11d853e412cbc103ea;hb=c19d2a91ca05e052e3408bf5852d88eb5d0608f1;hp=78f64ac9a77ec5cc80a4b9dc9b02dbb3de24dc10;hpb=422beff9bcaf1813684e23647889bbb7c822cfae;p=jalview.git diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java index 78f64ac..f36a5c4 100755 --- a/src/jalview/datamodel/AlignmentAnnotation.java +++ b/src/jalview/datamodel/AlignmentAnnotation.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 2.9.0b2) + * Copyright (C) 2015 The Jalview Authors * * This file is part of Jalview. * @@ -25,9 +25,10 @@ import jalview.analysis.SecStrConsensus.SimpleBP; import jalview.analysis.WUSSParseException; import java.util.ArrayList; -import java.util.Enumeration; +import java.util.Collection; +import java.util.Collections; import java.util.HashMap; -import java.util.Hashtable; +import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; @@ -39,23 +40,43 @@ import java.util.Map.Entry; */ public class AlignmentAnnotation { + private static final String ANNOTATION_ID_PREFIX = "ann"; + + /* + * Identifers for different types of profile data + */ + public static final int SEQUENCE_PROFILE = 0; + + public static final int STRUCTURE_PROFILE = 1; + + public static final int CDNA_PROFILE = 2; + + private static long counter = 0; + /** * If true, this annotations is calculated every edit, eg consensus, quality * or conservation graphs */ public boolean autoCalculated = false; + /** + * unique ID for this annotation, used to match up the same annotation row + * shown in multiple views and alignments + */ public String annotationId; + /** + * the sequence this annotation is associated with (or null) + */ public SequenceI sequenceRef; - /** DOCUMENT ME!! */ + /** label shown in dropdown menus and in the annotation label area */ public String label; - /** DOCUMENT ME!! */ + /** longer description text shown as a tooltip */ public String description; - /** DOCUMENT ME!! */ + /** Array of annotations placed in the current coordinate system */ public Annotation[] annotations; public ArrayList bps = null; @@ -66,9 +87,10 @@ public class AlignmentAnnotation public SequenceFeature[] _rnasecstr = null; /** - * position of annotation resulting in invalid WUSS parsing or -1 + * position of annotation resulting in invalid WUSS parsing or -1. -2 means + * there was no RNA structure in this annotation */ - private long invalidrnastruc = -1; + private long invalidrnastruc = -2; /** * Updates the _rnasecstr field Determines the positions that base pair and @@ -101,11 +123,52 @@ public class AlignmentAnnotation isrna = true; showAllColLabels = true; scaleColLabel = true; + _markRnaHelices(); } // System.out.println("featuregroup " + _rnasecstr[0].getFeatureGroup()); + + } + + private void _markRnaHelices() + { + int mxval = 0; + // Figure out number of helices + // Length of rnasecstr is the number of pairs of positions that base pair + // with each other in the secondary structure + for (int x = 0; x < _rnasecstr.length; x++) + { + + /* + * System.out.println(this.annotation._rnasecstr[x] + " Begin" + + * this.annotation._rnasecstr[x].getBegin()); + */ + // System.out.println(this.annotation._rnasecstr[x].getFeatureGroup()); + int val = 0; + try + { + val = Integer.valueOf(_rnasecstr[x].getFeatureGroup()); + if (mxval < val) + { + mxval = val; + } + } catch (NumberFormatException q) + { + } + ; + + annotations[_rnasecstr[x].getBegin()].value = val; + annotations[_rnasecstr[x].getEnd()].value = val; + + // annotations[_rnasecstr[x].getBegin()].displayCharacter = "" + val; + // annotations[_rnasecstr[x].getEnd()].displayCharacter = "" + val; + } + setScore(mxval); } - public java.util.Hashtable sequenceMapping; + /** + * map of positions in the associated annotation + */ + private Map sequenceMapping; /** DOCUMENT ME!! */ public float graphMin; @@ -224,6 +287,7 @@ public class AlignmentAnnotation public AlignmentAnnotation(String label, String description, Annotation[] annotations) { + setAnnotationId(); // always editable? editable = true; this.label = label; @@ -400,8 +464,6 @@ public class AlignmentAnnotation _updateRnaSecStr(new AnnotCharSequence()); } } - - annotationId = this.hashCode() + ""; } /** @@ -443,13 +505,17 @@ public class AlignmentAnnotation @Override public char charAt(int index) { - String dc; return ((index + offset < 0) || (index + offset) >= max - || annotations[index + offset] == null || (dc = annotations[index - + offset].displayCharacter.trim()).length() < 1) ? '.' : dc - .charAt(0); + || annotations[index + offset] == null + || (annotations[index + offset].secondaryStructure <= ' ') ? ' ' + : annotations[index + offset].displayCharacter == null + || annotations[index + offset].displayCharacter + .length() == 0 ? annotations[index + offset].secondaryStructure + : annotations[index + offset].displayCharacter + .charAt(0)); } + @Override public String toString() { char[] string = new char[max - offset]; @@ -457,9 +523,10 @@ public class AlignmentAnnotation for (int i = offset; i < mx; i++) { - String dc; - string[i] = (annotations[i] == null || (dc = annotations[i].displayCharacter - .trim()).length() < 1) ? '.' : dc.charAt(0); + string[i] = (annotations[i] == null || (annotations[i].secondaryStructure <= 32)) ? ' ' + : (annotations[i].displayCharacter == null + || annotations[i].displayCharacter.length() == 0 ? annotations[i].secondaryStructure + : annotations[i].displayCharacter.charAt(0)); } return new String(string); } @@ -502,6 +569,7 @@ public class AlignmentAnnotation public AlignmentAnnotation(String label, String description, Annotation[] annotations, float min, float max, int graphType) { + setAnnotationId(); // graphs are not editable editable = graphType == 0; @@ -587,7 +655,7 @@ public class AlignmentAnnotation { if (annotations[i] != null) { - annotations[i].displayCharacter = "X"; + annotations[i].displayCharacter = ""; } } } @@ -601,6 +669,7 @@ public class AlignmentAnnotation */ public AlignmentAnnotation(AlignmentAnnotation annotation) { + setAnnotationId(); this.label = new String(annotation.label); if (annotation.description != null) { @@ -624,6 +693,14 @@ public class AlignmentAnnotation this.scaleColLabel = annotation.scaleColLabel; this.showAllColLabels = annotation.showAllColLabels; this.calcId = annotation.calcId; + if (annotation.properties != null) + { + properties = new HashMap(); + for (Map.Entry val : annotation.properties.entrySet()) + { + properties.put(val.getKey(), val.getValue()); + } + } if (this.hasScore = annotation.hasScore) { this.score = annotation.score; @@ -632,9 +709,9 @@ public class AlignmentAnnotation { threshold = new GraphLine(annotation.threshold); } + Annotation[] ann = annotation.annotations; if (annotation.annotations != null) { - Annotation[] ann = annotation.annotations; this.annotations = new Annotation[ann.length]; for (int i = 0; i < ann.length; i++) { @@ -647,24 +724,27 @@ public class AlignmentAnnotation } } } - ; - if (annotation.sequenceRef != null) + } + if (annotation.sequenceRef != null) + { + this.sequenceRef = annotation.sequenceRef; + if (annotation.sequenceMapping != null) { - this.sequenceRef = annotation.sequenceRef; - if (annotation.sequenceMapping != null) + Integer p = null; + sequenceMapping = new HashMap(); + Iterator pos = annotation.sequenceMapping.keySet() + .iterator(); + while (pos.hasNext()) { - Integer p = null; - sequenceMapping = new Hashtable(); - Enumeration pos = annotation.sequenceMapping.keys(); - while (pos.hasMoreElements()) + // could optimise this! + p = pos.next(); + Annotation a = annotation.sequenceMapping.get(p); + if (a == null) + { + continue; + } + if (ann != null) { - // could optimise this! - p = (Integer) pos.nextElement(); - Annotation a = annotation.sequenceMapping.get(p); - if (a == null) - { - continue; - } for (int i = 0; i < ann.length; i++) { if (ann[i] == a) @@ -674,10 +754,10 @@ public class AlignmentAnnotation } } } - else - { - this.sequenceMapping = null; - } + } + else + { + this.sequenceMapping = null; } } // TODO: check if we need to do this: JAL-952 @@ -731,11 +811,11 @@ public class AlignmentAnnotation int epos = sequenceRef.findPosition(endRes); if (sequenceMapping != null) { - Hashtable newmapping = new Hashtable(); - Enumeration e = sequenceMapping.keys(); - while (e.hasMoreElements()) + Map newmapping = new HashMap(); + Iterator e = sequenceMapping.keySet().iterator(); + while (e.hasNext()) { - Integer pos = (Integer) e.nextElement(); + Integer pos = e.next(); if (pos.intValue() >= spos && pos.intValue() <= epos) { newmapping.put(pos, sequenceMapping.get(pos)); @@ -778,9 +858,10 @@ public class AlignmentAnnotation * * @return DOCUMENT ME! */ + @Override public String toString() { - StringBuffer buffer = new StringBuffer(); + StringBuilder buffer = new StringBuilder(256); for (int i = 0; i < annotations.length; i++) { @@ -853,7 +934,7 @@ public class AlignmentAnnotation { return; } - sequenceMapping = new java.util.Hashtable(); + sequenceMapping = new HashMap(); int seqPos; @@ -876,6 +957,12 @@ public class AlignmentAnnotation } + /** + * When positional annotation and a sequence reference is present, clears and + * resizes the annotations array to the current alignment width, and adds + * annotation according to aligned positions of the sequenceRef given by + * sequenceMapping. + */ public void adjustForAlignment() { if (sequenceRef == null) @@ -899,18 +986,20 @@ public class AlignmentAnnotation int position; Annotation[] temp = new Annotation[aSize]; Integer index; - - for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++) + if (sequenceMapping != null) { - index = new Integer(a); - if (sequenceMapping.containsKey(index)) + for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++) { - position = sequenceRef.findIndex(a) - 1; + index = new Integer(a); + Annotation annot = sequenceMapping.get(index); + if (annot != null) + { + position = sequenceRef.findIndex(a) - 1; - temp[position] = sequenceMapping.get(index); + temp[position] = annot; + } } } - annotations = temp; } @@ -947,11 +1036,11 @@ public class AlignmentAnnotation } /** - * Associate this annotion with the aligned residues of a particular sequence. - * sequenceMapping will be updated in the following way: null sequenceI - - * existing mapping will be discarded but annotations left in mapped - * positions. valid sequenceI not equal to current sequenceRef: mapping is - * discarded and rebuilt assuming 1:1 correspondence TODO: overload with + * Associate this annotation with the aligned residues of a particular + * sequence. sequenceMapping will be updated in the following way: null + * sequenceI - existing mapping will be discarded but annotations left in + * mapped positions. valid sequenceI not equal to current sequenceRef: mapping + * is discarded and rebuilt assuming 1:1 correspondence TODO: overload with * parameter to specify correspondence between current and new sequenceRef * * @param sequenceI @@ -962,7 +1051,8 @@ public class AlignmentAnnotation { if (sequenceRef != null) { - boolean rIsDs=sequenceRef.getDatasetSequence()==null,tIsDs=sequenceI.getDatasetSequence()==null; + boolean rIsDs = sequenceRef.getDatasetSequence() == null, tIsDs = sequenceI + .getDatasetSequence() == null; if (sequenceRef != sequenceI && (rIsDs && !tIsDs && sequenceRef != sequenceI .getDatasetSequence()) @@ -1158,14 +1248,16 @@ public class AlignmentAnnotation { if (sp2sq.getMappedWidth() != sp2sq.getWidth()) { - // TODO: employ getWord/MappedWord to transfer annotation between cDNA and Protein reference frames - throw new Error("liftOver currently not implemented for transfer of annotation between different types of seqeunce"); + // TODO: employ getWord/MappedWord to transfer annotation between cDNA and + // Protein reference frames + throw new Error( + "liftOver currently not implemented for transfer of annotation between different types of seqeunce"); } boolean mapIsTo = (sp2sq != null) ? (sp2sq.getTo() == sq || sp2sq .getTo() == sq.getDatasetSequence()) : false; // TODO build a better annotation element map and get rid of annotations[] - Hashtable mapForsq = new Hashtable(); + Map mapForsq = new HashMap(); if (sequenceMapping != null) { if (sp2sq != null) @@ -1217,7 +1309,8 @@ public class AlignmentAnnotation { if (mapping != null) { - Hashtable old = sequenceMapping, remap = new Hashtable(); + Map old = sequenceMapping; + Map remap = new HashMap(); int index = -1; for (int mp[] : mapping) { @@ -1262,7 +1355,7 @@ public class AlignmentAnnotation } } - public Object getProperty(String property) + public String getProperty(String property) { if (properties == null) { @@ -1273,10 +1366,51 @@ public class AlignmentAnnotation public void setProperty(String property, String value) { - if (properties==null) + if (properties == null) { - properties = new HashMap(); + properties = new HashMap(); } properties.put(property, value); } + + public boolean hasProperties() + { + return properties != null && properties.size() > 0; + } + + public Collection getProperties() + { + if (properties == null) + { + return Collections.emptyList(); + } + return properties.keySet(); + } + + /** + * Returns the Annotation for the given sequence position (base 1) if any, + * else null + * + * @param position + * @return + */ + public Annotation getAnnotationForPosition(int position) + { + return sequenceMapping == null ? null : sequenceMapping.get(position); + + } + + /** + * Set the id to "ann" followed by a counter that increments so as to be + * unique for the lifetime of the JVM + */ + protected final void setAnnotationId() + { + this.annotationId = ANNOTATION_ID_PREFIX + Long.toString(nextId()); + } + + protected static synchronized long nextId() + { + return counter++; + } }