X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignmentAnnotation.java;h=9550e836ed809b93c5e2fdbfcc4468f912c3ebef;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=9de07ddcc2b41f3fd9e44466e745f7067a060ecc;hpb=ff7e72d6df848ca0694d25bde0e9616e8df1d18e;p=jalview.git diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java index 9de07dd..9550e83 100755 --- a/src/jalview/datamodel/AlignmentAnnotation.java +++ b/src/jalview/datamodel/AlignmentAnnotation.java @@ -1,27 +1,37 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7) - * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, 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 . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.datamodel; import jalview.analysis.Rna; +import jalview.analysis.SecStrConsensus.SimpleBP; import jalview.analysis.WUSSParseException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.Enumeration; +import java.util.HashMap; import java.util.Hashtable; +import java.util.Map; +import java.util.Map.Entry; /** * DOCUMENT ME! @@ -37,27 +47,39 @@ public class AlignmentAnnotation */ 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; + /** * RNA secondary structure contact positions */ 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 @@ -66,31 +88,74 @@ public class AlignmentAnnotation */ private void _updateRnaSecStr(CharSequence RNAannot) { - try { - _rnasecstr = Rna.GetBasePairs(RNAannot); - invalidrnastruc=-1; - } - catch (WUSSParseException px) + try + { + _rnasecstr = Rna.GetBasePairs(RNAannot); + bps = Rna.GetModeleBP(RNAannot); + invalidrnastruc = -1; + } catch (WUSSParseException px) { - invalidrnastruc=px.getProblemPos(); + // DEBUG System.out.println(px); + invalidrnastruc = px.getProblemPos(); } - if (invalidrnastruc>-1) + if (invalidrnastruc > -1) { return; } Rna.HelixMap(_rnasecstr); // setRNAStruc(RNAannot); - + if (_rnasecstr != null && _rnasecstr.length > 0) { // show all the RNA secondary structure annotation symbols. - isrna=true; + 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 + */ + public java.util.Hashtable sequenceMapping; /** DOCUMENT ME!! */ public float graphMin; @@ -190,6 +255,12 @@ public class AlignmentAnnotation } } + // JBPNote: what does this do ? + public void ConcenStru(CharSequence RNAannot) throws WUSSParseException + { + bps = Rna.GetModeleBP(RNAannot); + } + /** * Creates a new AlignmentAnnotation object. * @@ -237,7 +308,39 @@ public class AlignmentAnnotation else // Check for RNA secondary structure { - if (annotations[i].secondaryStructure == 'S') + // System.out.println(annotations[i].secondaryStructure); + // TODO: 2.8.2 should this ss symbol validation check be a function in + // RNA/ResidueProperties ? + 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 == 'D' + || annotations[i].secondaryStructure == 'E' + || annotations[i].secondaryStructure == 'F' + || annotations[i].secondaryStructure == 'G' + || annotations[i].secondaryStructure == 'H' + || annotations[i].secondaryStructure == 'I' + || annotations[i].secondaryStructure == 'J' + || annotations[i].secondaryStructure == 'K' + || annotations[i].secondaryStructure == 'L' + || annotations[i].secondaryStructure == 'M' + || annotations[i].secondaryStructure == 'N' + || annotations[i].secondaryStructure == 'O' + || annotations[i].secondaryStructure == 'P' + || annotations[i].secondaryStructure == 'Q' + || annotations[i].secondaryStructure == 'R' + || 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 == 'Y' + || annotations[i].secondaryStructure == 'Z') { hasIcons |= true; isrna |= true; @@ -268,9 +371,38 @@ public class AlignmentAnnotation // && // annotations[i].displayCharacter.charAt(0)==annotations[i].secondaryStructure firstChar != ' ' - && firstChar != 'H' + && 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) { @@ -321,65 +453,77 @@ public class AlignmentAnnotation annotationId = this.hashCode() + ""; } + /** - * flyweight access to positions in the alignment annotation row for RNA processing + * flyweight access to positions in the alignment annotation row for RNA + * processing + * * @author jimp - * + * */ - private class AnnotCharSequence implements CharSequence + private class AnnotCharSequence implements CharSequence { - int offset=0; - int max=0; - - public AnnotCharSequence() { - this(0,annotations.length); + int offset = 0; + + int max = 0; + + public AnnotCharSequence() + { + this(0, annotations.length); } - public AnnotCharSequence(int start, int end) { - offset=start; - max=end; + + public AnnotCharSequence(int start, int end) + { + offset = start; + max = end; } + @Override public CharSequence subSequence(int start, int end) { - return new AnnotCharSequence(offset+start, offset+end); + return new AnnotCharSequence(offset + start, offset + end); } - + @Override public int length() { - return max-offset; + return max - offset; } - + @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); + return ((index + offset < 0) || (index + offset) >= max + || annotations[index + offset] == null || (annotations[index + + offset].secondaryStructure < ' ') ? ' ' + : annotations[index + offset].secondaryStructure); } + public String toString() { - char[] string=new char[max-offset]; - int mx=annotations.length; - - for (int i=offset;i 0) @@ -487,7 +635,7 @@ public class AlignmentAnnotation { if (annotations[i] != null) { - annotations[i].displayCharacter = ""; + annotations[i].displayCharacter = "X"; } } } @@ -503,7 +651,9 @@ public class AlignmentAnnotation { this.label = new String(annotation.label); if (annotation.description != null) + { this.description = new String(annotation.description); + } this.graphMin = annotation.graphMin; this.graphMax = annotation.graphMax; this.graph = annotation.graph; @@ -518,6 +668,18 @@ public class AlignmentAnnotation this.label = annotation.label; this.padGaps = annotation.padGaps; this.visible = annotation.visible; + this.centreColLabels = annotation.centreColLabels; + 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; @@ -526,32 +688,41 @@ 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++) { - annotations[i] = new Annotation(ann[i]); + if (ann[i] != null) + { + annotations[i] = new Annotation(ann[i]); + if (_linecolour != null) + { + _linecolour = annotations[i].colour; + } + } } - ; - 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 Hashtable(); + Enumeration pos = annotation.sequenceMapping.keys(); + while (pos.hasMoreElements()) { - Integer p = null; - sequenceMapping = new Hashtable(); - Enumeration pos = annotation.sequenceMapping.keys(); - while (pos.hasMoreElements()) + // could optimise this! + p = (Integer) pos.nextElement(); + Annotation a = annotation.sequenceMapping.get(p); + if (a == null) + { + continue; + } + if (ann != null) { - // could optimise this! - p = (Integer) pos.nextElement(); - Annotation a = (Annotation) annotation.sequenceMapping.get(p); - if (a == null) - { - continue; - } for (int i = 0; i < ann.length; i++) { if (ann[i] == a) @@ -561,11 +732,16 @@ public class AlignmentAnnotation } } } - else - { - this.sequenceMapping = null; - } } + else + { + this.sequenceMapping = null; + } + } + // TODO: check if we need to do this: JAL-952 + // if (this.isrna=annotation.isrna) + { + // _rnasecstr=new SequenceFeature[annotation._rnasecstr]; } validateRangeAndDisplay(); // construct hashcodes, etc. } @@ -585,13 +761,21 @@ public class AlignmentAnnotation return; } if (startRes < 0) + { startRes = 0; + } if (startRes >= annotations.length) + { startRes = annotations.length - 1; + } if (endRes >= annotations.length) + { endRes = annotations.length - 1; + } if (annotations == null) + { return; + } Annotation[] temp = new Annotation[endRes - startRes + 1]; if (startRes < annotations.length) { @@ -753,7 +937,9 @@ public class AlignmentAnnotation public void adjustForAlignment() { if (sequenceRef == null) + { return; + } if (annotations == null) { @@ -779,7 +965,7 @@ public class AlignmentAnnotation { position = sequenceRef.findIndex(a) - 1; - temp[position] = (Annotation) sequenceMapping.get(index); + temp[position] = sequenceMapping.get(index); } } @@ -800,8 +986,10 @@ public class AlignmentAnnotation if (annotations[i] == null) { if (i + 1 < iSize) + { System.arraycopy(annotations, i + 1, annotations, i, iSize - i - 1); + } iSize--; } else @@ -832,10 +1020,14 @@ public class AlignmentAnnotation { if (sequenceRef != null) { + boolean rIsDs=sequenceRef.getDatasetSequence()==null,tIsDs=sequenceI.getDatasetSequence()==null; if (sequenceRef != sequenceI - && !sequenceRef.equals(sequenceI) - && sequenceRef.getDatasetSequence() != sequenceI + && (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 // throw away old mapping and reconstruct. @@ -935,11 +1127,15 @@ public class AlignmentAnnotation for (int i = 0; i < annotations.length; i++) { if (annotations[i] == null) + { annotations[i] = new Annotation(String.valueOf(gapchar), null, - ' ', 0f); + ' ', 0f, null); + } else if (annotations[i].displayCharacter == null || annotations[i].displayCharacter.equals(" ")) + { annotations[i].displayCharacter = String.valueOf(gapchar); + } } } } @@ -955,11 +1151,12 @@ public class AlignmentAnnotation { if (seqname && this.sequenceRef != null) { - int i=description.toLowerCase().indexOf(""); - if (i>-1) + int i = description.toLowerCase().indexOf(""); + if (i > -1) { // move the html tag to before the sequence reference. - return ""+sequenceRef.getName()+" : "+description.substring(i+6); + return "" + sequenceRef.getName() + " : " + + description.substring(i + 6); } return sequenceRef.getName() + " : " + description; } @@ -968,8 +1165,9 @@ public class AlignmentAnnotation public boolean isValidStruc() { - return invalidrnastruc==-1; + return invalidrnastruc == -1; } + public long getInvalidStrucPos() { return invalidrnastruc; @@ -978,7 +1176,19 @@ public class AlignmentAnnotation /** * machine readable ID string indicating what generated this annotation */ - protected String calcId=""; + protected String calcId = ""; + + /** + * properties associated with the calcId + */ + protected Map properties = new HashMap(); + + /** + * base colour for line graphs. If null, will be set automatically by + * searching the alignment annotation + */ + public java.awt.Color _linecolour; + public String getCalcId() { return calcId; @@ -988,5 +1198,157 @@ public class AlignmentAnnotation { this.calcId = calcId; } - + + public boolean isRNA() + { + return isrna; + } + + /** + * transfer annotation to the given sequence using the given mapping from the + * current positions or an existing sequence mapping + * + * @param sq + * @param sp2sq + * map involving sq as To or From + */ + public void liftOver(SequenceI sq, Mapping sp2sq) + { + 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"); + } + 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(); + if (sequenceMapping != null) + { + if (sp2sq != null) + { + for (Entry ie : sequenceMapping.entrySet()) + { + 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()); + } + } + sequenceMapping = mapForsq; + sequenceRef = sq; + adjustForAlignment(); + } + else + { + // trim positions + } + } + } + + /** + * like liftOver but more general. + * + * Takes an array of int pairs that will be used to update the internal + * sequenceMapping and so shuffle the annotated positions + * + * @param newref + * - new sequence reference for the annotation row - if null, + * sequenceRef is left unchanged + * @param mapping + * array of ints containing corresponding positions + * @param from + * - column for current coordinate system (-1 for index+1) + * @param to + * - column for destination coordinate system (-1 for index+1) + * @param idxoffset + * - offset added to index when referencing either coordinate system + * @note no checks are made as to whether from and/or to are sensible + * @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) + { + if (mapping != null) + { + Hashtable old = sequenceMapping, remap = new Hashtable(); + int index = -1; + for (int mp[] : mapping) + { + if (index++ < 0) + { + continue; + } + Annotation ann = null; + if (from == -1) + { + ann = sequenceMapping.get(Integer.valueOf(idxoffset + index)); + } + else + { + if (mp != null && mp.length > from) + { + ann = sequenceMapping.get(Integer.valueOf(mp[from])); + } + } + if (ann != null) + { + if (to == -1) + { + remap.put(Integer.valueOf(idxoffset + index), ann); + } + else + { + if (to > -1 && to < mp.length) + { + remap.put(Integer.valueOf(mp[to]), ann); + } + } + } + } + sequenceMapping = remap; + old.clear(); + if (newref != null) + { + sequenceRef = newref; + } + adjustForAlignment(); + } + } + + public String getProperty(String property) + { + if (properties == null) + { + return null; + } + return properties.get(property); + } + + public void setProperty(String property, String value) + { + if (properties==null) + { + properties = new HashMap(); + } + properties.put(property, value); + } + + public boolean hasProperties() + { + return properties != null && properties.size() > 0; + } + + public Collection getProperties() + { + if (properties == null) + { + return Collections.EMPTY_LIST; + } + return properties.keySet(); + } }