/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
- * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
+ * Copyright (C) 2009 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
boolean colourText = false;
/**
+ * after Olivier's non-conserved only character display
+ */
+ boolean showUnconserved = false;
+
+ /**
* group members
*/
private Vector sequences = new Vector();
public Color textColour2 = Color.white;
/**
+ * consensus calculation property
+ */
+ private boolean ignoreGapsInConsensus=true;
+ /**
+ * consensus calculation property
+ */
+ private boolean showSequenceLogo=false;
+
+ /**
+ * @return the includeAllConsSymbols
+ */
+ public boolean isShowSequenceLogo()
+ {
+ return showSequenceLogo;
+ }
+
+
+ /**
* Creates a new SequenceGroup object.
*/
public SequenceGroup()
textColour2 = seqsel.textColour2;
thresholdTextColour = seqsel.thresholdTextColour;
width = seqsel.width;
+ ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus;
if (seqsel.conserve!=null)
{
recalcConservation(); // safer than
public void setName(String name)
{
groupName = name;
+ // TODO: URGENT: update dependent objects (annotation row)
}
public void setDescription(String desc)
}
/**
- * calculate residue conservation for group
+ * Max Gaps Threshold for performing a conservation calculation
+ * TODO: make this a configurable property - or global to an alignment view
+ */
+ private int consPercGaps=25;
+ /**
+ * calculate residue conservation for group - but only if necessary.
*/
public void recalcConservation()
{
- if (cs == null)
+ if (cs == null && consensus == null && conservation == null)
{
return;
}
-
+
try
{
- cs.setConsensus(AAFrequency
- .calculate(sequences, startRes, endRes + 1));
-
+ Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes, endRes + 1, showSequenceLogo);
+ if (consensus != null)
+ {
+ _updateConsensusRow(cnsns);
+ }
+ if (cs!=null)
+ {
+ cs.setConsensus(cnsns);
+
if (cs instanceof ClustalxColourScheme)
{
((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
}
+ }
- if (cs.conservationApplied())
+ if ((conservation!=null) || (cs!=null && cs.conservationApplied()))
{
Conservation c = new Conservation(groupName,
ResidueProperties.propHash, 3, sequences, startRes,
endRes + 1);
c.calculate();
- c.verdict(false, 25);
-
- cs.setConservation(c);
-
+ c.verdict(false, consPercGaps);
+ if (conservation!=null)
+ {
+ _updateConservationRow(c);
+ }
+ if (cs!=null)
+ {
+ cs.setConservation(c);
+
if (cs instanceof ClustalxColourScheme)
{
((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
}
+ }
}
} catch (java.lang.OutOfMemoryError err)
{
}
+ private void _updateConservationRow(Conservation c)
+ {
+ if (conservation==null)
+ {
+ getConservation();
+ }
+ // update Labels
+ conservation.label = "Conservation for "+getName();
+ conservation.description = "Conservation for group "+getName()+" less than " + consPercGaps
+ + "% gaps";
+ // preserve width if already set
+ int aWidth = (conservation.annotations!=null) ? (endRes<conservation.annotations.length ? conservation.annotations.length : endRes+1) : endRes+1;
+ conservation.annotations = null;
+ conservation.annotations = new Annotation[aWidth]; // should be alignment width
+ c.completeAnnotations(conservation,null, startRes, endRes+1);
+ }
+ public Hashtable[] consensusData = null;
+ private void _updateConsensusRow(Hashtable[] cnsns)
+ {
+ if (consensus==null)
+ {
+ getConsensus();
+ }
+ consensus.label = "Consensus for "+getName();
+ consensus.description = "Percent Identity";
+ consensusData = cnsns;
+ // preserve width if already set
+ int aWidth = (consensus.annotations!=null) ? (endRes<consensus.annotations.length ? consensus.annotations.length : endRes+1) : endRes+1;
+ consensus.annotations = null;
+ consensus.annotations = new Annotation[aWidth]; // should be alignment width
+
+ AAFrequency.completeConsensus(consensus,cnsns,startRes,endRes+1,ignoreGapsInConsensus, showSequenceLogo); // TODO: setting container for ignoreGapsInConsensusCalculation);
+ }
+
/**
- * DOCUMENT ME!
- *
- * @param s
- * DOCUMENT ME!
- * @param recalc
- * DOCUMENT ME!
+ * @param s sequence to either add or remove from group
+ * @param recalc flag passed to delete/addSequence to indicate if group properties should be recalculated
*/
public void addOrRemove(SequenceI s, boolean recalc)
{
/**
*
- * returns the sequences in the group ordered by the ordering given by al
- *
+ * returns the sequences in the group ordered by the ordering given by al.
+ * this used to return an array with null entries regardless, new behaviour is below.
+ * TODO: verify that this does not affect use in applet or application
* @param al
* Alignment
- * @return SequenceI[]
+ * @return SequenceI[] intersection of sequences in group with al, ordered by al, or null if group does not intersect with al
*/
public SequenceI[] getSequencesInOrder(AlignmentI al)
{
seqs[index++] = al.getSequenceAt(i);
}
}
-
+ if (index==0)
+ {
+ return null;
+ }
+ if (index<seqs.length)
+ {
+ SequenceI[] dummy = seqs;
+ seqs = new SequenceI[index];
+ while (--index>=0)
+ {
+ seqs[index] = dummy[index];
+ dummy[index] = null;
+ }
+ }
return seqs;
}
public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable)
{
SequenceGroup sgroup = new SequenceGroup(this);
- Enumeration en = getSequences(hashtable).elements();
- while (en.hasMoreElements())
+ SequenceI[] insect=getSequencesInOrder(alignment);
+ sgroup.sequences = new Vector();
+ for (int s=0;insect!=null && s<insect.length;s++) {
+ if (hashtable==null || hashtable.containsKey(insect[s]))
+ {
+ sgroup.sequences.addElement(insect[s]); }
+ }
+ //Enumeration en =getSequences(hashtable).elements();
+ //while (en.hasMoreElements())
+ // {
+ // SequenceI elem = (SequenceI) en.nextElement();
+ // if (alignment.getSequences().contains(elem))
+ // {
+ // sgroup.addSequence(elem, false);
+ // }
+ // }
+ return sgroup;
+ }
+
+ /**
+ * @return the showUnconserved
+ */
+ public boolean getShowunconserved()
+ {
+ return showUnconserved;
+ }
+
+ /**
+ * @param showUnconserved the showUnconserved to set
+ */
+ public void setShowunconserved(boolean displayNonconserved)
+ {
+ this.showUnconserved = displayNonconserved;
+ }
+ AlignmentAnnotation consensus=null,conservation=null;
+
+ /**
+ * flag indicating if consensus histogram should be rendered
+ */
+ private boolean showConsensusHistogram;
+
+
+ /**
+ *
+ * @return automatically calculated consensus row
+ */
+ public AlignmentAnnotation getConsensus()
+ {
+ // TODO get or calculate and get consensus annotation row for this group
+ int aWidth = this.getWidth();
+ // pointer
+ // possibility
+ // here.
+ if (aWidth < 0)
+ {
+ return null;
+ }
+ if (consensus==null)
{
- SequenceI elem = (SequenceI) en.nextElement();
- if (alignment.getSequences().contains(elem))
+ consensus = new AlignmentAnnotation("","",
+ new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+ }
+ consensus.hasText = true;
+ consensus.autoCalculated = true;
+ consensus.groupRef = this;
+ consensus.label = "Consensus for "+getName();
+ consensus.description = "Percent Identity";
+ return consensus;
+ }
+ /**
+ * get the conservation annotation row for this group
+ * @return autoCalculated annotation row
+ */
+ public AlignmentAnnotation getConservationRow() {
+ if (conservation == null) {
+ conservation = new AlignmentAnnotation("","", new Annotation[1], 0f, 11f,
+ AlignmentAnnotation.BAR_GRAPH);
+ }
+
+ conservation.hasText = true;
+ conservation.autoCalculated = true;
+ conservation.groupRef = this;
+ conservation.label = "Conservation for "+getName();
+ conservation.description = "Conservation for group "+getName()+" less than " + consPercGaps
+ + "% gaps";
+ return conservation;
+ }
+
+ /**
+ *
+ * @return true if annotation rows have been instantiated for this group
+ */
+ public boolean hasAnnotationRows()
+ {
+ return consensus!=null || conservation!=null;
+ }
+
+ public SequenceI getConsensusSeq()
+ {
+ getConsensus();
+ StringBuffer seqs = new StringBuffer();
+ for (int i = 0; i < consensus.annotations.length; i++)
+ {
+ if (consensus.annotations[i] != null)
{
- sgroup.addSequence(elem, false);
+ if (consensus.annotations[i].description.charAt(0) == '[')
+ {
+ seqs.append(consensus.annotations[i].description.charAt(1));
+ }
+ else
+ {
+ seqs.append(consensus.annotations[i].displayCharacter);
+ }
}
}
- return sgroup;
+
+ SequenceI sq = new Sequence("Group"+getName()+" Consensus", seqs.toString());
+ sq.setDescription("Percentage Identity Consensus "
+ + ((ignoreGapsInConsensus) ? " without gaps" : ""));
+ return sq;
+ }
+
+ public void setIgnoreGapsConsensus(boolean state)
+ {
+ if (this.ignoreGapsInConsensus!=state && consensus!=null)
+ {
+ ignoreGapsInConsensus = state;
+ recalcConservation();
+ }
+ ignoreGapsInConsensus = state;
+ }
+ public boolean getIgnoreGapsConsensus()
+ {
+ return ignoreGapsInConsensus;
+ }
+ /**
+ * @param includeAllConsSymbols the includeAllConsSymbols to set
+ */
+ public void setIncludeAllConsSymbols(boolean includeAllConsSymbols)
+ {
+ if (this.showSequenceLogo!=includeAllConsSymbols && consensus!=null) {
+ this.showSequenceLogo = includeAllConsSymbols;
+ recalcConservation();
+ }
+ this.showSequenceLogo = includeAllConsSymbols;
+ }
+
+
+ /**
+ *
+ * @param showConsHist flag indicating if the consensus histogram for this group should be rendered
+ */
+ public void setShowConsensusHistogram(boolean showConsHist)
+ {
+
+ if (showConsensusHistogram!=showConsHist && consensus!=null) {
+ this.showConsensusHistogram = showConsHist;
+ recalcConservation();
+ }
+ this.showConsensusHistogram = showConsHist;
+ }
+ /**
+ * @return the showConsensusHistogram
+ */
+ public boolean isShowConsensusHistogram()
+ {
+ return showConsensusHistogram;
+ }
}
-}
git://source.jalview.org / jalview.git / blobdiff