X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignmentAnnotation.java;h=c675a759bb71fe620a4fd7e5c2bf4f939b9f9e22;hb=c39e588784c0fbb64c7dabfcae8db4faedde10e6;hp=8635505945a1a73dd2145920f9a154eebb3842eb;hpb=92517f40eaa56129bd0545a766cbf6b71fb16545;p=jalview.git diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java index 8635505..c675a75 100755 --- a/src/jalview/datamodel/AlignmentAnnotation.java +++ b/src/jalview/datamodel/AlignmentAnnotation.java @@ -1,77 +1,365 @@ -package jalview.datamodel; - -public class AlignmentAnnotation -{ - public String label; - public String description; - public Annotation [] annotations; - public boolean isGraph = false; - public float graphMin, graphMax; - public int windowLength; - - // Graphical hints and tips - public boolean editable = false; - public boolean hasIcons; // - public boolean hasText; - public boolean visible = true; - public int height=0; - - public AlignmentAnnotation(String label, String description, Annotation [] annotations) - { - // always editable? - editable = true; - this.label = label; - this.description = description; - this.annotations = annotations; - for(int i=0; i0) - hasText = true; - } - } - - public AlignmentAnnotation(String label, String description, Annotation [] annotations, float min, float max, int winLength) - { - // graphs are not editable - this.label = label; - this.description = description; - this.annotations = annotations; - isGraph = true; - if(min==max) - { - for(int i=0; imax) - max = annotations[i].value; - if(annotations[i].value0) - hasText = true; - } - - - } - -} +/* + * Jalview - A Sequence Alignment Editor and Viewer + * Copyright (C) 2007 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.datamodel; + +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class AlignmentAnnotation +{ + /** If true, this annotations is calculated every edit, + * eg consensus, quality or conservation graphs */ + public boolean autoCalculated = false; + + public String annotationId; + + public SequenceI sequenceRef; + + /** DOCUMENT ME!! */ + public String label; + + /** DOCUMENT ME!! */ + public String description; + + /** DOCUMENT ME!! */ + public Annotation[] annotations; + + public java.util.Hashtable sequenceMapping; + + /** DOCUMENT ME!! */ + public float graphMin; + + /** DOCUMENT ME!! */ + public float graphMax; + + public GraphLine threshold; + + // Graphical hints and tips + + /** DOCUMENT ME!! */ + public boolean editable = false; + + /** DOCUMENT ME!! */ + public boolean hasIcons; // + + /** DOCUMENT ME!! */ + public boolean hasText; + + /** DOCUMENT ME!! */ + public boolean visible = true; + + public int graphGroup = -1; + + /** DOCUMENT ME!! */ + public int height = 0; + + public int graph = 0; + + public int graphHeight = 40; + + public static final int NO_GRAPH = 0; + + public static final int BAR_GRAPH = 1; + + public static final int LINE_GRAPH = 2; + + public static int getGraphValueFromString(String string) + { + if (string.equalsIgnoreCase("BAR_GRAPH")) + { + return BAR_GRAPH; + } + else if (string.equalsIgnoreCase("LINE_GRAPH")) + { + return LINE_GRAPH; + } + else + { + return NO_GRAPH; + } + } + + /** + * Creates a new AlignmentAnnotation object. + * + * @param label DOCUMENT ME! + * @param description DOCUMENT ME! + * @param annotations DOCUMENT ME! + */ + public AlignmentAnnotation(String label, String description, + Annotation[] annotations) + { + // always editable? + editable = true; + this.label = label; + this.description = description; + this.annotations = annotations; + + areLabelsSecondaryStructure(); + } + + void areLabelsSecondaryStructure() + { + boolean nonSSLabel = false; + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] == null) + { + continue; + } + + if (annotations[i].secondaryStructure == 'H' || + annotations[i].secondaryStructure == 'E') + { + hasIcons = true; + } + + if (annotations[i].displayCharacter.length() == 1 + && !annotations[i].displayCharacter.equals("H") + && !annotations[i].displayCharacter.equals("E") + && !annotations[i].displayCharacter.equals("-") + && !annotations[i].displayCharacter.equals(".")) + { + if (jalview.schemes.ResidueProperties.aaIndex + [annotations[i].displayCharacter.charAt(0)] < 23) + { + nonSSLabel = true; + } + } + + if (annotations[i].displayCharacter.length() > 0) + { + hasText = true; + } + } + + if (nonSSLabel) + { + hasIcons = false; + for (int j = 0; j < annotations.length; j++) + { + if (annotations[j] != null && annotations[j].secondaryStructure != ' ') + { + annotations[j].displayCharacter + = String.valueOf(annotations[j].secondaryStructure); + annotations[j].secondaryStructure = ' '; + } + + } + + } + + annotationId = this.hashCode() + ""; + } + + /** + * Creates a new AlignmentAnnotation object. + * + * @param label DOCUMENT ME! + * @param description DOCUMENT ME! + * @param annotations DOCUMENT ME! + * @param min DOCUMENT ME! + * @param max DOCUMENT ME! + * @param winLength DOCUMENT ME! + */ + public AlignmentAnnotation(String label, String description, + Annotation[] annotations, float min, float max, + int graphType) + { + // graphs are not editable + this.label = label; + this.description = description; + this.annotations = annotations; + graph = graphType; + + boolean drawValues = true; + + if (min == max) + { + min = 999999999; + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] == null) + { + continue; + } + + if (drawValues && annotations[i].displayCharacter.length() > 1) + { + drawValues = false; + } + + if (annotations[i].value > max) + { + max = annotations[i].value; + } + + if (annotations[i].value < min) + { + min = annotations[i].value; + } + } + } + + graphMin = min; + graphMax = max; + + areLabelsSecondaryStructure(); + + if (!drawValues && graphType != NO_GRAPH) + { + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + annotations[i].displayCharacter = ""; + } + } + } + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public String toString() + { + StringBuffer buffer = new StringBuffer(); + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + if (graph != 0) + { + buffer.append(annotations[i].value); + } + else if (hasIcons) + { + buffer.append(annotations[i].secondaryStructure); + } + else + { + buffer.append(annotations[i].displayCharacter); + } + } + + buffer.append(", "); + } + + if (label.equals("Consensus")) + { + buffer.append("\n"); + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + buffer.append(annotations[i].description); + } + + buffer.append(", "); + } + } + + return buffer.toString(); + } + + public void setThreshold(GraphLine line) + { + threshold = line; + } + + public GraphLine getThreshold() + { + return threshold; + } + + /** + * Attach the annotation to seqRef, starting from startRes position. If alreadyMapped is true then the indices of the annotation[] array are sequence positions rather than alignment column positions. + * @param seqRef + * @param startRes + * @param alreadyMapped + */ + public void createSequenceMapping(SequenceI seqRef, + int startRes, + boolean alreadyMapped) + { + + if (seqRef == null) + { + return; + } + + sequenceMapping = new java.util.Hashtable(); + + sequenceRef = seqRef; + int seqPos; + + for (int i = 0; i < annotations.length; i++) + { + if (annotations[i] != null) + { + if (alreadyMapped) + { + seqPos = seqRef.findPosition(i); + } + else + { + seqPos = i + startRes; + } + + sequenceMapping.put(new Integer(seqPos), annotations[i]); + } + } + + } + + public void adjustForAlignment() + { + int a = 0, aSize = sequenceRef.getLength(); + + if (aSize == 0) + { + //Its been deleted + return; + } + + int position; + Annotation[] temp = new Annotation[aSize]; + Integer index; + + for (a = sequenceRef.getStart(); a <= sequenceRef.getEnd(); a++) + { + index = new Integer(a); + if (sequenceMapping.containsKey(index)) + { + position = sequenceRef.findIndex(a) - 1; + + temp[position] = (Annotation) sequenceMapping.get(index); + } + } + + annotations = temp; + } +}