public GraphFullScan(IDocumentUIContainer documentUIContainer)
{
InitializeComponent();
graphControl.GraphPane = new HeatMapGraphPane
{
MinDotRadius = MIN_DOT_RADIUS,
MaxDotRadius = MAX_DOT_RADIUS
};
Icon = Resources.SkylineData;
_graphHelper = GraphHelper.Attach(graphControl);
_documentContainer = documentUIContainer;
_documentContainer.ListenUI(OnDocumentUIChanged);
_msDataFileScanHelper = new MsDataFileScanHelper(SetSpectra, HandleLoadScanException);
GraphPane.Title.IsVisible = true;
GraphPane.Legend.IsVisible = false;
// Make sure to use italics for "m/z"
AbstractMSGraphItem.SetAxisText(GraphPane.XAxis, Resources.AbstractMSGraphItem_CustomizeXAxis_MZ);
magnifyBtn.Checked = Settings.Default.AutoZoomFullScanGraph;
spectrumBtn.Checked = Settings.Default.SumScansFullScan;
filterBtn.Checked = Settings.Default.FilterDriftTimesFullScan;
spectrumBtn.Visible = false;
filterBtn.Visible = false;
lblScanId.Visible = false; // you might want to show the scan index for debugging
}
private void UpdateAxes(bool resetAxes, GraphValues.AggregateOp aggregateOp, AreaNormalizeToData normalizeData,
AreaNormalizeToView areaView, IsotopeLabelType standardType)
{
if (resetAxes)
{
XAxis.Scale.MaxAuto = XAxis.Scale.MinAuto = true;
YAxis.Scale.MaxAuto = true;
}
if (BarSettings.Type == BarType.PercentStack)
{
YAxis.Scale.Max = 100;
YAxis.Scale.MaxAuto = false;
YAxis.Title.Text = aggregateOp.AnnotateTitle(Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area_Percentage);
YAxis.Type = AxisType.Linear;
YAxis.Scale.MinAuto = false;
FixedYMin = YAxis.Scale.Min = 0;
}
else
{
if (normalizeData == AreaNormalizeToData.optimization)
{
// If currently log scale or normalized to max, reset the y-axis max
if (YAxis.Type == AxisType.Log || YAxis.Scale.Max == 1)
YAxis.Scale.MaxAuto = true;
YAxis.Title.Text = aggregateOp.AnnotateTitle(Resources.AreaReplicateGraphPane_UpdateGraph_Percent_of_Regression_Peak_Area);
YAxis.Type = AxisType.Linear;
YAxis.Scale.MinAuto = false;
FixedYMin = YAxis.Scale.Min = 0;
}
else if (areaView == AreaNormalizeToView.area_maximum_view)
{
YAxis.Scale.Max = 1;
if (IsDotProductVisible)
// Make YAxis Scale Max a little higher to accommodate for the dot products
YAxis.Scale.Max = 1.1;
YAxis.Scale.MaxAuto = false;
YAxis.Title.Text = aggregateOp.AnnotateTitle(Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area_Normalized);
YAxis.Type = AxisType.Linear;
YAxis.Scale.MinAuto = false;
FixedYMin = YAxis.Scale.Min = 0;
}
else if (Settings.Default.AreaLogScale)
{
// If currently not log scale, reset the y-axis max
if (YAxis.Type != AxisType.Log)
YAxis.Scale.MaxAuto = true;
if (Settings.Default.PeakAreaMaxArea != 0)
{
YAxis.Scale.MaxAuto = false;
YAxis.Scale.Max = Settings.Default.PeakAreaMaxArea;
}
YAxis.Type = AxisType.Log;
YAxis.Title.Text = GraphValues.AnnotateLogAxisTitle(aggregateOp.AnnotateTitle(
Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area));
YAxis.Scale.MinAuto = false;
FixedYMin = YAxis.Scale.Min = 1;
}
else
{
// If currently log scale, reset the y-axis max
if (YAxis.Type == AxisType.Log)
YAxis.Scale.MaxAuto = true;
if (Settings.Default.PeakAreaMaxArea != 0)
{
YAxis.Scale.MaxAuto = false;
YAxis.Scale.Max = Settings.Default.PeakAreaMaxArea;
}
else if (!YAxis.Scale.MaxAuto)
{
YAxis.Scale.MaxAuto = true;
}
string yTitle = Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area;
switch (areaView)
{
case AreaNormalizeToView.area_ratio_view:
yTitle = string.Format(Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area_Ratio_To__0_,
standardType.Title);
break;
case AreaNormalizeToView.area_global_standard_view:
yTitle = Resources.AreaReplicateGraphPane_UpdateGraph_Peak_Area_Ratio_To_Global_Standards;
break;
}
YAxis.Title.Text = aggregateOp.AnnotateTitle(yTitle);
YAxis.Type = AxisType.Linear;
YAxis.Scale.MinAuto = false;
FixedYMin = YAxis.Scale.Min = 0;
}
// Handle a switch from percent stack
if (!YAxis.Scale.MaxAuto && YAxis.Scale.Max == 100)
YAxis.Scale.MaxAuto = true;
}
Legend.IsVisible = Settings.Default.ShowPeakAreaLegend;
AxisChange();
// Reformat Y-Axis for labels and whiskers
var maxY = GraphHelper.GetMaxY(CurveList,this);
if (IsDotProductVisible)
{
var extraSpace = _lableHeight*(maxY/(Chart.Rect.Height - _lableHeight*2))*2;
maxY += extraSpace;
}
GraphHelper.ReformatYAxis(this, maxY);
}
public void UpdateUI(bool selectionChanged = true)
{
// Only worry about updates, if the graph is visible
// And make sure it is not disposed, since rendering happens on a timer
if (!Visible || IsDisposed)
{
return;
}
// Clear existing data from the graph pane
var graphPane = (MSGraphPane)graphControl.MasterPane[0];
graphPane.CurveList.Clear();
graphPane.GraphObjList.Clear();
GraphItem = null;
GraphHelper.FormatGraphPane(graphControl.GraphPane);
GraphHelper.FormatFontSize(graphControl.GraphPane, Settings.Default.SpectrumFontSize);
// Try to find a tree node with spectral library info associated
// with the current selection.
var nodeTree = _stateProvider.SelectedNode as SrmTreeNode;
var nodeGroupTree = nodeTree as TransitionGroupTreeNode;
var nodeTranTree = nodeTree as TransitionTreeNode;
if (nodeTranTree != null)
{
nodeGroupTree = nodeTranTree.Parent as TransitionGroupTreeNode;
}
var nodeGroup = (nodeGroupTree != null ? nodeGroupTree.DocNode : null);
PeptideTreeNode nodePepTree;
if (nodeGroup == null)
{
nodePepTree = nodeTree as PeptideTreeNode;
if (nodePepTree != null)
{
var listInfoGroups = GetLibraryInfoChargeGroups(nodePepTree);
if (listInfoGroups.Length == 1)
{
nodeGroup = listInfoGroups[0];
}
else if (listInfoGroups.Length > 1)
{
_nodeGroup = null;
toolBar.Visible = false;
_graphHelper.SetErrorGraphItem(new NoDataMSGraphItem(
Resources.GraphSpectrum_UpdateUI_Multiple_charge_states_with_library_spectra));
return;
}
}
}
else
{
nodePepTree = nodeGroupTree.Parent as PeptideTreeNode;
}
// Check for appropriate spectrum to load
SrmSettings settings = DocumentUI.Settings;
PeptideLibraries libraries = settings.PeptideSettings.Libraries;
bool available = false;
if (nodeGroup == null || (!nodeGroup.HasLibInfo && !libraries.HasMidasLibrary))
{
_spectra = null;
}
else
{
TransitionGroup group = nodeGroup.TransitionGroup;
TransitionDocNode transition = (nodeTranTree == null ? null : nodeTranTree.DocNode);
string lookupSequence = group.Peptide.TextId; // Sequence or custom ion id
ExplicitMods lookupMods = null;
if (nodePepTree != null)
{
lookupSequence = nodePepTree.DocNode.SourceUnmodifiedTextId;
lookupMods = nodePepTree.DocNode.SourceExplicitMods;
}
try
{
// Try to load a list of spectra matching the criteria for
// the current node group.
if (libraries.HasLibraries && libraries.IsLoaded)
{
if (NodeGroupChanged(nodeGroup))
{
try
{
UpdateSpectra(nodeGroup, lookupSequence, lookupMods);
UpdateToolbar();
}
catch (Exception)
{
_spectra = null;
UpdateToolbar();
throw;
}
_nodeGroup = nodeGroup;
if (settings.TransitionSettings.Instrument.IsDynamicMin)
{
ZoomSpectrumToSettings();
}
}
var spectrum = SelectedSpectrum;
if (spectrum != null)
{
IsotopeLabelType typeInfo = spectrum.LabelType;
var types = _stateProvider.ShowIonTypes;
var charges = _stateProvider.ShowIonCharges;
var rankTypes = settings.TransitionSettings.Filter.IonTypes;
var rankCharges = settings.TransitionSettings.Filter.ProductCharges;
// Make sure the types and charges in the settings are at the head
// of these lists to give them top priority, and get rankings correct.
int i = 0;
foreach (IonType type in rankTypes)
{
if (types.Remove(type))
{
types.Insert(i++, type);
}
}
i = 0;
foreach (int charge in rankCharges)
{
if (charges.Remove(charge))
{
charges.Insert(i++, charge);
}
}
SpectrumPeaksInfo spectrumInfo = spectrum.SpectrumPeaksInfo;
var spectrumInfoR = new LibraryRankedSpectrumInfo(spectrumInfo,
typeInfo,
group,
settings,
lookupSequence,
lookupMods,
charges,
types,
rankCharges,
rankTypes);
GraphItem = new SpectrumGraphItem(nodeGroup, transition, spectrumInfoR, spectrum.LibName)
{
ShowTypes = types,
ShowCharges = charges,
ShowRanks = Settings.Default.ShowRanks,
ShowMz = Settings.Default.ShowIonMz,
ShowObservedMz = Settings.Default.ShowObservedMz,
ShowDuplicates = Settings.Default.ShowDuplicateIons,
FontSize = Settings.Default.SpectrumFontSize,
LineWidth = Settings.Default.SpectrumLineWidth
};
LibraryChromGroup chromatogramData = null;
if (Settings.Default.ShowLibraryChromatograms)
{
chromatogramData = spectrum.LoadChromatogramData();
}
if (null == chromatogramData)
{
_graphHelper.ResetForSpectrum(new[] { nodeGroup.TransitionGroup });
_graphHelper.AddSpectrum(GraphItem);
_graphHelper.ZoomSpectrumToSettings(DocumentUI, nodeGroup);
}
else
{
_graphHelper.ResetForChromatograms(new[] { nodeGroup.TransitionGroup });
var displayType = GraphChromatogram.GetDisplayType(DocumentUI, nodeGroup);
IList <TransitionDocNode> displayTransitions =
GraphChromatogram.GetDisplayTransitions(nodeGroup, displayType).ToArray();
int numTrans = displayTransitions.Count;
var allChromDatas =
chromatogramData.ChromDatas.Where(
chromData => DisplayTypeMatches(chromData, displayType)).ToList();
var chromDatas = new List <LibraryChromGroup.ChromData>();
for (int iTran = 0; iTran < numTrans; iTran++)
{
var displayTransition = displayTransitions[iTran];
var indexMatch =
allChromDatas.IndexOf(chromData => IonMatches(displayTransition.Transition, chromData));
if (indexMatch >= 0)
{
chromDatas.Add(allChromDatas[indexMatch]);
allChromDatas.RemoveAt(indexMatch);
}
else
{
chromDatas.Add(null);
}
}
allChromDatas.Sort((chromData1, chromData2) => chromData1.Mz.CompareTo(chromData2.Mz));
chromDatas.AddRange(allChromDatas);
double maxHeight = chromDatas.Max(chromData => null == chromData ? double.MinValue : chromData.Height);
int iChromDataPrimary = chromDatas.IndexOf(chromData => null != chromData && maxHeight == chromData.Height);
int colorOffset = displayType == DisplayTypeChrom.products
? GraphChromatogram.GetDisplayTransitions(nodeGroup,
DisplayTypeChrom.
precursors).Count()
: 0;
for (int iChromData = 0; iChromData < chromDatas.Count; iChromData++)
{
var chromData = chromDatas[iChromData];
if (chromData == null)
{
continue;
}
string label;
var pointAnnotation = GraphItem.AnnotatePoint(new PointPair(chromData.Mz, 1.0));
if (null != pointAnnotation)
{
label = pointAnnotation.Label;
}
else
{
label = chromData.Mz.ToString("0.####"); // Not L10N
}
TransitionDocNode matchingTransition;
Color color;
if (iChromData < numTrans)
{
matchingTransition = displayTransitions[iChromData];
color =
GraphChromatogram.COLORS_LIBRARY[
(iChromData + colorOffset) % GraphChromatogram.COLORS_LIBRARY.Length];
}
else
{
matchingTransition = null;
color =
GraphChromatogram.COLORS_GROUPS[
iChromData % GraphChromatogram.COLORS_GROUPS.Length];
}
TransitionChromInfo tranPeakInfo;
ChromatogramInfo chromatogramInfo;
MakeChromatogramInfo(nodeGroup.PrecursorMz, chromatogramData, chromData, out chromatogramInfo, out tranPeakInfo);
var graphItem = new ChromGraphItem(nodeGroup, matchingTransition, chromatogramInfo, iChromData == iChromDataPrimary ? tranPeakInfo : null, null,
new[] { iChromData == iChromDataPrimary }, null, 0, false, false, 0,
color, Settings.Default.ChromatogramFontSize, 1);
LineItem curve = (LineItem)_graphHelper.AddChromatogram(PaneKey.DEFAULT, graphItem);
if (matchingTransition == null)
{
curve.Label.Text = label;
}
curve.Line.Width = Settings.Default.ChromatogramLineWidth;
if (null != transition)
{
if (IonMatches(transition.Transition, chromData))
{
color = ChromGraphItem.ColorSelected;
}
}
curve.Color = color;
}
graphPane.Title.IsVisible = false;
graphPane.Legend.IsVisible = true;
_graphHelper.FinishedAddingChromatograms(chromatogramData.StartTime, chromatogramData.EndTime, false);
graphControl.Refresh();
}
graphControl.IsEnableVPan = graphControl.IsEnableVZoom =
!Settings.Default.LockYAxis;
available = true;
}
}
}
catch (Exception)
{
_graphHelper.SetErrorGraphItem(new NoDataMSGraphItem(
Resources.GraphSpectrum_UpdateUI_Failure_loading_spectrum__Library_may_be_corrupted));
return;
}
}
// Show unavailable message, if no spectrum loaded
if (!available)
{
UpdateToolbar();
_nodeGroup = null;
_graphHelper.SetErrorGraphItem(new UnavailableMSGraphItem());
}
}
public GraphChromatogram(IStateProvider stateProvider, IDocumentUIContainer documentContainer, string name)
{
InitializeComponent();
graphControl.GraphPane = new MSGraphPane();
_graphHelper = GraphHelper.Attach(graphControl);
NameSet = name;
Icon = Resources.SkylineData;
_nameChromatogramSet = name;
_documentContainer = documentContainer;
_documentContainer.ListenUI(OnDocumentUIChanged);
_stateProvider = stateProvider;
// Synchronize the zooming across all graph panes
// Note that this only affects applying ZoomState to a graph pane. Explicit changes
// to Scale Min/Max properties need to be manually applied to each axis.
graphControl.IsSynchronizeXAxes = true;
}
public static GraphHelper Attach(MSGraphControl msGraphControl)
{
GraphHelper graphHelper = new GraphHelper(msGraphControl);
msGraphControl.MasterPane.Border.IsVisible = false;
msGraphControl.GraphPane.Border.IsVisible = false;
msGraphControl.GraphPane.AllowCurveOverlap = true;
return graphHelper;
}
public override void UpdateGraph(bool checkData)
{
GraphHelper.FormatGraphPane(this);
SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI;
PeptideDocNode nodeSelected = null;
int resultIndex = (ShowReplicate == ReplicateDisplay.single ? GraphSummary.ResultsIndex : -1);
var results = document.Settings.MeasuredResults;
bool resultsAvailable = results != null;
if (resultsAvailable)
{
if (resultIndex == -1)
{
resultsAvailable = results.IsLoaded;
}
else
{
resultsAvailable = results.Chromatograms.Count > resultIndex &&
results.IsChromatogramSetLoaded(resultIndex);
}
}
if (!resultsAvailable)
{
Clear();
}
else
{
var nodeTree = GraphSummary.StateProvider.SelectedNode as SrmTreeNode;
var nodePeptide = nodeTree as PeptideTreeNode;
while (nodePeptide == null && nodeTree != null)
{
nodeTree = nodeTree.Parent as SrmTreeNode;
nodePeptide = nodeTree as PeptideTreeNode;
}
if (nodePeptide != null)
{
nodeSelected = nodePeptide.DocNode;
}
if (checkData)
{
double threshold = RTGraphController.OutThreshold;
bool refine = Settings.Default.RTRefinePeptides;
bool bestResult = (ShowReplicate == ReplicateDisplay.best);
if (!IsValidFor(document, resultIndex, bestResult, threshold, refine))
{
Update(document, resultIndex, threshold, refine);
if (refine && !IsRefined)
{
// Do refinement on a background thread.
ActionUtil.RunAsync(RefineData, "Refine data"); // Not L10N
}
}
}
Graph(nodeSelected);
}
AxisChange();
GraphSummary.GraphControl.Invalidate();
}