import jalview.analysis.SecStrConsensus.SimpleBP;
import jalview.analysis.WUSSParseException;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
+import java.util.List;
import java.util.Map;
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 CDNA_PROFILE = 2;
+ private static long counter = 0;
+
/**
* If true, this annotations is calculated every edit, eg consensus, quality
* or conservation graphs
/** Array of annotations placed in the current coordinate system */
public Annotation[] annotations;
- public ArrayList<SimpleBP> bps = null;
+ public List<SimpleBP> bps = null;
/**
* RNA secondary structure contact positions
{
try
{
- _rnasecstr = Rna.GetBasePairs(RNAannot);
- bps = Rna.GetModeleBP(RNAannot);
+ bps = Rna.getModeleBP(RNAannot);
+ _rnasecstr = Rna.getBasePairs(bps);
invalidrnastruc = -1;
} catch (WUSSParseException px)
{
}
setScore(mxval);
}
+
/**
* map of positions in the associated annotation
*/
*
* @see java.lang.Object#finalize()
*/
+ @Override
protected void finalize() throws Throwable
{
sequenceRef = null;
// JBPNote: what does this do ?
public void ConcenStru(CharSequence RNAannot) throws WUSSParseException
{
- bps = Rna.GetModeleBP(RNAannot);
+ bps = Rna.getModeleBP(RNAannot);
}
/**
public AlignmentAnnotation(String label, String description,
Annotation[] annotations)
{
+ setAnnotationId();
// always editable?
editable = true;
this.label = label;
_updateRnaSecStr(new AnnotCharSequence());
}
}
-
- annotationId = this.hashCode() + "";
}
/**
this(0, annotations.length);
}
- public AnnotCharSequence(int start, int end)
+ AnnotCharSequence(int start, int end)
{
offset = start;
max = end;
public char charAt(int index)
{
return ((index + offset < 0) || (index + offset) >= max
- || annotations[index + offset] == null || (annotations[index
- + offset].secondaryStructure <= ' ') ? ' '
- : annotations[index + offset].displayCharacter.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
for (int i = offset; i < mx; i++)
{
string[i] = (annotations[i] == null || (annotations[i].secondaryStructure <= 32)) ? ' '
- : annotations[i].displayCharacter.charAt(0);
+ : (annotations[i].displayCharacter == null
+ || annotations[i].displayCharacter.length() == 0 ? annotations[i].secondaryStructure
+ : annotations[i].displayCharacter.charAt(0));
}
return new String(string);
}
public AlignmentAnnotation(String label, String description,
Annotation[] annotations, float min, float max, int graphType)
{
+ setAnnotationId();
// graphs are not editable
editable = graphType == 0;
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.
}
{
if (annotations[i] != null)
{
- annotations[i].displayCharacter = "X";
+ annotations[i].displayCharacter = "";
}
}
}
*/
public AlignmentAnnotation(AlignmentAnnotation annotation)
{
+ setAnnotationId();
this.label = new String(annotation.label);
if (annotation.description != null)
{
this.scaleColLabel = annotation.scaleColLabel;
this.showAllColLabels = annotation.showAllColLabels;
this.calcId = annotation.calcId;
- if (annotation.properties!=null)
+ if (annotation.properties != null)
{
- properties = new HashMap<String,String>();
- for (Map.Entry<String, String> val:annotation.properties.entrySet())
+ properties = new HashMap<String, String>();
+ for (Map.Entry<String, String> val : annotation.properties.entrySet())
{
properties.put(val.getKey(), val.getValue());
}
}
+ /**
+ * 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)
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;
}
}
/**
- * 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
{
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())
{
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;
* @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<Integer, int[]> mapping,
+ int from, int to, int idxoffset)
{
if (mapping != null)
{
Map<Integer, Annotation> old = sequenceMapping;
Map<Integer, Annotation> remap = new HashMap<Integer, Annotation>();
int index = -1;
- for (int mp[] : mapping)
+ for (int mp[] : mapping.values())
{
if (index++ < 0)
{
public void setProperty(String property, String value)
{
- if (properties==null)
+ if (properties == null)
{
- properties = new HashMap<String,String>();
+ properties = new HashMap<String, String>();
}
properties.put(property, value);
}
{
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++;
+ }
}
git://source.jalview.org / jalview.git / blobdiff