X-Git-Url: http://source.jalview.org/gitweb/?p=jalview.git;a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignmentAnnotation.java;h=0f418508abdd229bde007483606a24e5b448a996;hp=8d367a035731072287a7486b88a684a431a0c1bf;hb=0ae965fc73680bdc69b06986c060ff17342c4787;hpb=26f8448aa2e98602622538f31a4a635299c4748b diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java index 8d367a0..0f41850 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-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,17 +20,21 @@ */ package jalview.datamodel; -import jalview.analysis.Rna; -import jalview.analysis.SecStrConsensus.SimpleBP; -import jalview.analysis.WUSSParseException; - import java.util.ArrayList; -import java.util.Enumeration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; import java.util.HashMap; -import java.util.Hashtable; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; import java.util.Map; import java.util.Map.Entry; +import jalview.analysis.Rna; +import jalview.analysis.SecStrConsensus.SimpleBP; +import jalview.analysis.WUSSParseException; + /** * DOCUMENT ME! * @@ -39,6 +43,19 @@ 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 @@ -65,7 +82,7 @@ public class AlignmentAnnotation /** Array of annotations placed in the current coordinate system */ public Annotation[] annotations; - public ArrayList bps = null; + public List bps = null; /** * RNA secondary structure contact positions @@ -73,22 +90,22 @@ 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 * the positions of helices based on secondary structure from a Stockholm file * - * @param RNAannot + * @param rnaAnnotation */ - private void _updateRnaSecStr(CharSequence RNAannot) + private void _updateRnaSecStr(CharSequence rnaAnnotation) { try { - _rnasecstr = Rna.GetBasePairs(RNAannot); - bps = Rna.GetModeleBP(RNAannot); + _rnasecstr = Rna.getHelixMap(rnaAnnotation); invalidrnastruc = -1; } catch (WUSSParseException px) { @@ -99,8 +116,6 @@ public class AlignmentAnnotation { return; } - Rna.HelixMap(_rnasecstr); - // setRNAStruc(RNAannot); if (_rnasecstr != null && _rnasecstr.length > 0) { @@ -108,19 +123,127 @@ 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); + } + + /** + * Get the RNA Secondary Structure SequenceFeature Array if present + */ + public SequenceFeature[] getRnaSecondaryStructure() + { + return this._rnasecstr; + } + + /** + * Check the RNA Secondary Structure is equivalent to one in given + * AlignmentAnnotation param + */ + public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that) + { + return rnaSecondaryStructureEquivalent(that, true); + } + + public boolean rnaSecondaryStructureEquivalent(AlignmentAnnotation that, + boolean compareType) + { + SequenceFeature[] thisSfArray = this.getRnaSecondaryStructure(); + SequenceFeature[] thatSfArray = that.getRnaSecondaryStructure(); + if (thisSfArray == null || thatSfArray == null) + { + return thisSfArray == null && thatSfArray == null; + } + if (thisSfArray.length != thatSfArray.length) + { + return false; + } + Arrays.sort(thisSfArray, new SFSortByEnd()); // probably already sorted + // like this + Arrays.sort(thatSfArray, new SFSortByEnd()); // probably already sorted + // like this + for (int i = 0; i < thisSfArray.length; i++) + { + SequenceFeature thisSf = thisSfArray[i]; + SequenceFeature thatSf = thatSfArray[i]; + if (compareType) + { + if (thisSf.getType() == null || thatSf.getType() == null) + { + if (thisSf.getType() == null && thatSf.getType() == null) + { + continue; + } + else + { + return false; + } + } + if (!thisSf.getType().equals(thatSf.getType())) + { + return false; + } + } + if (!(thisSf.getBegin() == thatSf.getBegin() + && thisSf.getEnd() == thatSf.getEnd())) + { + return false; + } + } + return true; + } /** * map of positions in the associated annotation */ - public java.util.Hashtable sequenceMapping; + private Map sequenceMapping; - /** DOCUMENT ME!! */ + /** + * lower range for quantitative data + */ public float graphMin; - /** DOCUMENT ME!! */ + /** + * Upper range for quantitative data + */ public float graphMax; /** @@ -187,18 +310,6 @@ public class AlignmentAnnotation private boolean isrna; - /* - * (non-Javadoc) - * - * @see java.lang.Object#finalize() - */ - protected void finalize() throws Throwable - { - sequenceRef = null; - groupRef = null; - super.finalize(); - } - public static int getGraphValueFromString(String string) { if (string.equalsIgnoreCase("BAR_GRAPH")) @@ -215,12 +326,6 @@ public class AlignmentAnnotation } } - // JBPNote: what does this do ? - public void ConcenStru(CharSequence RNAannot) throws WUSSParseException - { - bps = Rna.GetModeleBP(RNAannot); - } - /** * Creates a new AlignmentAnnotation object. * @@ -234,6 +339,7 @@ public class AlignmentAnnotation public AlignmentAnnotation(String label, String description, Annotation[] annotations) { + setAnnotationId(); // always editable? editable = true; this.label = label; @@ -256,6 +362,7 @@ public class AlignmentAnnotation char firstChar = 0; for (int i = 0; i < annotations.length; i++) { + // DEBUG System.out.println(i + ": " + annotations[i]); if (annotations[i] == null) { continue; @@ -263,27 +370,35 @@ public class AlignmentAnnotation if (annotations[i].secondaryStructure == 'H' || annotations[i].secondaryStructure == 'E') { + // DEBUG System.out.println( "/H|E/ '" + + // annotations[i].secondaryStructure + "'"); hasIcons |= true; } else // Check for RNA secondary structure { - // System.out.println(annotations[i].secondaryStructure); + // DEBUG System.out.println( "/else/ '" + + // annotations[i].secondaryStructure + "'"); // TODO: 2.8.2 should this ss symbol validation check be a function in // RNA/ResidueProperties ? + // allow for DSSP extended code: + // https://www.wikidoc.org/index.php/Secondary_structure#The_DSSP_code + // GHITEBS as well as C and X (for missing?) if (annotations[i].secondaryStructure == '(' || annotations[i].secondaryStructure == '[' || annotations[i].secondaryStructure == '<' || annotations[i].secondaryStructure == '{' || annotations[i].secondaryStructure == 'A' - || annotations[i].secondaryStructure == 'B' - || annotations[i].secondaryStructure == 'C' + // || annotations[i].secondaryStructure == 'B' + // || annotations[i].secondaryStructure == 'C' || annotations[i].secondaryStructure == 'D' - || annotations[i].secondaryStructure == 'E' + // || annotations[i].secondaryStructure == 'E' // ambiguous on + // its own -- already checked above || annotations[i].secondaryStructure == 'F' - || annotations[i].secondaryStructure == 'G' - || annotations[i].secondaryStructure == 'H' - || annotations[i].secondaryStructure == 'I' + // || annotations[i].secondaryStructure == 'G' + // || annotations[i].secondaryStructure == 'H' // ambiguous on + // its own -- already checked above + // || annotations[i].secondaryStructure == 'I' || annotations[i].secondaryStructure == 'J' || annotations[i].secondaryStructure == 'K' || annotations[i].secondaryStructure == 'L' @@ -293,12 +408,12 @@ public class AlignmentAnnotation || annotations[i].secondaryStructure == 'P' || annotations[i].secondaryStructure == 'Q' || annotations[i].secondaryStructure == 'R' - || annotations[i].secondaryStructure == 'S' - || annotations[i].secondaryStructure == 'T' + // || annotations[i].secondaryStructure == 'S' + // || annotations[i].secondaryStructure == 'T' || annotations[i].secondaryStructure == 'U' || annotations[i].secondaryStructure == 'V' || annotations[i].secondaryStructure == 'W' - || annotations[i].secondaryStructure == 'X' + // || annotations[i].secondaryStructure == 'X' || annotations[i].secondaryStructure == 'Y' || annotations[i].secondaryStructure == 'Z') { @@ -320,49 +435,25 @@ public class AlignmentAnnotation firstChar = annotations[i].displayCharacter.charAt(0); // check to see if it looks like a sequence or is secondary structure // labelling. - if (annotations[i].secondaryStructure != ' ' - && !hasIcons - && - // Uncomment to only catch case where - // displayCharacter==secondary - // Structure - // to correctly redisplay SS annotation imported from Stockholm, - // exported to JalviewXML and read back in again. - // && - // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure - firstChar != ' ' - && firstChar != '$' - && firstChar != 0xCE - && firstChar != '(' - && firstChar != '[' - && firstChar != '>' - && firstChar != '{' - && firstChar != 'A' - && firstChar != 'B' - && firstChar != 'C' - && firstChar != 'D' - && firstChar != 'E' - && firstChar != 'F' - && firstChar != 'G' - && firstChar != 'H' - && firstChar != 'I' - && firstChar != 'J' - && firstChar != 'K' - && firstChar != 'L' - && firstChar != 'M' - && firstChar != 'N' - && firstChar != 'O' - && firstChar != 'P' - && firstChar != 'Q' - && firstChar != 'R' - && firstChar != 'S' - && firstChar != 'T' - && firstChar != 'U' - && firstChar != 'V' - && firstChar != 'W' - && firstChar != 'X' - && firstChar != 'Y' - && firstChar != 'Z' + if (annotations[i].secondaryStructure != ' ' && !hasIcons && + // Uncomment to only catch case where + // displayCharacter==secondary + // Structure + // to correctly redisplay SS annotation imported from Stockholm, + // exported to JalviewXML and read back in again. + // && + // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure + firstChar != ' ' && firstChar != '$' && firstChar != 0xCE + && firstChar != '(' && firstChar != '[' && firstChar != '<' + && firstChar != '{' && firstChar != 'A' && firstChar != 'B' + && firstChar != 'C' && firstChar != 'D' && firstChar != 'E' + && firstChar != 'F' && firstChar != 'G' && firstChar != 'H' + && firstChar != 'I' && firstChar != 'J' && firstChar != 'K' + && firstChar != 'L' && firstChar != 'M' && firstChar != 'N' + && firstChar != 'O' && firstChar != 'P' && firstChar != 'Q' + && firstChar != 'R' && firstChar != 'S' && firstChar != 'T' + && firstChar != 'U' && firstChar != 'V' && firstChar != 'W' + && firstChar != 'X' && firstChar != 'Y' && firstChar != 'Z' && firstChar != '-' && firstChar < jalview.schemes.ResidueProperties.aaIndex.length) { @@ -410,8 +501,6 @@ public class AlignmentAnnotation _updateRnaSecStr(new AnnotCharSequence()); } } - - annotationId = this.hashCode() + ""; } /** @@ -432,7 +521,7 @@ public class AlignmentAnnotation this(0, annotations.length); } - public AnnotCharSequence(int start, int end) + AnnotCharSequence(int start, int end) { offset = start; max = end; @@ -453,13 +542,22 @@ 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]; @@ -467,9 +565,15 @@ 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); } @@ -512,6 +616,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; @@ -534,6 +639,7 @@ public class AlignmentAnnotation if (annotations == null) { visible = false; // try to prevent renderer from displaying. + invalidrnastruc = -1; return; // this is a non-annotation row annotation - ie a sequence score. } @@ -597,7 +703,7 @@ public class AlignmentAnnotation { if (annotations[i] != null) { - annotations[i].displayCharacter = "X"; + annotations[i].displayCharacter = ""; } } } @@ -611,6 +717,7 @@ public class AlignmentAnnotation */ public AlignmentAnnotation(AlignmentAnnotation annotation) { + setAnnotationId(); this.label = new String(annotation.label); if (annotation.description != null) { @@ -634,10 +741,10 @@ public class AlignmentAnnotation this.scaleColLabel = annotation.scaleColLabel; this.showAllColLabels = annotation.showAllColLabels; this.calcId = annotation.calcId; - if (annotation.properties!=null) + if (annotation.properties != null) { - properties = new HashMap(); - for (Map.Entry val:annotation.properties.entrySet()) + properties = new HashMap<>(); + for (Map.Entry val : annotation.properties.entrySet()) { properties.put(val.getKey(), val.getValue()); } @@ -672,12 +779,13 @@ public class AlignmentAnnotation if (annotation.sequenceMapping != null) { Integer p = null; - sequenceMapping = new Hashtable(); - Enumeration pos = annotation.sequenceMapping.keys(); - while (pos.hasMoreElements()) + sequenceMapping = new HashMap<>(); + Iterator pos = annotation.sequenceMapping.keySet() + .iterator(); + while (pos.hasNext()) { // could optimise this! - p = (Integer) pos.nextElement(); + p = pos.next(); Annotation a = annotation.sequenceMapping.get(p); if (a == null) { @@ -694,10 +802,10 @@ public class AlignmentAnnotation } } } - else - { - this.sequenceMapping = null; - } + } + else + { + this.sequenceMapping = null; } } // TODO: check if we need to do this: JAL-952 @@ -741,8 +849,8 @@ public class AlignmentAnnotation Annotation[] temp = new Annotation[endRes - startRes + 1]; if (startRes < annotations.length) { - System.arraycopy(annotations, startRes, temp, 0, endRes - startRes - + 1); + System.arraycopy(annotations, startRes, temp, 0, + endRes - startRes + 1); } if (sequenceRef != null) { @@ -751,11 +859,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)); @@ -798,9 +906,14 @@ public class AlignmentAnnotation * * @return DOCUMENT ME! */ + @Override public String toString() { - StringBuffer buffer = new StringBuffer(); + if (annotations == null) + { + return ""; + } + StringBuilder buffer = new StringBuilder(256); for (int i = 0; i < annotations.length; i++) { @@ -873,7 +986,7 @@ public class AlignmentAnnotation { return; } - sequenceMapping = new java.util.Hashtable(); + sequenceMapping = new HashMap<>(); int seqPos; @@ -890,12 +1003,18 @@ public class AlignmentAnnotation seqPos = i + startRes; } - sequenceMapping.put(new Integer(seqPos), annotations[i]); + sequenceMapping.put(Integer.valueOf(seqPos), annotations[i]); } } } + /** + * 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) @@ -919,18 +1038,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 = Integer.valueOf(a); + Annotation annot = sequenceMapping.get(index); + if (annot != null) + { + position = sequenceRef.findIndex(a) - 1; - temp[position] = sequenceMapping.get(index); + temp[position] = annot; + } } } - annotations = temp; } @@ -949,8 +1070,8 @@ public class AlignmentAnnotation { if (i + 1 < iSize) { - System.arraycopy(annotations, i + 1, annotations, i, iSize - i - - 1); + System.arraycopy(annotations, i + 1, annotations, i, + iSize - i - 1); } iSize--; } @@ -967,11 +1088,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 @@ -982,13 +1103,16 @@ 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()) - && (!rIsDs && tIsDs && sequenceRef.getDatasetSequence() != sequenceI) - && (!rIsDs && !tIsDs && sequenceRef.getDatasetSequence() != sequenceI - .getDatasetSequence()) + && (rIsDs && !tIsDs + && sequenceRef != sequenceI.getDatasetSequence()) + && (!rIsDs && tIsDs + && sequenceRef.getDatasetSequence() != sequenceI) + && (!rIsDs && !tIsDs + && sequenceRef.getDatasetSequence() != sequenceI + .getDatasetSequence()) && !sequenceRef.equals(sequenceI)) { // if sequenceRef isn't intersecting with sequenceI @@ -1070,14 +1194,14 @@ public class AlignmentAnnotation * @param colSel */ public AlignmentAnnotation(AlignmentAnnotation alignmentAnnotation, - ColumnSelection colSel) + HiddenColumns hidden) { this(alignmentAnnotation); if (annotations == null) { return; } - colSel.makeVisibleAnnotation(this); + makeVisibleAnnotation(hidden); } public void setPadGaps(boolean padgaps, char gapchar) @@ -1113,7 +1237,7 @@ public class AlignmentAnnotation { if (seqname && this.sequenceRef != null) { - int i = description.toLowerCase().indexOf(""); + int i = description.toLowerCase(Locale.ROOT).indexOf(""); if (i > -1) { // move the html tag to before the sequence reference. @@ -1143,7 +1267,7 @@ public class AlignmentAnnotation /** * properties associated with the calcId */ - protected Map properties = new HashMap(); + protected Map properties = new HashMap<>(); /** * base colour for line graphs. If null, will be set automatically by @@ -1178,23 +1302,27 @@ 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; + 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) { for (Entry ie : sequenceMapping.entrySet()) { - Integer mpos = Integer.valueOf(mapIsTo ? sp2sq - .getMappedPosition(ie.getKey()) : sp2sq.getPosition(ie - .getKey())); + Integer mpos = Integer + .valueOf(mapIsTo ? sp2sq.getMappedPosition(ie.getKey()) + : sp2sq.getPosition(ie.getKey())); if (mpos >= sq.getStart() && mpos <= sq.getEnd()) { mapForsq.put(mpos, ie.getValue()); @@ -1232,14 +1360,15 @@ public class AlignmentAnnotation * @note caller should add the remapped annotation to newref if they have not * already */ - public void remap(SequenceI newref, int[][] mapping, int from, int to, - int idxoffset) + public void remap(SequenceI newref, HashMap mapping, + int from, int to, int idxoffset) { if (mapping != null) { - Hashtable old = sequenceMapping, remap = new Hashtable(); + Map old = sequenceMapping; + Map remap = new HashMap<>(); int index = -1; - for (int mp[] : mapping) + for (int mp[] : mapping.values()) { if (index++ < 0) { @@ -1293,9 +1422,9 @@ 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); } @@ -1309,8 +1438,292 @@ public class AlignmentAnnotation { if (properties == null) { - return Collections.EMPTY_LIST; + 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()); + } + + /** + * Returns the match for the last unmatched opening RNA helix pair symbol + * preceding the given column, or '(' if nothing found to match. + * + * @param column + * @return + */ + public String getDefaultRnaHelixSymbol(int column) + { + String result = "("; + if (annotations == null) + { + return result; + } + + /* + * for each preceding column, if it contains an open bracket, + * count whether it is still unmatched at column, if so return its pair + * (likely faster than the fancy alternative using stacks) + */ + for (int col = column - 1; col >= 0; col--) + { + Annotation annotation = annotations[col]; + if (annotation == null) + { + continue; + } + String displayed = annotation.displayCharacter; + if (displayed == null || displayed.length() != 1) + { + continue; + } + char symbol = displayed.charAt(0); + if (!Rna.isOpeningParenthesis(symbol)) + { + continue; + } + + /* + * found an opening bracket symbol + * count (closing-opening) symbols of this type that follow it, + * up to and excluding the target column; if the count is less + * than 1, the opening bracket is unmatched, so return its match + */ + String closer = String + .valueOf(Rna.getMatchingClosingParenthesis(symbol)); + String opener = String.valueOf(symbol); + int count = 0; + for (int j = col + 1; j < column; j++) + { + if (annotations[j] != null) + { + String s = annotations[j].displayCharacter; + if (closer.equals(s)) + { + count++; + } + else if (opener.equals(s)) + { + count--; + } + } + } + if (count < 1) + { + return closer; + } + } + return result; + } + + protected static synchronized long nextId() + { + return counter++; + } + + /** + * + * @return true for rows that have a range of values in their annotation set + */ + public boolean isQuantitative() + { + return graphMin < graphMax; + } + + /** + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). + * + * @param hiddenColumns + * the set of hidden columns + */ + public void makeVisibleAnnotation(HiddenColumns hiddenColumns) + { + if (annotations != null) + { + makeVisibleAnnotation(0, annotations.length, hiddenColumns); + } + } + + /** + * delete any columns in alignmentAnnotation that are hidden (including + * sequence associated annotation). + * + * @param start + * remove any annotation to the right of this column + * @param end + * remove any annotation to the left of this column + * @param hiddenColumns + * the set of hidden columns + */ + public void makeVisibleAnnotation(int start, int end, + HiddenColumns hiddenColumns) + { + if (annotations != null) + { + if (hiddenColumns.hasHiddenColumns()) + { + removeHiddenAnnotation(start, end, hiddenColumns); + } + else + { + restrict(start, end); + } + } + } + + /** + * The actual implementation of deleting hidden annotation columns + * + * @param start + * remove any annotation to the right of this column + * @param end + * remove any annotation to the left of this column + * @param hiddenColumns + * the set of hidden columns + */ + private void removeHiddenAnnotation(int start, int end, + HiddenColumns hiddenColumns) + { + // mangle the alignmentAnnotation annotation array + ArrayList annels = new ArrayList<>(); + Annotation[] els = null; + + int w = 0; + + Iterator blocks = hiddenColumns.getVisContigsIterator(start, + end + 1, false); + + int copylength; + int annotationLength; + while (blocks.hasNext()) + { + int[] block = blocks.next(); + annotationLength = block[1] - block[0] + 1; + + if (blocks.hasNext()) + { + // copy just the visible segment of the annotation row + copylength = annotationLength; + } + else + { + if (annotationLength + block[0] <= annotations.length) + { + // copy just the visible segment of the annotation row + copylength = annotationLength; + } + else + { + // copy to the end of the annotation row + copylength = annotations.length - block[0]; + } + } + + els = new Annotation[annotationLength]; + annels.add(els); + System.arraycopy(annotations, block[0], els, 0, copylength); + w += annotationLength; + } + + if (w != 0) + { + annotations = new Annotation[w]; + + w = 0; + for (Annotation[] chnk : annels) + { + System.arraycopy(chnk, 0, annotations, w, chnk.length); + w += chnk.length; + } + } + } + + public static Iterable findAnnotations( + Iterable list, SequenceI seq, String calcId, + String label) + { + + ArrayList aa = new ArrayList<>(); + for (AlignmentAnnotation ann : list) + { + if ((calcId == null || (ann.getCalcId() != null + && ann.getCalcId().equals(calcId))) + && (seq == null || (ann.sequenceRef != null + && ann.sequenceRef == seq)) + && (label == null + || (ann.label != null && ann.label.equals(label)))) + { + aa.add(ann); + } + } + return aa; + } + + /** + * Answer true if any annotation matches the calcId passed in (if not null). + * + * @param list + * annotation to search + * @param calcId + * @return + */ + public static boolean hasAnnotation(List list, + String calcId) + { + + if (calcId != null && !"".equals(calcId)) + { + for (AlignmentAnnotation a : list) + { + if (a.getCalcId() == calcId) + { + return true; + } + } + } + return false; + } + + public static Iterable findAnnotation( + List list, String calcId) + { + + List aa = new ArrayList<>(); + if (calcId == null) + { + return aa; + } + for (AlignmentAnnotation a : list) + { + + if (a.getCalcId() == calcId || (a.getCalcId() != null + && calcId != null && a.getCalcId().equals(calcId))) + { + aa.add(a); + } + } + return aa; + } + }