import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.analysis.Conservation;
+import jalview.analysis.TreeModel;
import jalview.api.AlignCalcManagerI;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentView;
import jalview.datamodel.Annotation;
-import jalview.datamodel.CigarArray;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.HiddenSequences;
-import jalview.datamodel.ProfileI;
-import jalview.datamodel.Profiles;
import jalview.datamodel.ProfilesI;
import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import java.util.Deque;
import java.util.HashMap;
import java.util.Hashtable;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
* @author jimp
*
*/
-public abstract class AlignmentViewport implements AlignViewportI,
- CommandListener, VamsasSource
+public abstract class AlignmentViewport
+ implements AlignViewportI, CommandListener, VamsasSource
{
- final protected ViewportRanges ranges;
+ protected ViewportRanges ranges;
protected ViewStyleI viewStyle = new ViewStyle();
protected Deque<CommandI> historyList = new ArrayDeque<>();
protected Deque<CommandI> redoList = new ArrayDeque<>();
-
+
+ protected String sequenceSetID;
+
+ /*
+ * probably unused indicator that view is of a dataset rather than an
+ * alignment
+ */
+ protected boolean isDataset = false;
+
+ private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
+
+ protected ColumnSelection colSel = new ColumnSelection();
+
+ public boolean autoCalculateConsensus = true;
+
+ protected boolean autoCalculateStrucConsensus = true;
+
+ protected boolean ignoreGapsInConsensusCalculation = false;
+
+ protected boolean ignoreBelowBackGroundFrequencyCalculation = false;
+
+ protected boolean infoLetterHeight = false;
+
+ protected ResidueShaderI residueShading = new ResidueShader();
+
+ protected AlignmentAnnotation consensus;
+
+ protected AlignmentAnnotation complementConsensus;
+
+ protected AlignmentAnnotation occupancy;
+
+ protected AlignmentAnnotation strucConsensus;
+
+ protected AlignmentAnnotation conservation;
+
+ protected AlignmentAnnotation quality;
+
+ /**
+ * alignment displayed in the viewport
+ */
+ private AlignmentI alignment;
+
+ /**
+ * results of alignment consensus analysis for visible portion of view
+ */
+ protected ProfilesI consensusProfiles;
+
+ /**
+ * HMM profile for the alignment
+ */
+ protected ProfilesI hmmProfiles;
/**
- * alignment displayed in the viewport. Please use get/setter
+ * results of cDNA complement consensus visible portion of view
+ */
+ protected Hashtable[] hcomplementConsensus;
+
+ /**
+ * results of secondary structure base pair consensus for visible portion of
+ * view
*/
- protected AlignmentI alignment;
+ protected Hashtable[] hStrucConsensus;
+
+ protected Conservation hconservation;
public AlignmentViewport(AlignmentI al)
{
public void setWrapAlignment(boolean state)
{
viewStyle.setWrapAlignment(state);
+ ranges.setWrappedMode(state);
}
/**
viewStyle.setSeqNameItalics(default1);
}
-
-
@Override
public AlignmentI getAlignment()
{
return alignment.getGapCharacter();
}
- protected String sequenceSetID;
-
- /**
- * probably unused indicator that view is of a dataset rather than an
- * alignment
- */
- protected boolean isDataset = false;
-
public void setDataset(boolean b)
{
isDataset = b;
return isDataset;
}
- private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
-
- protected ColumnSelection colSel = new ColumnSelection();
-
- public boolean autoCalculateConsensus = true;
-
- public boolean autoCalculateInformation = true;
-
- protected boolean autoCalculateStrucConsensus = true;
-
- protected boolean ignoreGapsInConsensusCalculation = false;
-
- protected boolean ignoreBelowBackGroundFrequencyCalculation = false;
-
- protected ResidueShaderI residueShading = new ResidueShader();
-
@Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
{
residueShading.setConservation(hconservation);
}
+ /*
+ * reset conservation flag in case just set to false if
+ * Conservation was null (calculation still in progress)
+ */
+ residueShading.setConservationApplied(getConservationSelected());
residueShading.alignmentChanged(alignment, hiddenRepSequences);
}
sg.setColourScheme(cs);
if (cs != null)
{
- sg.getGroupColourScheme()
- .alignmentChanged(sg, hiddenRepSequences);
+ sg.getGroupColourScheme().alignmentChanged(sg,
+ hiddenRepSequences);
}
}
}
@Override
public ColourSchemeI getGlobalColourScheme()
{
- return residueShading == null ? null : residueShading
- .getColourScheme();
+ return residueShading == null ? null : residueShading.getColourScheme();
}
@Override
{
return residueShading;
}
-
- protected AlignmentAnnotation consensus;
-
- protected AlignmentAnnotation complementConsensus;
-
- protected AlignmentAnnotation gapcounts;
-
- protected AlignmentAnnotation strucConsensus;
-
- protected AlignmentAnnotation conservation;
-
- protected AlignmentAnnotation quality;
-
- protected AlignmentAnnotation[] groupConsensus;
-
- protected AlignmentAnnotation[] groupConservation;
-
- protected List<AlignmentAnnotation> groupInformation = new ArrayList<>();
-
- protected List<AlignmentAnnotation> information = new ArrayList<>();
-
- /**
- * results of alignment consensus analysis for visible portion of view
- */
- protected ProfilesI hconsensus = null;
-
- protected List<ProfilesI> hinformation = new ArrayList<>();
-
- /**
- * results of cDNA complement consensus visible portion of view
- */
- protected Hashtable[] hcomplementConsensus = null;
-
- /**
- * results of secondary structure base pair consensus for visible portion of
- * view
- */
- protected Hashtable[] hStrucConsensus = null;
-
- protected Conservation hconservation = null;
-
@Override
public void setConservation(Conservation cons)
{
}
@Override
- public void setSequenceConsensusHash(ProfilesI hconsensus)
+ public void setConsensusProfiles(ProfilesI hconsensus)
{
- this.hconsensus = hconsensus;
+ this.consensusProfiles = hconsensus;
}
@Override
}
@Override
- public ProfilesI getSequenceConsensusHash()
- {
- return hconsensus;
- }
-
- @Override
- public void setSequenceInformationHashes(List<ProfilesI> info)
+ public ProfilesI getConsensusProfiles()
{
- hinformation = info;
+ return consensusProfiles;
}
@Override
- public void setSequenceInformationHash(ProfilesI info, int index)
+ public void setHmmProfiles(ProfilesI info)
{
- hinformation.set(index, info);
+ hmmProfiles = info;
}
@Override
- public List<ProfilesI> getSequenceInformationHashes()
+ public ProfilesI getHmmProfiles()
{
- return hinformation;
- }
-
- @Override
- public ProfilesI getSequenceInformationHash(int index)
- {
- return hinformation.get(index);
+ return hmmProfiles;
}
@Override
}
@Override
- public List<AlignmentAnnotation> getInformationAnnotations()
- {
- return information;
- }
-
- @Override
- public AlignmentAnnotation getInformationAnnotation(int index)
- {
- return information.get(index);
- }
-
-
- @Override
- public AlignmentAnnotation getAlignmentGapAnnotation()
+ public AlignmentAnnotation getOccupancyAnnotation()
{
- return gapcounts;
+ return occupancy;
}
@Override
{
return;
}
- if (calculator
- .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ jalview.workers.ConservationThread.class) == null)
{
- calculator.registerWorker(new jalview.workers.ConservationThread(
- this, ap));
+ calculator.registerWorker(
+ new jalview.workers.ConservationThread(this, ap));
}
}
{
return;
}
- if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class) == null)
+ if (calculator
+ .getRegisteredWorkersOfClass(ConsensusThread.class) == null)
{
calculator.registerWorker(new ConsensusThread(this, ap));
}
}
if (doConsensus)
{
- if (calculator
- .getRegisteredWorkersOfClass(ComplementConsensusThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ ComplementConsensusThread.class) == null)
{
calculator
.registerWorker(new ComplementConsensusThread(this, ap));
}
}
- /**
- * trigger update of information annotation
- */
- public void updateInformation(final AlignmentViewPanel ap)
+ @Override
+ public void initInformationWorker(final AlignmentViewPanel ap)
{
if (calculator
.getRegisteredWorkersOfClass(InformationThread.class) == null)
{
calculator.registerWorker(new InformationThread(this, ap));
}
-
}
// --------START Structure Conservation
{
return;
}
- if (calculator.getRegisteredWorkersOfClass(StrucConsensusThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ StrucConsensusThread.class) == null)
{
calculator.registerWorker(new StrucConsensusThread(this, ap));
}
strucConsensus = null;
conservation = null;
quality = null;
- groupConsensus = null;
- groupConservation = null;
- hconsensus = null;
+ consensusProfiles = null;
+ hconservation = null;
hcomplementConsensus = null;
- // colour scheme may hold reference to consensus
- residueShading = null;
- // TODO remove listeners from changeSupport?
+ occupancy = null;
+ calculator = null;
+ residueShading = null; // may hold a reference to Consensus
changeSupport = null;
+ ranges = null;
+ currentTree = null;
+ selectionGroup = null;
setAlignment(null);
}
/**
* should hmm profile be rendered by default
*/
- protected boolean showHMMSequenceLogo = false;
+ protected boolean hmmShowSequenceLogo = false;
/**
* should hmm profile be rendered normalised to row height
*/
- protected boolean normaliseHMMSequenceLogo = false;
+ protected boolean hmmNormaliseSequenceLogo = false;
/**
* should information histograms be rendered by default
*/
- protected boolean showInformationHistogram = true;
+ protected boolean hmmShowHistogram = true;
/**
* @return the showConsensusProfile
@Override
public boolean isShowHMMSequenceLogo()
{
- return showHMMSequenceLogo;
+ return hmmShowSequenceLogo;
}
/**
public void setShowHMMSequenceLogo(boolean showHMMSequenceLogo)
{
- if (showHMMSequenceLogo != this.showHMMSequenceLogo)
+ if (showHMMSequenceLogo != this.hmmShowSequenceLogo)
{
- this.showHMMSequenceLogo = showHMMSequenceLogo;
- calculator.updateAnnotationFor(InformationThread.class);
+ this.hmmShowSequenceLogo = showHMMSequenceLogo;
+ // TODO: updateAnnotation if description (tooltip) will show
+ // profile in place of information content?
+ // calculator.updateAnnotationFor(InformationThread.class);
}
- this.showHMMSequenceLogo = showHMMSequenceLogo;
+ this.hmmShowSequenceLogo = showHMMSequenceLogo;
}
/**
/**
* @param showInformationHistogram
- * the showInformationHistogram to set
*/
public void setShowInformationHistogram(boolean showInformationHistogram)
{
- this.showInformationHistogram = showInformationHistogram;
+ this.hmmShowHistogram = showInformationHistogram;
}
/**
@Override
public boolean isShowInformationHistogram()
{
- return this.showInformationHistogram;
+ return this.hmmShowHistogram;
}
/**
@Override
public boolean hasHiddenColumns()
{
- return colSel != null
+ return alignment.getHiddenColumns() != null
&& alignment.getHiddenColumns().hasHiddenColumns();
}
{
if (sequenceSetID != null)
{
- System.err
- .println("Warning - overwriting a sequenceSetId for a viewport!");
+ System.err.println(
+ "Warning - overwriting a sequenceSetId for a viewport!");
}
sequenceSetID = new String(newid);
}
ignoreGapsInConsensusCalculation = b;
if (ap != null)
{
- updateConsensus(ap);
if (residueShading != null)
{
residueShading.setThreshold(residueShading.getThreshold(),
ignoreGapsInConsensusCalculation);
}
}
-
}
public void setIgnoreBelowBackground(boolean b, AlignmentViewPanel ap)
{
ignoreBelowBackGroundFrequencyCalculation = b;
- if (ap != null)
- {
- updateInformation(ap);
- }
+ }
+ public void setInfoLetterHeight(boolean b, AlignmentViewPanel ap)
+ {
+ infoLetterHeight = b;
}
private long sgrouphash = -1, colselhash = -1;
return ignoreBelowBackGroundFrequencyCalculation;
}
+ @Override
+ public boolean isInfoLetterHeight()
+ {
+ return infoLetterHeight;
+ }
+
// property change stuff
// JBPNote Prolly only need this in the applet version.
private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
public void removePropertyChangeListener(
java.beans.PropertyChangeListener listener)
{
- changeSupport.removePropertyChangeListener(listener);
+ if (changeSupport != null)
+ {
+ changeSupport.removePropertyChangeListener(listener);
+ }
}
/**
// common hide/show seq stuff
public void showAllHiddenSeqs()
{
+ int startSeq = ranges.getStartSeq();
+ int endSeq = ranges.getEndSeq();
+
if (alignment.getHiddenSequences().getSize() > 0)
{
if (selectionGroup == null)
selectionGroup = new SequenceGroup();
selectionGroup.setEndRes(alignment.getWidth() - 1);
}
- List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
- hiddenRepSequences);
+ List<SequenceI> tmp = alignment.getHiddenSequences()
+ .showAll(hiddenRepSequences);
for (SequenceI seq : tmp)
{
selectionGroup.addSequence(seq, false);
hiddenRepSequences = null;
+ ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
+
firePropertyChange("alignment", null, alignment.getSequences());
// used to set hasHiddenRows/hiddenRepSequences here, after the property
// changed event
public void showSequence(int index)
{
- List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
- index, hiddenRepSequences);
+ int startSeq = ranges.getStartSeq();
+ int endSeq = ranges.getEndSeq();
+
+ List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(index,
+ hiddenRepSequences);
if (tmp.size() > 0)
{
if (selectionGroup == null)
selectionGroup.addSequence(seq, false);
setSequenceAnnotationsVisible(seq, true);
}
+
+ ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
+
firePropertyChange("alignment", null, alignment.getSequences());
sendSelection();
}
public void hideSequence(SequenceI[] seq)
{
+ /*
+ * cache offset to first visible sequence
+ */
+ int startSeq = ranges.getStartSeq();
+
if (seq != null)
{
for (int i = 0; i < seq.length; i++)
alignment.getHiddenSequences().hideSequence(seq[i]);
setSequenceAnnotationsVisible(seq[i], false);
}
+ ranges.setStartSeq(startSeq);
firePropertyChange("alignment", null, alignment.getSequences());
}
}
}
int gsize = selectionGroup.getSize();
- SequenceI[] hseqs = selectionGroup.getSequences().toArray(
- new SequenceI[gsize]);
+ SequenceI[] hseqs = selectionGroup.getSequences()
+ .toArray(new SequenceI[gsize]);
hideSequence(hseqs);
setSelectionGroup(null);
*/
public boolean isHiddenRepSequence(SequenceI seq)
{
- return (hiddenRepSequences != null && hiddenRepSequences
- .containsKey(seq));
+ return (hiddenRepSequences != null
+ && hiddenRepSequences.containsKey(seq));
}
/**
@Override
public int adjustForHiddenSeqs(int alignmentIndex)
{
- return alignment.getHiddenSequences().adjustForHiddenSeqs(
- alignmentIndex);
+ return alignment.getHiddenSequences()
+ .adjustForHiddenSeqs(alignmentIndex);
}
@Override
}
else
{
- sequences = selectionGroup.getSelectionAsNewSequences(alignment);
+ sequences = selectionGroup.getSelectionAsNewSequences(alignment,
+ true);
}
return sequences;
}
@Override
- public CigarArray getViewAsCigars(boolean selectedRegionOnly)
- {
- return new CigarArray(alignment, alignment.getHiddenColumns(),
- (selectedRegionOnly ? selectionGroup : null));
- }
-
- @Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly)
{
boolean selectedOnly, boolean markGroups)
{
return new AlignmentView(alignment, alignment.getHiddenColumns(),
- selectionGroup, alignment.getHiddenColumns() != null
+ selectionGroup,
+ alignment.getHiddenColumns() != null
&& alignment.getHiddenColumns().hasHiddenColumns(),
- selectedOnly,
- markGroups);
+ selectedOnly, markGroups);
}
@Override
if (alignment.getHiddenColumns() != null
&& alignment.getHiddenColumns().hasHiddenColumns())
{
- selection = alignment.getHiddenColumns().getVisibleSequenceStrings(
- start, end, seqs);
+ for (i = 0; i < iSize; i++)
+ {
+ Iterator<int[]> blocks = alignment.getHiddenColumns()
+ .getVisContigsIterator(start, end + 1, false);
+ selection[i] = seqs[i].getSequenceStringFromIterator(blocks);
+ }
}
else
{
{
if (start == 0)
{
- start = hidden.adjustForHiddenColumns(start);
+ start = hidden.visibleToAbsoluteColumn(start);
}
- end = hidden.getHiddenBoundaryRight(start);
+ end = hidden.getNextHiddenBoundary(false, start);
if (start == end)
{
end = max;
if (hidden != null && hidden.hasHiddenColumns())
{
- start = hidden.adjustForHiddenColumns(end);
- start = hidden.getHiddenBoundaryLeft(start) + 1;
+ start = hidden.visibleToAbsoluteColumn(end);
+ start = hidden.getNextHiddenBoundary(true, start) + 1;
}
} while (end < max);
AlignmentAnnotation clone = new AlignmentAnnotation(annot);
if (selectedOnly && selectionGroup != null)
{
- alignment.getHiddenColumns().makeVisibleAnnotation(
- selectionGroup.getStartRes(),
- selectionGroup.getEndRes(), clone);
+ clone.makeVisibleAnnotation(
+ selectionGroup.getStartRes(), selectionGroup.getEndRes(),
+ alignment.getHiddenColumns());
}
else
{
- alignment.getHiddenColumns().makeVisibleAnnotation(clone);
+ clone.makeVisibleAnnotation(alignment.getHiddenColumns());
}
ala.add(clone);
}
{
alignment.padGaps();
}
- if (autoCalculateConsensus)
- {
- updateConsensus(ap);
- }
- if (hconsensus != null && autoCalculateConsensus)
- {
- updateConservation(ap);
- }
- if (autoCalculateStrucConsensus)
- {
- updateStrucConsensus(ap);
- }
- updateInformation(ap);
-
- Map<Integer, SequenceI> hmmSequences;
- hmmSequences = alignment.getHMMConsensusSequences(false);
-
- for (Map.Entry<Integer, SequenceI> entry : hmmSequences.entrySet())
- {
- SequenceI seq = entry.getValue();
- seq.updateHMMMapping();
- }
// Reset endRes of groups if beyond alignment width
int alWidth = alignment.getWidth();
updateAllColourSchemes();
calculator.restartWorkers();
- // alignment.adjustSequenceAnnotations();
}
/**
{
rs.alignmentChanged(alignment, hiddenRepSequences);
- rs.setConsensus(hconsensus);
+ rs.setConsensus(consensusProfiles);
if (rs.conservationApplied())
{
rs.setConservation(Conservation.calculateConservation("All",
// depending on if the user wants to see the annotation or not in a
// specific alignment
- if (hconsensus == null && !isDataset)
+ if (consensusProfiles == null && !isDataset)
{
if (!alignment.isNucleotide())
{
new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
initConsensus(consensus);
- initGapCounts();
+ initOccupancy();
initComplementConsensus();
}
}
-
/**
* If this is a protein alignment and there are mappings to cDNA, adds the
* cDNA consensus annotation and returns true, else returns false.
}
}
- public void initInformation(SequenceI hmmSequence)
- {
- AlignmentAnnotation information;
- information = new AlignmentAnnotation(hmmSequence.getName(),
- MessageManager.getString("label.information_description"),
- new Annotation[1], 0f, 6.52f, AlignmentAnnotation.BAR_GRAPH);
- information.hasText = true;
- information.autoCalculated = true;
- information.hasText = true;
- information.autoCalculated = false;
- information.sequenceRef = hmmSequence;
- this.information.add(information);
- hinformation.add(new Profiles(new ProfileI[1]));
- alignment.addAnnotation(information);
- }
-
// these should be extracted from the view model - style and settings for
// derived annotation
- private void initGapCounts()
+ private void initOccupancy()
{
if (showOccupancy)
{
- gapcounts = new AlignmentAnnotation("Occupancy",
+ occupancy = new AlignmentAnnotation("Occupancy",
MessageManager.getString("label.occupancy_descr"),
- new Annotation[1], 0f,
- alignment.getHeight(), AlignmentAnnotation.BAR_GRAPH);
- gapcounts.hasText = true;
- gapcounts.autoCalculated = true;
- gapcounts.scaleColLabel = true;
- gapcounts.graph = AlignmentAnnotation.BAR_GRAPH;
+ new Annotation[1], 0f, alignment.getHeight(),
+ AlignmentAnnotation.BAR_GRAPH);
+ occupancy.hasText = true;
+ occupancy.autoCalculated = true;
+ occupancy.scaleColLabel = true;
+ occupancy.graph = AlignmentAnnotation.BAR_GRAPH;
- alignment.addAnnotation(gapcounts);
+ alignment.addAnnotation(occupancy);
}
}
{
conservation = new AlignmentAnnotation("Conservation",
MessageManager.formatMessage("label.conservation_descr",
- getConsPercGaps()), new Annotation[1],
- 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
+ getConsPercGaps()),
+ new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
conservation.hasText = true;
conservation.autoCalculated = true;
alignment.addAnnotation(conservation);
sg.setshowSequenceLogo(showprf);
sg.setShowConsensusHistogram(showConsHist);
sg.setNormaliseSequenceLogo(normLogo);
- sg.setshowHMMSequenceLogo(showHMMPrf);
+ sg.setShowHMMSequenceLogo(showHMMPrf);
sg.setShowInformationHistogram(showInfoHist);
sg.setNormaliseHMMSequenceLogo(normHMMLogo);
}
viewStyle = new ViewStyle(settingsForView);
if (residueShading != null)
{
- residueShading.setConservationApplied(settingsForView
- .isConservationColourSelected());
+ residueShading.setConservationApplied(
+ settingsForView.isConservationColourSelected());
}
}
return sortAnnotationsBy;
}
- public void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
+ public void setSortAnnotationsBy(
+ SequenceAnnotationOrder sortAnnotationsBy)
{
this.sortAnnotationsBy = sortAnnotationsBy;
}
return 0;
}
boolean iAmProtein = !getAlignment().isNucleotide();
- AlignmentI proteinAlignment = iAmProtein ? getAlignment() : complement
- .getAlignment();
+ AlignmentI proteinAlignment = iAmProtein ? getAlignment()
+ : complement.getAlignment();
if (proteinAlignment == null)
{
return 0;
*/
int lastSeq = alignment.getHeight() - 1;
List<AlignedCodonFrame> seqMappings = null;
- for (int seqNo = ranges.getStartSeq(); seqNo < lastSeq; seqNo++, seqOffset++)
+ for (int seqNo = ranges
+ .getStartSeq(); seqNo <= lastSeq; seqNo++, seqOffset++)
{
sequence = getAlignment().getSequenceAt(seqNo);
if (hiddenSequences != null && hiddenSequences.isHidden(sequence))
{
continue;
}
- seqMappings = MappingUtils
- .findMappingsForSequenceAndOthers(sequence, mappings,
- getCodingComplement().getAlignment().getSequences());
+ seqMappings = MappingUtils.findMappingsForSequenceAndOthers(sequence,
+ mappings,
+ getCodingComplement().getAlignment().getSequences());
if (!seqMappings.isEmpty())
{
break;
*/
private SearchResultsI searchResults = null;
+ protected TreeModel currentTree = null;
+
@Override
public boolean hasSearchResults()
{
{
return searchResults;
}
-
+ /**
+ * get the consensus sequence as displayed under the PID consensus annotation
+ * row.
+ *
+ * @return consensus sequence as a new sequence object
+ */
+ public SequenceI getConsensusSeq()
+ {
+ if (consensus == null)
+ {
+ updateConsensus(null);
+ }
+ if (consensus == null)
+ {
+ return null;
+ }
+ StringBuffer seqs = new StringBuffer();
+ for (int i = 0; i < consensus.annotations.length; i++)
+ {
+ Annotation annotation = consensus.annotations[i];
+ if (annotation != null)
+ {
+ String description = annotation.description;
+ if (description != null && description.startsWith("["))
+ {
+ // consensus is a tie - just pick the first one
+ seqs.append(description.charAt(1));
+ }
+ else
+ {
+ seqs.append(annotation.displayCharacter);
+ }
+ }
+ }
+
+ SequenceI sq = new Sequence("Consensus", seqs.toString());
+ sq.setDescription("Percentage Identity Consensus "
+ + ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
+ return sq;
+ }
+
+ public boolean hasReferenceAnnotation()
+ {
+ AlignmentAnnotation[] annots = this.alignment.getAlignmentAnnotation();
+ for (AlignmentAnnotation annot : annots)
+ {
+ if ("RF".equals(annot.label) || annot.label.contains("Reference"))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void setCurrentTree(TreeModel tree)
+ {
+ currentTree = tree;
+ }
+
+ @Override
+ public TreeModel getCurrentTree()
+ {
+ return currentTree;
+ }
+
+ @Override
+ public boolean isNormaliseSequenceLogo()
+ {
+ return normaliseSequenceLogo;
+ }
+
+ public void setNormaliseSequenceLogo(boolean state)
+ {
+ normaliseSequenceLogo = state;
+ }
+
+ @Override
+ public boolean isNormaliseHMMSequenceLogo()
+ {
+ return hmmNormaliseSequenceLogo;
+ }
+
+ public void setNormaliseHMMSequenceLogo(boolean state)
+ {
+ hmmNormaliseSequenceLogo = state;
+ }
}