public class SequenceGroup implements AnnotatedCollectionI
{
// TODO ideally this event notification functionality should be separated into
- // a
- // subclass of ViewportProperties similarly to ViewportRanges. Done here as
- // quick fix for JAL-2665
+ // a subclass of ViewportProperties similarly to ViewportRanges.
+ // Done here as a quick fix for JAL-2665
public static final String SEQ_GROUP_CHANGED = "Sequence group changed";
-
+
protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
this);
String groupName;
String description;
-
+
Conservation conserve;
+ Conservation conservationData;
+
+ ProfilesI consensusProfiles;
+
+ ProfilesI hmmProfiles;
+
boolean displayBoxes = true;
boolean displayText = true;
boolean colourText = false;
- /**
- * True if the group is defined as a group on the alignment, false if it is
- * just a selection.
+ /*
+ * true if the group is defined as a group on the alignment, false if it is
+ * just a selection
*/
boolean isDefined = false;
- /**
+ /*
* after Olivier's non-conserved only character display
*/
boolean showNonconserved = false;
- /**
- * group members
+ /*
+ * sequences in the group
*/
- private List<SequenceI> sequences = new ArrayList<>();
+ private List<SequenceI> sequences;
- /**
+ /*
* representative sequence for this group (if any)
*/
private SequenceI seqrep = null;
int width = -1;
- /**
- * Colourscheme applied to group if any
+ /*
+ * colour scheme applied to group if any
*/
public ResidueShaderI cs;
- // start column (base 0)
- int startRes = 0;
+ /**
+ * start column (base 0)
+ */
+ private int startRes = 0;
- // end column (base 0)
- int endRes = 0;
+ /**
+ * end column (base 0)
+ */
+ private int endRes = 0;
public Color outlineColour = Color.black;
public Color textColour2 = Color.white;
- /**
- * consensus calculation property
+ /*
+ * properties for consensus annotation
*/
private boolean ignoreGapsInConsensus = true;
- private boolean ignoreBelowBackground = true;
+ private boolean showSequenceLogo = false;
- private boolean infoLetterHeight = false;
+ private boolean normaliseSequenceLogo;
- /**
- * consensus calculation property
+ /*
+ * properties for HMM information annotation
*/
- private boolean showSequenceLogo = false;
+ private boolean hmmIgnoreBelowBackground = true;
- /**
- * flag indicating if logo should be rendered normalised
- */
- private boolean normaliseSequenceLogo;
+ private boolean hmmUseInfoLetterHeight;
+
+ private boolean hmmShowSequenceLogo;
+
+ private boolean hmmNormaliseSequenceLogo;
+
+ private boolean hmmShowHistogram;
/*
* visibility of rows or represented rows covered by group
/*
* visibility of columns intersecting this group
*/
- private boolean hidecols = false;
+ private boolean hidecols;
AlignmentAnnotation consensus = null;
AlignmentAnnotation conservation = null;
- AlignmentAnnotation information = null;
-
+ private AlignmentAnnotation hmmInformation;
+
private boolean showConsensusHistogram;
-
+
private AnnotatedCollectionI context;
- private boolean showHMMSequenceLogo;
-
- private boolean normaliseHMMSequenceLogo;
-
- private boolean showInformationHistogram;
/**
- * Creates a new SequenceGroup object.
+ * Constructor, assigning a generated default name of "JGroup:" with object
+ * hashcode appended
*/
public SequenceGroup()
{
groupName = "JGroup:" + this.hashCode();
cs = new ResidueShader();
+ sequences = new ArrayList<>();
}
/**
* copy constructor
*
* @param seqsel
+ * @param keepsequences
+ * if false do not add sequences from seqsel to new instance
*/
public SequenceGroup(SequenceGroup seqsel)
{
this();
+
if (seqsel != null)
{
sequences = new ArrayList<>();
displayBoxes = seqsel.displayBoxes;
displayText = seqsel.displayText;
colourText = seqsel.colourText;
+
startRes = seqsel.startRes;
endRes = seqsel.endRes;
cs = new ResidueShader((ResidueShader) seqsel.cs);
showSequenceLogo = seqsel.showSequenceLogo;
normaliseSequenceLogo = seqsel.normaliseSequenceLogo;
showConsensusHistogram = seqsel.showConsensusHistogram;
- showHMMSequenceLogo = seqsel.showHMMSequenceLogo;
- normaliseHMMSequenceLogo = seqsel.normaliseHMMSequenceLogo;
- showInformationHistogram = seqsel.showInformationHistogram;
+ hmmShowSequenceLogo = seqsel.hmmShowSequenceLogo;
+ hmmNormaliseSequenceLogo = seqsel.hmmNormaliseSequenceLogo;
+ hmmShowHistogram = seqsel.hmmShowHistogram;
idColour = seqsel.idColour;
outlineColour = seqsel.outlineColour;
seqrep = seqsel.seqrep;
thresholdTextColour = seqsel.thresholdTextColour;
width = seqsel.width;
ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus;
- ignoreBelowBackground = seqsel.ignoreBelowBackground;
- infoLetterHeight = seqsel.infoLetterHeight;
+ hmmIgnoreBelowBackground = seqsel.hmmIgnoreBelowBackground;
+ hmmUseInfoLetterHeight = seqsel.hmmUseInfoLetterHeight;
if (seqsel.conserve != null)
{
+ // todo avoid doing this if we don't actually want derived calculations
+ // !
recalcConservation(); // safer than
// aaFrequency = (Vector) seqsel.aaFrequency.clone(); // ??
}
}
}
+ /**
+ * Constructor that copies the given list of sequences
+ *
+ * @param seqs
+ */
+ public SequenceGroup(List<SequenceI> seqs)
+ {
+ this();
+ this.sequences.addAll(seqs);
+ }
+
public boolean isShowSequenceLogo()
{
return showSequenceLogo;
for (int i = 0, ipos = 0; i < inorder.length; i++)
{
SequenceI seq = inorder[i];
-
- seqs[ipos] = seq.getSubSequence(startRes, endRes + 1);
- if (seqs[ipos] != null)
+ SequenceI seqipos = seqs[ipos] = seq.getSubSequence(startRes, endRes + 1);
+ if (seqipos != null)
{
- seqs[ipos].setDescription(seq.getDescription());
- seqs[ipos].setDBRefs(seq.getDBRefs());
- seqs[ipos].setSequenceFeatures(seq.getSequenceFeatures());
+ seqipos.setDescription(seq.getDescription());
+ seqipos.setDBRefs(seq.getDBRefs());
+ seqipos.setSequenceFeatures(seq.getSequenceFeatures());
if (seq.getDatasetSequence() != null)
{
- seqs[ipos].setDatasetSequence(seq.getDatasetSequence());
+ seqipos.setDatasetSequence(seq.getDatasetSequence());
}
if (seq.getAnnotation() != null)
if (alann != null)
{
boolean found = false;
- for (int pos = 0; pos < alann.length; pos++)
+ for (int pos = 0, np = alann.length; pos < np; pos++)
{
if (alann[pos] == tocopy)
{
newannot.restrict(startRes, endRes);
newannot.setSequenceRef(seqs[ipos]);
newannot.adjustForAlignment();
- seqs[ipos].addAlignmentAnnotation(newannot);
+ seqipos.addAlignmentAnnotation(newannot);
}
}
ipos++;
}
/**
- * calculate residue conservation for group - but only if necessary. returns
- * true if the calculation resulted in a visible change to group
+ * Recalculates column consensus, conservation, and HMM annotation for the
+ * group (as applicable). Returns true if the calculation resulted in a
+ * visible change to group.
*
* @param defer
* when set, colourschemes for this group are not refreshed after
public boolean recalcConservation(boolean defer)
{
if (cs == null && consensus == null && conservation == null
- && information == null)
+ && hmmInformation == null)
{
return false;
}
{
ProfilesI cnsns = AAFrequency.calculate(sequences, startRes,
endRes + 1, showSequenceLogo);
- if (information != null)
+ if (hmmInformation != null)
{
- HiddenMarkovModel hmm = information.sequenceRef.getHMM();
+ HiddenMarkovModel hmm = hmmInformation.sequenceRef.getHMM();
ProfilesI info = AAFrequency.calculateHMMProfiles(hmm,
(endRes + 1) - startRes, startRes, endRes + 1,
- showHMMSequenceLogo, ignoreBelowBackground,
- infoLetterHeight);
- _updateInformationRow(info, sequences.size());
+ hmmIgnoreBelowBackground, hmmUseInfoLetterHeight);
+ _updateInformationRow(info);
upd = true;
}
if (consensus != null)
public ProfilesI consensusData = null;
- public ProfilesI informationData = null;
-
private void _updateConsensusRow(ProfilesI cnsns, long nseq)
{
if (consensus == null)
}
/**
- * Recalculates the information content on the HMM annotation.
+ * Recalculates the information content on the HMM annotation
*
* @param cnsns
- * @param nseq
*/
- private void _updateInformationRow(ProfilesI cnsns, long nseq)
+ private void _updateInformationRow(ProfilesI cnsns)
{
- if (information == null)
+ if (hmmInformation == null)
{
- getInformation();
+ createInformationAnnotation();
}
- information.description = MessageManager
+ hmmInformation.description = MessageManager
.getString("label.information_description");
- informationData = cnsns;
+ setHmmProfiles(cnsns);
// preserve width if already set
- int aWidth = (information.annotations != null)
- ? (endRes < information.annotations.length
- ? information.annotations.length : endRes + 1)
+ int aWidth = (hmmInformation.annotations != null)
+ ? (endRes < hmmInformation.annotations.length
+ ? hmmInformation.annotations.length : endRes + 1)
: endRes + 1;
- information.annotations = null;
- information.annotations = new Annotation[aWidth]; // should be alignment
+ hmmInformation.annotations = null;
+ hmmInformation.annotations = new Annotation[aWidth]; // should be alignment
// width
- information.setCalcId(InformationThread.HMM_CALC_ID);
- AAFrequency.completeInformation(information, cnsns, startRes,
- endRes + 1, nseq, 0f);
+ hmmInformation.setCalcId(InformationThread.HMM_CALC_ID);
+ AAFrequency.completeInformation(hmmInformation, cnsns, startRes,
+ endRes + 1);
}
/**
/**
* Set the first column selected by this group. Runs from 0<=i<N_cols
*
- * @param i
+ * @param newStart
*/
- public void setStartRes(int i)
+ public void setStartRes(int newStart)
{
int before = startRes;
- startRes = i;
- changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, startRes);
+ startRes= Math.max(0,newStart); // sanity check for negative start column positions
+ changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, startRes);
+
+
+
}
/**
}
/**
- * Answers the Hidden Markov Model annotation for this group (creating it if
- * necessary)
- *
- * @return
+ * Creates the Hidden Markov Model annotation for this group
*/
- public AlignmentAnnotation getInformation()
+ void createInformationAnnotation()
{
- if (information == null)
- {
- information = new AlignmentAnnotation("", "", new Annotation[1], 0f,
- 6.25f, AlignmentAnnotation.BAR_GRAPH);
- information.hasText = true;
- information.autoCalculated = false;
- information.groupRef = this;
- information.label = getName();
- information.description = MessageManager
- .getString("label.information_description");
- information.setCalcId(InformationThread.HMM_CALC_ID);
- }
- return information;
+ hmmInformation = new AlignmentAnnotation("", "", new Annotation[1], 0f,
+ 6.25f, AlignmentAnnotation.BAR_GRAPH);
+ hmmInformation.hasText = true;
+ hmmInformation.autoCalculated = false;
+ hmmInformation.groupRef = this;
+ hmmInformation.label = getName();
+ hmmInformation.description = MessageManager
+ .getString("label.information_description");
+ hmmInformation.setCalcId(InformationThread.HMM_CALC_ID);
}
/**
{
if (consensus.annotations[i] != null)
{
- if (consensus.annotations[i].description.charAt(0) == '[')
+ String desc = consensus.annotations[i].description;
+ if (desc.length() > 1 && desc.charAt(0) == '[')
{
- seqs.append(consensus.annotations[i].description.charAt(1));
+ seqs.append(desc.charAt(1));
}
else
{
public void setIgnoreBelowBackground(boolean state)
{
- if (this.ignoreBelowBackground != state)
- {
- ignoreBelowBackground = state;
- }
- ignoreBelowBackground = state;
+ hmmIgnoreBelowBackground = state;
}
- public boolean getIgnoreBelowBackground()
+ public boolean isIgnoreBelowBackground()
{
- return ignoreBelowBackground;
+ return hmmIgnoreBelowBackground;
}
public void setInfoLetterHeight(boolean state)
{
- if (this.infoLetterHeight != state)
- {
- infoLetterHeight = state;
- }
- infoLetterHeight = state;
+ hmmUseInfoLetterHeight = state;
}
- public boolean getInfoLetterHeight()
+ public boolean isUseInfoLetterHeight()
{
- return infoLetterHeight;
+ return hmmUseInfoLetterHeight;
}
/**
public boolean isShowInformationHistogram()
{
- return showInformationHistogram;
+ return hmmShowHistogram;
}
public void setShowInformationHistogram(boolean state)
{
- if (showInformationHistogram != state && information != null)
+ if (hmmShowHistogram != state && hmmInformation != null)
{
- this.showInformationHistogram = state;
+ this.hmmShowHistogram = state;
// recalcConservation(); TODO don't know what to do here next
}
- this.showInformationHistogram = state;
-
+ this.hmmShowHistogram = state;
}
public boolean isShowHMMSequenceLogo()
{
- return showHMMSequenceLogo;
+ return hmmShowSequenceLogo;
}
- public void setshowHMMSequenceLogo(boolean state)
+ public void setShowHMMSequenceLogo(boolean state)
{
- showHMMSequenceLogo = state;
-
+ hmmShowSequenceLogo = state;
}
public boolean isNormaliseHMMSequenceLogo()
{
- return normaliseHMMSequenceLogo;
+ return hmmNormaliseSequenceLogo;
}
public void setNormaliseHMMSequenceLogo(boolean state)
{
- normaliseSequenceLogo = state;
+ hmmNormaliseSequenceLogo = state;
}
- /**
- * Returns all HMM consensus sequences. This will not return real sequences
- * with HMMs.
- */
- @Override
- public List<SequenceI> getHMMConsensusSequences()
+ public ProfilesI getConsensusData()
+ {
+ return consensusProfiles;
+ }
+
+ public ProfilesI getHmmProfiles()
{
- List<SequenceI> seqs = new ArrayList<>();
+ return hmmProfiles;
+ }
- for (int position = 0; position < sequences.size(); position++)
+ public void setHmmProfiles(ProfilesI hmmProfiles)
+ {
+ this.hmmProfiles = hmmProfiles;
+ }
+
+ @Override
+ public List<SequenceI> getHmmSequences()
+ {
+ List<SequenceI> result = new ArrayList<>();
+ for (int i = 0; i < sequences.size(); i++)
{
- SequenceI seq = sequences.get(position);
- if (seq.isHMMConsensusSequence())
+ SequenceI seq = sequences.get(i);
+ if (seq.hasHMMProfile())
{
- seqs.add(seq);
+ result.add(seq);
}
}
- return seqs;
+ return result;
}
}