import java.util.Enumeration;
import java.util.Hashtable;
-import java.util.Vector;
/**
* DOCUMENT ME!
/** DOCUMENT ME!! */
public float graphMax;
+ /**
+ * Score associated with label and description.
+ */
+ public double score= Double.NaN;
+ /**
+ * flag indicating if annotation has a score.
+ */
+ public boolean hasScore=false;
+
public GraphLine threshold;
// Graphical hints and tips
public int graphHeight = 40;
+ public boolean padGaps = false;
+
public static final int NO_GRAPH = 0;
public static final int BAR_GRAPH = 1;
public static final int LINE_GRAPH = 2;
+ public boolean belowAlignment = true;
+
+
public static int getGraphValueFromString(String string)
{
if (string.equalsIgnoreCase("BAR_GRAPH"))
*
* @param label DOCUMENT ME!
* @param description DOCUMENT ME!
- * @param annotations DOCUMENT ME!
+ * @param annotations DOCUMENT ME!about:blank
+Loading...
*/
public AlignmentAnnotation(String label, String description,
Annotation[] annotations)
this.description = description;
this.annotations = annotations;
- areLabelsSecondaryStructure();
+ validateRangeAndDisplay();
}
void areLabelsSecondaryStructure()
{
continue;
}
-
if (annotations[i].secondaryStructure == 'H' ||
annotations[i].secondaryStructure == 'E')
{
- hasIcons = true;
+ hasIcons = true;
+ }
+
+ if(annotations[i].displayCharacter==null)
+ {
+ continue;
}
if (annotations[i].displayCharacter.length() == 1
&& !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 (jalview.schemes.ResidueProperties.aaIndex
+ [annotations[i].displayCharacter.charAt(0)] < 23)
+ {
+ nonSSLabel = true;
+ }
}
- }
- if (annotations[i].displayCharacter.length() > 0)
- {
- hasText = true;
+ if (annotations[i].displayCharacter.length() > 0)
+ {
+ hasText = true;
+ }
}
- }
if (nonSSLabel)
{
}
}
-
}
annotationId = this.hashCode() + "";
int graphType)
{
// graphs are not editable
+ editable = graphType==0;
+
this.label = label;
this.description = description;
this.annotations = annotations;
* if appropriate.
*/
private void validateRangeAndDisplay() {
+
+ if (annotations==null)
+ {
+ visible=false; // try to prevent renderer from displaying.
+ return; // this is a non-annotation row annotation - ie a sequence score.
+ }
+
int graphType = graph;
float min = graphMin;
float max = graphMax;
boolean drawValues = true;
-
+
if (min == max)
{
min = 999999999;
continue;
}
- if (drawValues && annotations[i].displayCharacter.length() > 1)
+ if (drawValues
+ && annotations[i].displayCharacter!=null
+ && annotations[i].displayCharacter.length() > 1)
{
drawValues = false;
}
}
}
}
-
+
/**
* Copy constructor
- * creates a new independent annotation row with the same associated sequenceRef
+ * creates a new independent annotation row with the same associated sequenceRef
* @param annotation
*/
public AlignmentAnnotation(AlignmentAnnotation annotation)
{
this.label = new String(annotation.label);
- this.description = new String(annotation.description);
+ if (annotation.description != null)
+ this.description = new String(annotation.description);
this.graphMin = annotation.graphMin;
this.graphMax = annotation.graphMax;
this.graph = annotation.graph;
this.hasText = annotation.hasText;
this.height = annotation.height;
this.label = annotation.label;
+ this.padGaps = annotation.padGaps;
+ this.visible = annotation.visible;
+ if (this.hasScore = annotation.hasScore)
+ {
+ this.score = annotation.score;
+ }
if (threshold!=null) {
threshold = new GraphLine(annotation.threshold);
}
if (annotation.annotations!=null) {
- Vector anvec = new Vector();
Annotation[] ann = annotation.annotations;
this.annotations = new Annotation[ann.length];
for (int i=0; i<ann.length; i++) {
annotations[i] = new Annotation(ann[i]);
- anvec.addElement(ann[i]); // for lookup if sequenceMapping exists.
};
if (annotation.sequenceRef!=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 = (Integer) pos.nextElement();
- Annotation a = (Annotation) sequenceMapping.get(p);
- sequenceMapping.put(p, annotations[anvec.indexOf(a)]);
+ // 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)
+ {
+ sequenceMapping.put(p, annotations[i]);
+ }
+ }
}
- anvec.removeAllElements();
} else {
this.sequenceMapping = null;
}
}
/**
+ * clip the annotation to the columns given by startRes and endRes (inclusive)
+ * and prune any existing sequenceMapping to just those columns.
+ * @param startRes
+ * @param endRes
+ */
+ public void restrict(int startRes, int endRes)
+ {
+ 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)
+ {
+ System.arraycopy(annotations, startRes, temp, 0, endRes-startRes+1);
+ }
+ if (sequenceRef!=null) {
+ // Clip the mapping, if it exists.
+ int spos = sequenceRef.findPosition(startRes);
+ int epos = sequenceRef.findPosition(endRes);
+ if (sequenceMapping!=null)
+ {
+ Hashtable newmapping = new Hashtable();
+ Enumeration e = sequenceMapping.keys();
+ while (e.hasMoreElements())
+ {
+ Integer pos = (Integer) e.nextElement();
+ if (pos.intValue()>=spos && pos.intValue()<=epos)
+ {
+ newmapping.put(pos, sequenceMapping.get(pos));
+ }
+ }
+ sequenceMapping.clear();
+ sequenceMapping = newmapping;
+ }
+ }
+ annotations=temp;
+ }
+ /**
+ * set the annotation row to be at least length Annotations
+ * @param length minimum number of columns required in the annotation row
+ * @return false if the annotation row is greater than length
+ */
+ public boolean padAnnotation(int length) {
+ if (annotations==null)
+ {
+ return true; // annotation row is correct - null == not visible and undefined length
+ }
+ if (annotations.length<length)
+ {
+ Annotation[] na = new Annotation[length];
+ System.arraycopy(annotations, 0, na, 0, annotations.length);
+ annotations = na;
+ return true;
+ }
+ return annotations.length>length;
+
+ }
+
+ /**
* DOCUMENT ME!
*
* @return DOCUMENT ME!
{
return;
}
-
+ sequenceRef=seqRef;
+ if (annotations==null)
+ {
+ return;
+ }
sequenceMapping = new java.util.Hashtable();
- sequenceRef = seqRef;
int seqPos;
for (int i = 0; i < annotations.length; i++)
{
if (sequenceRef==null)
return;
-
+
+ if (annotations==null)
+ {
+ return;
+ }
+
int a = 0, aSize = sequenceRef.getLength();
if (aSize == 0)
ann = null;
return j;
}
-
+
/**
* Associate this annotion with the aligned residues of a particular sequence.
* sequenceMapping will be updated in the following way:
*/
public void setSequenceRef(SequenceI sequenceI)
{
- if (sequenceI!=null) {
- if (sequenceRef!=null) {
- if (sequenceRef!=sequenceI && !sequenceRef.equals(sequenceI)) {
+ if (sequenceI != null)
+ {
+ if (sequenceRef != null)
+ {
+ if (sequenceRef != sequenceI && !sequenceRef.equals(sequenceI) && sequenceRef.getDatasetSequence()!=sequenceI.getDatasetSequence())
+ {
+ // if sequenceRef isn't intersecting with sequenceI
// throw away old mapping and reconstruct.
- sequenceRef=null;
- if (sequenceMapping!=null)
+ sequenceRef = null;
+ if (sequenceMapping != null)
{
- sequenceMapping=null;
+ sequenceMapping = null;
// compactAnnotationArray();
}
- createSequenceMapping(sequenceI, 1,true);
+ createSequenceMapping(sequenceI, 1, true);
adjustForAlignment();
- } else {
+ }
+ else
+ {
// Mapping carried over
sequenceRef = sequenceI;
}
- } else {
+ }
+ else
+ {
// No mapping exists
createSequenceMapping(sequenceI, 1, true);
adjustForAlignment();
}
- } else {
+ }
+ else
+ {
// throw away the mapping without compacting.
- sequenceMapping=null;
+ sequenceMapping = null;
sequenceRef = null;
}
}
+
+ /**
+ * @return the score
+ */
+ public double getScore()
+ {
+ return score;
+ }
+
+ /**
+ * @param score the score to set
+ */
+ public void setScore(double score)
+ {
+ hasScore=true;
+ this.score = score;
+ }
+ /**
+ *
+ * @return true if annotation has an associated score
+ */
+ public boolean hasScore()
+ {
+ return hasScore || !Double.isNaN(score);
+ }
+ /**
+ * Score only annotation
+ * @param label
+ * @param description
+ * @param score
+ */
+ public AlignmentAnnotation(String label, String description, double score)
+ {
+ this(label, description, null);
+ setScore(score);
+ }
+
+ public void setPadGaps(boolean padgaps, char gapchar)
+ {
+ this.padGaps = padgaps;
+ if(padgaps)
+ {
+ hasText = true;
+ for(int i=0; i<annotations.length; i++)
+ {
+ if(annotations[i]==null)
+ annotations[i] = new Annotation(String.valueOf(gapchar),null,' ',0f);
+ else if(annotations[i].displayCharacter==null ||annotations[i].displayCharacter.equals(" "))
+ annotations[i].displayCharacter=String.valueOf(gapchar);
+ }
+ }
+ }
}
git://source.jalview.org / jalview.git / blobdiff