import java.util.Deque;
import java.util.HashMap;
import java.util.Hashtable;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
protected Deque<CommandI> redoList = new ArrayDeque<>();
- protected String sequenceSetID;
-
+ /**
+ * alignment displayed in the viewport. Please use get/setter
+ */
+ protected AlignmentI alignment;
+
/*
* 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 hmmProfiles;
- /**
- * 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 Hashtable[] hStrucConsensus;
-
- protected Conservation hconservation;
-
public AlignmentViewport(AlignmentI al)
{
setAlignment(al);
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;
+
+ protected boolean autoCalculateStrucConsensus = true;
+
+ protected boolean ignoreGapsInConsensusCalculation = false;
+
+ protected ResidueShaderI residueShading = new ResidueShader();
+
@Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
* retain any colour thresholds per group while
* changing choice of colour scheme (JAL-2386)
*/
- sg.setColourScheme(cs);
+ sg.setColourScheme(
+ cs == null ? null : cs.getInstance(this, sg));
if (cs != null)
{
sg.getGroupColourScheme().alignmentChanged(sg,
{
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;
+
+ /**
+ * results of alignment consensus analysis for visible portion of view
+ */
+ protected ProfilesI hconsensus = null;
+
+ /**
+ * 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 setConsensusProfiles(ProfilesI hconsensus)
+ public void setSequenceConsensusHash(ProfilesI hconsensus)
{
- this.consensusProfiles = hconsensus;
+ this.hconsensus = hconsensus;
}
@Override
}
@Override
- public ProfilesI getConsensusProfiles()
+ public ProfilesI getSequenceConsensusHash()
{
- return consensusProfiles;
+ return hconsensus;
}
@Override
}
@Override
- public AlignmentAnnotation getOccupancyAnnotation()
+ public AlignmentAnnotation getAlignmentGapAnnotation()
{
- return occupancy;
+ return gapcounts;
}
@Override
}
}
- /**
- * trigger update of information annotation
- */
@Override
- public void updateInformation(final AlignmentViewPanel ap)
+ public void initInformationWorker(final AlignmentViewPanel ap)
{
if (calculator
.getRegisteredWorkersOfClass(InformationThread.class) == null)
{
calculator.registerWorker(new InformationThread(this, ap));
}
-
}
// --------START Structure Conservation
conservation = null;
quality = null;
consensusProfiles = null;
+ groupConsensus = null;
+ groupConservation = null;
+ hconsensus = null;
hconservation = null;
hcomplementConsensus = null;
- occupancy = null;
+ gapcounts = null;
calculator = null;
residueShading = null; // may hold a reference to Consensus
changeSupport = 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;
}
/**
public void setIgnoreBelowBackground(boolean b, AlignmentViewPanel ap)
{
- boolean was = ignoreBelowBackGroundFrequencyCalculation;
ignoreBelowBackGroundFrequencyCalculation = b;
- if (ap != null && was != b)
- {
- updateInformation(ap);
- }
}
public void setInfoLetterHeight(boolean b, AlignmentViewPanel ap)
{
- boolean was = infoLetterHeight;
infoLetterHeight = b;
- if (ap != null && was != b)
- {
- updateInformation(ap);
- }
}
private long sgrouphash = -1, colselhash = -1;
public void invertColumnSelection()
{
colSel.invertColumnSelection(0, alignment.getWidth(), alignment);
+ isColSelChanged(true);
}
@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(
+ clone.makeVisibleAnnotation(
selectionGroup.getStartRes(), selectionGroup.getEndRes(),
- clone);
+ alignment.getHiddenColumns());
}
else
{
- alignment.getHiddenColumns().makeVisibleAnnotation(clone);
+ clone.makeVisibleAnnotation(alignment.getHiddenColumns());
}
ala.add(clone);
}
{
updateConsensus(ap);
}
- if (consensusProfiles != null && autoCalculateConsensus)
+ if (hconsensus != null && autoCalculateConsensus)
{
updateConservation(ap);
}
{
updateStrucConsensus(ap);
}
- // initInformation();
- updateInformation(ap);
// Reset endRes of groups if beyond alignment width
int alWidth = alignment.getWidth();
updateAllColourSchemes();
calculator.restartWorkers();
- // alignment.adjustSequenceAnnotations();
}
/**
{
rs.alignmentChanged(alignment, hiddenRepSequences);
- rs.setConsensus(consensusProfiles);
+ rs.setConsensus(hconsensus);
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 (consensusProfiles == null && !isDataset)
+ if (hconsensus == null && !isDataset)
{
if (!alignment.isNucleotide())
{
new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
initConsensus(consensus);
- initOccupancy();
+ initGapCounts();
initComplementConsensus();
}
// these should be extracted from the view model - style and settings for
// derived annotation
- private void initOccupancy()
+ private void initGapCounts()
{
if (showOccupancy)
{
- occupancy = new AlignmentAnnotation("Occupancy",
+ gapcounts = new AlignmentAnnotation("Occupancy",
MessageManager.getString("label.occupancy_descr"),
new Annotation[1], 0f, alignment.getHeight(),
AlignmentAnnotation.BAR_GRAPH);
- occupancy.hasText = true;
- occupancy.autoCalculated = true;
- occupancy.scaleColLabel = true;
- occupancy.graph = AlignmentAnnotation.BAR_GRAPH;
+ gapcounts.hasText = true;
+ gapcounts.autoCalculated = true;
+ gapcounts.scaleColLabel = true;
+ gapcounts.graph = AlignmentAnnotation.BAR_GRAPH;
- alignment.addAnnotation(occupancy);
+ alignment.addAnnotation(gapcounts);
}
}
sg.setshowSequenceLogo(showprf);
sg.setShowConsensusHistogram(showConsHist);
sg.setNormaliseSequenceLogo(normLogo);
- sg.setshowHMMSequenceLogo(showHMMPrf);
+ sg.setShowHMMSequenceLogo(showHMMPrf);
sg.setShowInformationHistogram(showInfoHist);
sg.setNormaliseHMMSequenceLogo(normHMMLogo);
}
int lastSeq = alignment.getHeight() - 1;
List<AlignedCodonFrame> seqMappings = null;
for (int seqNo = ranges
- .getStartSeq(); seqNo < lastSeq; seqNo++, seqOffset++)
+ .getStartSeq(); seqNo <= lastSeq; seqNo++, seqOffset++)
{
sequence = getAlignment().getSequenceAt(seqNo);
if (hiddenSequences != null && hiddenSequences.isHidden(sequence))
{
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;
+ }
+
+ /**
+ * flag set to indicate if structure views might be out of sync with sequences
+ * in the alignment
+ */
+
+ private boolean needToUpdateStructureViews = false;
+
+ @Override
+ public boolean isUpdateStructures()
+ {
+ return needToUpdateStructureViews;
+ }
+
+ @Override
+ public void setUpdateStructures(boolean update)
+ {
+ needToUpdateStructureViews = update;
+ }
+
+ @Override
+ public boolean needToUpdateStructureViews()
+ {
+ boolean update = needToUpdateStructureViews;
+ needToUpdateStructureViews = false;
+ return update;
+ }
+
+ @Override
+ public void addSequenceGroup(SequenceGroup sequenceGroup)
+ {
+ alignment.addGroup(sequenceGroup);
+
+ Color col = sequenceGroup.idColour;
+ if (col != null)
+ {
+ col = col.brighter();
+
+ for (SequenceI sq : sequenceGroup.getSequences())
+ {
+ setSequenceColour(sq, col);
+ }
+ }
+
+ if (codingComplement != null)
+ {
+ SequenceGroup mappedGroup = MappingUtils
+ .mapSequenceGroup(sequenceGroup, this, codingComplement);
+ if (mappedGroup.getSequences().size() > 0)
+ {
+ codingComplement.getAlignment().addGroup(mappedGroup);
+
+ if (col != null)
+ {
+ for (SequenceI seq : mappedGroup.getSequences())
+ {
+ codingComplement.setSequenceColour(seq, col);
+ }
+ }
+ }
+ // propagate the structure view update flag according to our own setting
+ codingComplement.setUpdateStructures(needToUpdateStructureViews);
+ }
+ }
}
git://source.jalview.org / jalview.git / blobdiff