protected virtual void InitData() { List <DocNode> docNodes = new List <DocNode>(); List <List <PointPairList> > pointPairLists = new List <List <PointPairList> >(); List <String> docNodeLabels = new List <string>(); // ReSharper disable CanBeReplacedWithTryCastAndCheckForNull if (_docNode is TransitionDocNode) { var nodeTran = (TransitionDocNode)_docNode; ReplicateGroups = GetReplicateGroups(GetReplicateIndices(nodeTran)).ToArray(); docNodes.Add(nodeTran); pointPairLists.Add(GetPointPairLists(null, nodeTran, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeTran)); } else if (_docNode is TransitionGroupDocNode) { var nodeGroup = (TransitionGroupDocNode)_docNode; ReplicateGroups = GetReplicateGroups(GetReplicateIndices(nodeGroup)).ToArray(); if (_displayType == DisplayTypeChrom.single || _displayType == DisplayTypeChrom.total) { docNodes.Add(nodeGroup); pointPairLists.Add(GetPointPairLists(nodeGroup, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeGroup)); } else { foreach (TransitionDocNode nodeTran in GraphChromatogram.GetDisplayTransitions(nodeGroup, _displayType)) { docNodes.Add(nodeTran); pointPairLists.Add(GetPointPairLists(nodeGroup, nodeTran, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeTran)); } } } else if (_docNode is PeptideDocNode) { var nodePep = (PeptideDocNode)_docNode; ReplicateGroups = GetReplicateGroups(GetReplicateIndices(nodePep)).ToArray(); foreach (TransitionGroupDocNode nodeGroup in nodePep.Children) { if (!_paneKey.IncludesTransitionGroup(nodeGroup)) { continue; } docNodes.Add(nodeGroup); pointPairLists.Add(GetPointPairLists(nodeGroup, DisplayTypeChrom.total)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeGroup)); } } // ReSharper restore CanBeReplacedWithTryCastAndCheckForNull PointPairLists = pointPairLists; DocNodes = docNodes; DocNodeLabels = docNodeLabels; }
protected override void InitData() { base.InitData(); if (_expectedVisible != AreaExpectedValue.none) { var nodeGroup = (TransitionGroupDocNode)_docNode; var expectedIntensities = from nodeTran in GraphChromatogram.GetDisplayTransitions(nodeGroup, DisplayType) select GetExpectedValue(nodeTran); var intensityArray = expectedIntensities.ToArray(); for (int i = 0; i < PointPairLists.Count; i++) { if (i >= intensityArray.Length) { continue; } var pointPairLists2 = PointPairLists[i]; foreach (var pointPairList in pointPairLists2) { pointPairList.Insert(0, 0, intensityArray[i]); } } } switch (_normalize) { case AreaNormalizeToData.none: // If library column is showing, make library column as tall as the tallest stack if (_expectedVisible != AreaExpectedValue.none) { NormalizeMaxStack(); } break; case AreaNormalizeToData.optimization: NormalizeOpt(); break; case AreaNormalizeToData.maximum: NormalizeMax(); break; case AreaNormalizeToData.maximum_stack: NormalizeMaxStack(); break; case AreaNormalizeToData.total: FixupForTotals(); break; } }
protected virtual void InitData() { List <DocNode> docNodes = new List <DocNode>(); List <IdentityPath> docNodePaths = new List <IdentityPath>(); List <List <PointPairList> > pointPairLists = new List <List <PointPairList> >(); List <String> docNodeLabels = new List <string>(); ReplicateGroups = new ReplicateGroup[0]; foreach (var docNodePath in _selectedDocNodePaths) { var nodeArray = _document.ToNodeArray(docNodePath); var docNode = nodeArray.Last(); var replicateIndices = Enumerable.Range(0, _document.Settings.MeasuredResults.Chromatograms.Count); // ReSharper disable CanBeReplacedWithTryCastAndCheckForNull if (docNode is TransitionDocNode) { var nodeTran = (TransitionDocNode)docNode; ReplicateGroups = GetReplicateGroups(replicateIndices).ToArray(); docNodes.Add(nodeTran); docNodePaths.Add(docNodePath); pointPairLists.Add(GetPointPairLists((PeptideDocNode)nodeArray[1], (TransitionGroupDocNode)nodeArray[2], nodeTran, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeTran)); } else if (docNode is TransitionGroupDocNode) { var nodeGroup = (TransitionGroupDocNode)docNode; var peptideDocNode = (PeptideDocNode)nodeArray[1]; ReplicateGroups = GetReplicateGroups(replicateIndices).ToArray(); if (_displayType == DisplayTypeChrom.single || _displayType == DisplayTypeChrom.total) { docNodes.Add(nodeGroup); docNodePaths.Add(docNodePath); pointPairLists.Add(GetPointPairLists(peptideDocNode, nodeGroup, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeGroup)); } else { foreach (TransitionDocNode nodeTran in GraphChromatogram.GetDisplayTransitions(nodeGroup, _displayType)) { docNodes.Add(nodeTran); docNodePaths.Add(new IdentityPath(docNodePath, nodeTran.Id)); pointPairLists.Add(GetPointPairLists(peptideDocNode, nodeGroup, nodeTran, _displayType)); docNodeLabels.Add(ChromGraphItem.GetTitle(nodeTran)); } } } else if (docNode is PeptideDocNode) { var nodePep = (PeptideDocNode)docNode; ReplicateGroups = GetReplicateGroups(replicateIndices).ToArray(); var isMultiSelect = _selectedDocNodePaths.Count > 1 || (_selectedDocNodePaths.Count == 1 && Program.MainWindow != null && Program.MainWindow.SelectedNode is PeptideGroupTreeNode); foreach (var tuple in GetPeptidePointPairLists((PeptideGroupDocNode)nodeArray[0], nodePep, isMultiSelect)) { docNodes.Add(tuple.Node); docNodePaths.Add(docNodePath); pointPairLists.Add(tuple.PointPairList); docNodeLabels.Add(tuple.DisplaySeq); } } } // ReSharper restore CanBeReplacedWithTryCastAndCheckForNull PointPairLists = pointPairLists; DocNodes = docNodes; _docNodePaths = ImmutableList.ValueOf(docNodePaths); DocNodeLabels = docNodeLabels; var oldGroupNames = ReplicateGroups.Select(g => g.GroupName).ToArray(); var uniqueGroupNames = oldGroupNames.Distinct().ToArray(); // Instert "All" groups and point pair lists in their correct positions InsertAllGroupsAndPointPairLists(uniqueGroupNames, docNodes.Count); // Collect all references to points that have a valid Y value var references = CollectValidPointRefs(uniqueGroupNames, oldGroupNames, docNodes.Count); // Merge groups if their replicate index is the same and each peptide only occurs in one of the files MergeGroups(uniqueGroupNames, references); // Remove groups that don't have any peptides in them RemoveEmptyGroups(docNodes.Count); }
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); var lookupSequence = group.Peptide.Target;// Sequence or custom ion id ExplicitMods lookupMods = null; if (nodePepTree != null) { lookupSequence = nodePepTree.DocNode.SourceUnmodifiedTarget; 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(group.IsProteomic); var adducts = (group.IsProteomic ? Transition.DEFAULT_PEPTIDE_LIBRARY_CHARGES : nodeGroup.InUseAdducts).ToArray(); var charges = _stateProvider.ShowIonCharges(adducts); var rankTypes = group.IsProteomic ? settings.TransitionSettings.Filter.PeptideIonTypes : settings.TransitionSettings.Filter.SmallMoleculeIonTypes; var rankAdducts = group.IsProteomic ? settings.TransitionSettings.Filter.PeptideProductCharges : settings.TransitionSettings.Filter.SmallMoleculeFragmentAdducts; var rankCharges = Adduct.OrderedAbsoluteChargeValues(rankAdducts); // 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; var showAdducts = new List <Adduct>(); foreach (var charge in rankCharges) { if (charges.Remove(charge)) { charges.Insert(i++, charge); } // NB for all adducts we just look at abs value of charge // CONSIDER(bspratt): we may want finer per-adduct control for small molecule use showAdducts.AddRange(adducts.Where(a => charge == Math.Abs(a.AdductCharge))); } showAdducts.AddRange(adducts.Where(a => charges.Contains(Math.Abs(a.AdductCharge)) && !showAdducts.Contains(a))); SpectrumPeaksInfo spectrumInfo = spectrum.SpectrumPeaksInfo; var spectrumInfoR = new LibraryRankedSpectrumInfo(spectrumInfo, typeInfo, nodeGroup, settings, lookupSequence, lookupMods, showAdducts, types, rankAdducts, 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.####"); } TransitionDocNode matchingTransition; Color color; if (iChromData < numTrans) { matchingTransition = displayTransitions[iChromData]; color = GraphChromatogram.COLORS_LIBRARY[ (iChromData + colorOffset) % GraphChromatogram.COLORS_LIBRARY.Count]; } else { matchingTransition = null; color = GraphChromatogram.COLORS_GROUPS[ iChromData % GraphChromatogram.COLORS_GROUPS.Count]; } 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, null, 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()); } }
private DockPane FindChromatogramPane(GraphChromatogram graphChrom, out IDockableForm formBefore) { foreach (var pane in dockPanel.Panes) { foreach (IDockableForm form in pane.Contents) { if (form is GraphChromatogram && (graphChrom == null || graphChrom == form)) { formBefore = form; return pane; } } } formBefore = null; return null; }
private void DestroyGraphChrom(GraphChromatogram graphChrom) { // Detach event handlers and dispose graphChrom.FormClosed -= graphChromatogram_FormClosed; graphChrom.PickedPeak -= graphChromatogram_PickedPeak; graphChrom.ClickedChromatogram -= graphChromatogram_ClickedChromatogram; graphChrom.ChangedPeakBounds -= graphChromatogram_ChangedPeakBounds; graphChrom.PickedSpectrum -= graphChromatogram_PickedSpectrum; graphChrom.ZoomAll -= graphChromatogram_ZoomAll; graphChrom.HideOnClose = false; graphChrom.Close(); }
private GraphChromatogram CreateGraphChrom(string name) { var graphChrom = new GraphChromatogram(this, this, name); graphChrom.FormClosed += graphChromatogram_FormClosed; graphChrom.PickedPeak += graphChromatogram_PickedPeak; graphChrom.ClickedChromatogram += graphChromatogram_ClickedChromatogram; graphChrom.ChangedPeakBounds += graphChromatogram_ChangedPeakBounds; graphChrom.PickedSpectrum += graphChromatogram_PickedSpectrum; graphChrom.ZoomAll += graphChromatogram_ZoomAll; _listGraphChrom.Add(graphChrom); return graphChrom; }
public override void UpdateGraph(bool selectionChanged) { Clear(); TransitionGroupDocNode selectedGroup = null; PeptideGroupDocNode selectedProtein = null; var selectedTreeNode = GraphSummary.StateProvider.SelectedNode as SrmTreeNode; if (selectedTreeNode != null) { if (selectedTreeNode is TransitionTreeNode) { selectedGroup = (TransitionGroupDocNode)selectedTreeNode.SrmParent.Model; } else if (selectedTreeNode is TransitionGroupTreeNode) { selectedGroup = (TransitionGroupDocNode)selectedTreeNode.Model; } else { var node = selectedTreeNode as PeptideTreeNode; if (node != null) { var nodePep = node.DocNode; selectedGroup = nodePep.TransitionGroups.FirstOrDefault(); } } var proteinTreeNode = selectedTreeNode.GetNodeOfType <PeptideGroupTreeNode>(); if (proteinTreeNode != null) { selectedProtein = proteinTreeNode.DocNode; } } SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI; var displayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); _graphData = CreateGraphData(document, selectedProtein, selectedGroup, displayType); int iColor = 0; int colorOffset = 0; if (selectedGroup != null && displayType == DisplayTypeChrom.products) { // If we are only displaying product ions, we want to use an offset in the colors array // so that we do not re-use colors that would be used for any precursor ions. colorOffset = GraphChromatogram.GetDisplayTransitions(selectedGroup, DisplayTypeChrom.precursors).Count(); } foreach (var pointPairList in _graphData.PointPairLists) { Color color = displayType == DisplayTypeChrom.total ? COLORS_GROUPS[iColor++ % COLORS_GROUPS.Count] : COLORS_TRANSITION[(iColor++ + colorOffset) % COLORS_TRANSITION.Count]; BarItem curveItem; if (HiLowMiddleErrorBarItem.IsHiLoMiddleErrorList(pointPairList)) { curveItem = new HiLowMiddleErrorBarItem(string.Empty, pointPairList, color, Color.Black); } else { curveItem = new MeanErrorBarItem(string.Empty, pointPairList, color, Color.Black); } curveItem.Bar.Border.IsVisible = false; curveItem.Bar.Fill.Brush = new SolidBrush(color); CurveList.Add(curveItem); } if (ShowSelection && SelectedIndex != -1) { double yValue = _graphData.SelectedMaxY; double yMin = _graphData.SelectedMinY; double height = yValue - yMin; GraphObjList.Add(new BoxObj(SelectedIndex + .5, yValue, 0.99, height, Color.Black, Color.Empty) { IsClippedToChartRect = true, }); } UpdateAxes(); }
// ReSharper disable PossibleMultipleEnumeration protected GraphData(SrmDocument document, TransitionGroupDocNode selectedGroup, PeptideGroupDocNode selectedProtein, int?iResult, DisplayTypeChrom displayType, GraphValues.IRetentionTimeTransformOp retentionTimeTransformOp, PaneKey paneKey) { RetentionTimeTransformOp = retentionTimeTransformOp; // Determine the shortest possible unique ID for each peptide or molecule var sequences = new List <Tuple <string, bool> >(); foreach (var nodePep in document.Molecules) { sequences.Add(new Tuple <string, bool>(nodePep.ModifiedTarget.DisplayName, nodePep.IsProteomic)); } var uniquePrefixGenerator = new UniquePrefixGenerator(sequences, 3); int pointListCount = 0; var dictTypeToSet = new Dictionary <IsotopeLabelType, int>(); bool onePointPerPeptide = PeptideOrder == SummaryPeptideOrder.document && null != paneKey.IsotopeLabelType; // Figure out how many point lists to create bool displayTotals = (displayType == DisplayTypeChrom.total); if (displayTotals) { foreach (var nodeGroup in document.MoleculeTransitionGroups) { if (!paneKey.IncludesTransitionGroup(nodeGroup)) { continue; } IsotopeLabelType labelType = nodeGroup.TransitionGroup.LabelType; if (!dictTypeToSet.ContainsKey(labelType)) { dictTypeToSet.Add(labelType, pointListCount++); } } } else { foreach (var nodeGroup in document.MoleculeTransitionGroups) { if (!paneKey.IncludesTransitionGroup(nodeGroup)) { continue; } pointListCount = Math.Max(pointListCount, GraphChromatogram.GetDisplayTransitions(nodeGroup, displayType).Count()); } } // Build the list of points to show. var listPoints = new List <GraphPointData>(); foreach (PeptideGroupDocNode nodeGroupPep in document.MoleculeGroups) { if (AreaGraphController.AreaScope == AreaScope.protein) { if (!ReferenceEquals(nodeGroupPep, selectedProtein)) { continue; } } foreach (PeptideDocNode nodePep in nodeGroupPep.Children) { bool addBlankPoint = onePointPerPeptide && !nodePep.TransitionGroups.Any(paneKey.IncludesTransitionGroup); foreach (TransitionGroupDocNode nodeGroup in nodePep.Children) { var path = new IdentityPath(nodeGroupPep.PeptideGroup, nodePep.Peptide, nodeGroup.TransitionGroup); var graphPointData = new GraphPointData(nodePep, nodeGroup, path); if (addBlankPoint || paneKey.IncludesTransitionGroup(nodeGroup)) { listPoints.Add(graphPointData); } if (addBlankPoint) { break; } } } } // Sort into correct order var peptideOrder = PeptideOrder; if (peptideOrder == SummaryPeptideOrder.time) { if (displayTotals) { listPoints.Sort(ComparePeptideTimes); } else { listPoints.Sort(CompareGroupTimes); } } else if (peptideOrder == SummaryPeptideOrder.area) { listPoints.Sort(CompareGroupAreas); } else if (peptideOrder == SummaryPeptideOrder.mass_error) { listPoints.Sort(CompareGroupMassErrors); } // Init calculated values var pointPairLists = new List <PointPairList>(); var labels = new List <string>(); var xscalePaths = new List <IdentityPath>(); double maxY = 0; double minY = double.MaxValue; int selectedIndex = -1; for (int i = 0; i < pointListCount; i++) { pointPairLists.Add(new PointPairList()); } // Calculate lists and values PeptideDocNode nodePepCurrent = null; int chargeCount = 0; var chargeCurrent = Adduct.EMPTY; foreach (var dataPoint in listPoints) { var nodePep = dataPoint.NodePep; var nodeGroup = dataPoint.NodeGroup; if (!ReferenceEquals(nodePep, nodePepCurrent)) { nodePepCurrent = nodePep; chargeCount = GetChargeCount(nodePep); chargeCurrent = Adduct.EMPTY; } bool addLabel = !displayTotals; if (displayTotals && !Equals(nodeGroup.TransitionGroup.PrecursorAdduct, chargeCurrent)) { LevelPointPairLists(pointPairLists); addLabel = true; } chargeCurrent = nodeGroup.TransitionGroup.PrecursorAdduct; var transitionGroup = nodeGroup.TransitionGroup; int iGroup = labels.Count; if (addLabel) { string label = uniquePrefixGenerator.GetUniquePrefix(nodePep.ModifiedTarget.DisplayName, nodePep.IsProteomic) + (chargeCount > 1 ? Transition.GetChargeIndicator(transitionGroup.PrecursorAdduct) : string.Empty); if (!displayTotals && null == paneKey.IsotopeLabelType) { label += transitionGroup.LabelTypeText; } if (peptideOrder == SummaryPeptideOrder.time) { label += string.Format(@" ({0:F01})", displayTotals ? dataPoint.TimePepCharge : dataPoint.TimeGroup); } labels.Add(label); xscalePaths.Add(dataPoint.IdentityPath); } double groupMaxY = 0; double groupMinY = double.MaxValue; // ReSharper disable DoNotCallOverridableMethodsInConstructor int?resultIndex = iResult.HasValue && iResult >= 0 ? iResult : null; if (RTLinearRegressionGraphPane.ShowReplicate == ReplicateDisplay.best && nodePep != null) { resultIndex = null; int iBest = nodePep.BestResult; if (iBest != -1) { resultIndex = iBest; } } if (displayTotals) { var labelType = nodeGroup.TransitionGroup.LabelType; if (dictTypeToSet.ContainsKey(labelType)) { if (paneKey.IncludesTransitionGroup(nodeGroup)) { pointPairLists[dictTypeToSet[labelType]].Add(CreatePointPair(iGroup, nodeGroup, ref groupMaxY, ref groupMinY, resultIndex)); } else { pointPairLists[dictTypeToSet[labelType]].Add(PointPairMissing(iGroup)); } } } else { if (paneKey.IncludesTransitionGroup(nodeGroup)) { var nodeTrans = GraphChromatogram.GetDisplayTransitions(nodeGroup, displayType).ToArray(); for (int i = 0; i < pointListCount; i++) { var pointPairList = pointPairLists[i]; pointPairList.Add(i >= nodeTrans.Length ? CreatePointPairMissing(iGroup) : CreatePointPair(iGroup, nodeTrans[i], ref groupMaxY, ref groupMinY, resultIndex)); } } else { for (int i = 0; i < pointListCount; i++) { pointPairLists[i].Add(CreatePointPairMissing(iGroup)); } } } // ReSharper restore DoNotCallOverridableMethodsInConstructor // Save the selected index and its y extent if (ReferenceEquals(selectedGroup, nodeGroup)) { selectedIndex = labels.Count - 1; SelectedMaxY = groupMaxY; SelectedMinY = groupMinY; } // If multiple groups in the selection, make sure y extent is max of them else if (selectedIndex == labels.Count - 1) { SelectedMaxY = Math.Max(groupMaxY, SelectedMaxY); SelectedMinY = Math.Min(groupMinY, SelectedMinY); } maxY = Math.Max(maxY, groupMaxY); minY = Math.Min(minY, groupMinY); } PointPairLists = pointPairLists; Labels = labels.ToArray(); XScalePaths = xscalePaths.ToArray(); SelectedIndex = selectedIndex; MaxY = maxY; if (minY != double.MaxValue) { MinY = minY; } }
public override void UpdateGraph(bool selectionChanged) { SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI; var results = document.Settings.MeasuredResults; bool resultsAvailable = results != null; Clear(); if (!resultsAvailable) { Title.Text = Resources.RTReplicateGraphPane_UpdateGraph_No_results_available; EmptyGraph(document); return; } var selectedTreeNode = GraphSummary.StateProvider.SelectedNode as SrmTreeNode ?? GraphSummary.StateProvider.SelectedNodes.OfType <SrmTreeNode>().FirstOrDefault(); if (selectedTreeNode == null || document.FindNode(selectedTreeNode.Path) == null) { EmptyGraph(document); return; } Title.Text = null; DisplayTypeChrom displayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); DocNode selectedNode = selectedTreeNode.Model; IdentityPath selectedPath = selectedTreeNode.Path; DocNode parentNode = selectedNode; IdentityPath parentPath = selectedTreeNode.Path; // If the selected tree node is a transition, then its siblings are displayed. if (selectedTreeNode is TransitionTreeNode) { if (displayType != DisplayTypeChrom.single) { SrmTreeNode parentTreeNode = selectedTreeNode.SrmParent; parentNode = parentTreeNode.Model; selectedPath = parentTreeNode.Path; } } // If the selected node is a peptide with one child, then show the children, // unless chromatogram display type is total else if (selectedTreeNode is PeptideTreeNode) { var children = ((DocNodeParent)selectedNode).Children; if (children.Count == 1 && displayType != DisplayTypeChrom.total) { selectedNode = parentNode = children[0]; selectedPath = new IdentityPath(parentPath, children[0].Id); } } else if (!(selectedTreeNode is PeptideGroupTreeNode) && !(selectedTreeNode is TransitionGroupTreeNode)) { Title.Text = Resources.RTReplicateGraphPane_UpdateGraph_Select_a_peptide_to_see_the_retention_time_graph; CanShowRTLegend = false; return; } // If a precursor is going to be displayed with display type single if (parentNode is TransitionGroupDocNode && displayType == DisplayTypeChrom.single) { // If no optimization data, then show all the transitions if (!results.Chromatograms.Contains(chrom => chrom.OptimizationFunction != null)) { displayType = DisplayTypeChrom.all; } } var rtTransformOp = GraphSummary.StateProvider.GetRetentionTimeTransformOperation(); var rtValue = RTPeptideGraphPane.RTValue; GraphValues.ReplicateGroupOp replicateGroupOp; if (rtValue == RTPeptideValue.All) { replicateGroupOp = GraphValues.ReplicateGroupOp.FromCurrentSettings(document.Settings, GraphValues.AggregateOp.MEAN); } else { replicateGroupOp = GraphValues.ReplicateGroupOp.FromCurrentSettings(document.Settings); } var retentionTimeValue = new GraphValues.RetentionTimeTransform(rtValue, rtTransformOp, replicateGroupOp.AggregateOp); YAxis.Title.Text = retentionTimeValue.GetAxisTitle(); var peptidePaths = GetSelectedPeptides().GetUniquePeptidePaths().ToList(); // if PeptideGroupTreeNode is selected but has only one child isMultiSelect should still be true IsMultiSelect = peptidePaths.Count > 1 || (peptidePaths.Count == 1 && GraphSummary.StateProvider.SelectedNodes.FirstOrDefault() is PeptideGroupTreeNode); GraphData graphData = new RTGraphData(document, IsMultiSelect ? peptidePaths : new[] { selectedPath }.AsEnumerable(), displayType, retentionTimeValue, replicateGroupOp); CanShowRTLegend = graphData.DocNodes.Count != 0; InitFromData(graphData); int selectedReplicateIndex = SelectedIndex; double minRetentionTime = double.MaxValue; double maxRetentionTime = -double.MaxValue; int iColor = 0, iCharge = -1; var charge = Adduct.EMPTY; int countLabelTypes = document.Settings.PeptideSettings.Modifications.CountLabelTypes; int colorOffset = 0; var transitionGroupDocNode = parentNode as TransitionGroupDocNode; if (transitionGroupDocNode != null && displayType == DisplayTypeChrom.products) { // If we are only displaying product ions, we want to use an offset in the colors array // so that we do not re-use colors that would be used for any precursor ions. colorOffset = GraphChromatogram.GetDisplayTransitions(transitionGroupDocNode, DisplayTypeChrom.precursors).Count(); } for (int i = 0; i < graphData.DocNodes.Count; i++) { var docNode = graphData.DocNodes[i]; var identityPath = graphData.DocNodePaths[i]; var pointPairLists = graphData.PointPairLists[i]; int numSteps = pointPairLists.Count / 2; for (int iStep = 0; iStep < pointPairLists.Count; iStep++) { int step = iStep - numSteps; var pointPairList = pointPairLists[iStep]; Color color; var isSelected = false; var nodeGroup = docNode as TransitionGroupDocNode; if (IsMultiSelect) { var peptides = peptidePaths.Select(path => document.FindNode(path)) .Cast <PeptideDocNode>().ToArray(); var peptideDocNode = peptides.FirstOrDefault( peptide => 0 <= peptide.FindNodeIndex(docNode.Id)); if (peptideDocNode == null) { continue; } color = GraphSummary.StateProvider.GetPeptideGraphInfo(peptideDocNode).Color; if (identityPath.Equals(selectedTreeNode.Path) && step == 0) { color = ChromGraphItem.ColorSelected; isSelected = true; } } else if (parentNode is PeptideDocNode) { // Resharper code inspection v9.0 on TC gets this one wrong // ReSharper disable ExpressionIsAlwaysNull int iColorGroup = GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge); // ReSharper restore ExpressionIsAlwaysNull color = COLORS_GROUPS[iColorGroup % COLORS_GROUPS.Count]; } else if (displayType == DisplayTypeChrom.total) { color = COLORS_GROUPS[iColor % COLORS_GROUPS.Count]; } else if (ReferenceEquals(docNode, selectedNode) && step == 0) { color = ChromGraphItem.ColorSelected; isSelected = true; } else { color = COLORS_TRANSITION[(iColor + colorOffset) % COLORS_TRANSITION.Count]; } iColor++; string label = graphData.DocNodeLabels[i]; if (step != 0) { label = string.Format(Resources.RTReplicateGraphPane_UpdateGraph_Step__0__, step); } CurveItem curveItem; if (IsMultiSelect) { if (rtValue != RTPeptideValue.All) { curveItem = CreateLineItem(label, pointPairList, color); } else { curveItem = CreateMultiSelectBarItem(label, pointPairList, color); } } else if (HiLowMiddleErrorBarItem.IsHiLoMiddleErrorList(pointPairList)) { curveItem = new HiLowMiddleErrorBarItem(label, pointPairList, color, Color.Black); BarSettings.Type = BarType.Cluster; } else if (rtValue == RTPeptideValue.All) { curveItem = new MeanErrorBarItem(label, pointPairList, color, Color.Black); BarSettings.Type = BarType.Cluster; } else { curveItem = CreateLineItem(label, pointPairList, color); } if (curveItem != null) { curveItem.Tag = identityPath; var barItem = curveItem as BarItem; if (barItem != null) { barItem.Bar.Border.IsVisible = false; barItem.Bar.Fill.Brush = GetBrushForNode(docNode, color); if (!isSelected) { barItem.SortedOverlayPriority = 1; } } CurveList.Add(curveItem); if (selectedReplicateIndex != -1 && selectedReplicateIndex < pointPairList.Count) { PointPair pointPair = pointPairList[selectedReplicateIndex]; if (!pointPair.IsInvalid) { minRetentionTime = Math.Min(minRetentionTime, pointPair.Z); maxRetentionTime = Math.Max(maxRetentionTime, pointPair.Y); } } } } } // Draw a box around the currently selected replicate if (ShowSelection && minRetentionTime != double.MaxValue) { AddSelection(selectedReplicateIndex, maxRetentionTime, minRetentionTime); } // Reset the scale when the parent node changes if (_parentNode == null || !ReferenceEquals(_parentNode.Id, parentNode.Id)) { XAxis.Scale.MaxAuto = XAxis.Scale.MinAuto = true; YAxis.Scale.MaxAuto = YAxis.Scale.MinAuto = true; } _parentNode = parentNode; Legend.IsVisible = !IsMultiSelect && Settings.Default.ShowRetentionTimesLegend; GraphSummary.GraphControl.Invalidate(); AxisChange(); }
public override void UpdateGraph(bool checkData) { _dotpLabels = new GraphObjList(); SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI; var results = document.Settings.MeasuredResults; bool resultsAvailable = results != null; Clear(); if (!resultsAvailable) { Title.Text = Resources.AreaReplicateGraphPane_UpdateGraph_No_results_available; EmptyGraph(document); return; } var selectedTreeNode = GraphSummary.StateProvider.SelectedNode as SrmTreeNode; if (selectedTreeNode == null || document.FindNode(selectedTreeNode.Path) == null) { EmptyGraph(document); return; } BarSettings.Type = BarType; Title.Text = null; DisplayTypeChrom displayType; if (Equals(PaneKey, PaneKey.PRECURSORS)) { displayType = DisplayTypeChrom.precursors; } else if (Equals(PaneKey, PaneKey.PRODUCTS)) { displayType = DisplayTypeChrom.products; } else { displayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); } DocNode selectedNode = selectedTreeNode.Model; DocNode parentNode = selectedNode; IdentityPath identityPath = selectedTreeNode.Path; bool optimizationPresent = results.Chromatograms.Contains( chrom => chrom.OptimizationFunction != null); // If the selected tree node is a transition, then its siblings are displayed. if (selectedTreeNode is TransitionTreeNode) { if (displayType == DisplayTypeChrom.single) { BarSettings.Type = BarType.Cluster; } else { SrmTreeNode parentTreeNode = selectedTreeNode.SrmParent; parentNode = parentTreeNode.Model; identityPath = parentTreeNode.Path; } } // If the selected node is a peptide with one child, then show the children, // unless chromatogram display type is total else if (selectedTreeNode is PeptideTreeNode) { var children = ((PeptideDocNode)selectedNode).TransitionGroups .Where(PaneKey.IncludesTransitionGroup) .ToArray(); if (children.Length == 1 && displayType != DisplayTypeChrom.total) { selectedNode = parentNode = children[0]; identityPath = new IdentityPath(identityPath, parentNode.Id); } else { BarSettings.Type = BarType.Cluster; } } else if (!(selectedTreeNode is TransitionGroupTreeNode)) { Title.Text = Resources.AreaReplicateGraphPane_UpdateGraph_Select_a_peptide_to_see_the_peak_area_graph; CanShowPeakAreaLegend = false; CanShowDotProduct = false; return; } var parentGroupNode = parentNode as TransitionGroupDocNode; // If a precursor is going to be displayed with display type single if (parentGroupNode != null && displayType == DisplayTypeChrom.single) { // If no optimization data, then show all the transitions if (!optimizationPresent) { displayType = DisplayTypeChrom.all; } // Otherwise, do not stack the bars else { BarSettings.Type = BarType.Cluster; } } int ratioIndex = AreaGraphData.RATIO_INDEX_NONE; var standardType = IsotopeLabelType.light; var areaView = AreaGraphController.AreaView; if (areaView == AreaNormalizeToView.area_ratio_view) { ratioIndex = GraphSummary.RatioIndex; standardType = document.Settings.PeptideSettings.Modifications.RatioInternalStandardTypes[ratioIndex]; } else if (areaView == AreaNormalizeToView.area_global_standard_view) { if (document.Settings.HasGlobalStandardArea) { ratioIndex = ChromInfo.RATIO_INDEX_GLOBAL_STANDARDS; } else { areaView = AreaNormalizeToView.none; } } // Sets normalizeData to optimization, maximum_stack, maximum, total, or none AreaNormalizeToData normalizeData; if (optimizationPresent && displayType == DisplayTypeChrom.single && areaView == AreaNormalizeToView.area_percent_view) { normalizeData = AreaNormalizeToData.optimization; } else if (areaView == AreaNormalizeToView.area_maximum_view) { normalizeData = BarSettings.Type == BarType.Stack ? AreaNormalizeToData.maximum_stack : AreaNormalizeToData.maximum; } else if (BarSettings.Type == BarType.PercentStack) { normalizeData = AreaNormalizeToData.total; } else { normalizeData = AreaNormalizeToData.none; } // Calculate graph data points // IsExpectedVisible depends on ExpectedVisible ExpectedVisible = AreaExpectedValue.none; if (parentGroupNode != null && displayType != DisplayTypeChrom.total && areaView != AreaNormalizeToView.area_ratio_view && !(optimizationPresent && displayType == DisplayTypeChrom.single)) { var displayTrans = GraphChromatogram.GetDisplayTransitions(parentGroupNode, displayType).ToArray(); bool isShowingMs = displayTrans.Any(nodeTran => nodeTran.IsMs1); bool isShowingMsMs = displayTrans.Any(nodeTran => !nodeTran.IsMs1); bool isFullScanMs = document.Settings.TransitionSettings.FullScan.IsEnabledMs && isShowingMs; if (isFullScanMs) { if (!isShowingMsMs && parentGroupNode.HasIsotopeDist) { ExpectedVisible = AreaExpectedValue.isotope_dist; } } else { if (parentGroupNode.HasLibInfo) { ExpectedVisible = AreaExpectedValue.library; } } } var expectedValue = IsExpectedVisible ? ExpectedVisible : AreaExpectedValue.none; var replicateGroupOp = GraphValues.ReplicateGroupOp.FromCurrentSettings(document.Settings); var graphData = new AreaGraphData(document, parentNode, displayType, replicateGroupOp, ratioIndex, normalizeData, expectedValue, PaneKey); var aggregateOp = replicateGroupOp.AggregateOp; // Avoid stacking CVs if (aggregateOp.Cv || aggregateOp.CvDecimal) { BarSettings.Type = BarType.Cluster; } int countNodes = graphData.DocNodes.Count; if (countNodes == 0) { ExpectedVisible = AreaExpectedValue.none; } CanShowDotProduct = ExpectedVisible != AreaExpectedValue.none && areaView != AreaNormalizeToView.area_percent_view; CanShowPeakAreaLegend = countNodes != 0; InitFromData(graphData); // Add data to the graph int selectedReplicateIndex = SelectedIndex; if (IsExpectedVisible) { if (GraphSummary.ActiveLibrary) { selectedReplicateIndex = 0; } } double maxArea = -double.MaxValue; double sumArea = 0; // An array to keep track of height of all bars to determine // where each dot product annotation (if showing) should be placed var sumAreas = new double[graphData.ReplicateGroups.Count]; // If only one bar to show, then use cluster instead of stack bar type, since nothing to stack // Important for mean error bar checking below if (BarSettings.Type == BarType.Stack && countNodes == 1 && graphData.PointPairLists[0].Count == 1) { BarSettings.Type = BarType.Cluster; } int colorOffset = 0; if (parentGroupNode != null) { // We want the product ion colors to stay the same whether they are displayed: // 1. In a single pane with the precursor ions (Transitions -> All) // 2. In a separate pane of the split graph (Transitions -> All AND Transitions -> Split Graph) // 3. In a single pane by themselves (Transition -> Products) // We will use an offset in the colors array for cases 2 and 3 so that we do not reuse the precursor ion colors. var nodeDisplayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); if (displayType == DisplayTypeChrom.products && (nodeDisplayType != DisplayTypeChrom.single || (nodeDisplayType == DisplayTypeChrom.single && !optimizationPresent))) { colorOffset = GraphChromatogram.GetDisplayTransitions(parentGroupNode, DisplayTypeChrom.precursors).Count(); } } int iColor = 0, iCharge = -1; int?charge = null; int countLabelTypes = document.Settings.PeptideSettings.Modifications.CountLabelTypes; for (int i = 0; i < countNodes; i++) { var docNode = graphData.DocNodes[i]; var pointPairLists = graphData.PointPairLists[i]; int numSteps = pointPairLists.Count / 2; for (int iStep = 0; iStep < pointPairLists.Count; iStep++) { int step = iStep - numSteps; var pointPairList = pointPairLists[iStep]; Color color; var nodeGroup = docNode as TransitionGroupDocNode; if (parentNode is PeptideDocNode) { int iColorGroup = GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge); color = COLORS_GROUPS[iColorGroup % COLORS_GROUPS.Length]; } else if (displayType == DisplayTypeChrom.total) { color = COLORS_GROUPS[iColor % COLORS_GROUPS.Length]; } else if (docNode.Equals(selectedNode) && step == 0) { color = ChromGraphItem.ColorSelected; } else { color = COLORS_TRANSITION[(iColor + colorOffset) % COLORS_TRANSITION.Length]; } iColor++; // If showing ratios, do not add the standard type to the graph, // since it will always be empty, but make sure the colors still // correspond with the other graphs. if (nodeGroup != null && ratioIndex >= 0) { var labelType = nodeGroup.TransitionGroup.LabelType; if (ReferenceEquals(labelType, standardType)) { continue; } } string label = graphData.DocNodeLabels[i]; if (step != 0) { label = string.Format(Resources.AreaReplicateGraphPane_UpdateGraph_Step__0_, step); } BarItem curveItem; // Only use a MeanErrorBarItem if bars are not going to be stacked. // TODO(nicksh): AreaGraphData.NormalizeTo does not know about MeanErrorBarItem if (BarSettings.Type != BarType.Stack && BarSettings.Type != BarType.PercentStack && normalizeData == AreaNormalizeToData.none) { curveItem = new MeanErrorBarItem(label, pointPairList, color, Color.Black); } else { curveItem = new BarItem(label, pointPairList, color); } if (0 <= selectedReplicateIndex && selectedReplicateIndex < pointPairList.Count) { PointPair pointPair = pointPairList[selectedReplicateIndex]; if (!pointPair.IsInvalid) { sumArea += pointPair.Y; maxArea = Math.Max(maxArea, pointPair.Y); } } // Add area for this transition to each area entry AddAreasToSums(pointPairList, sumAreas); curveItem.Bar.Border.IsVisible = false; curveItem.Bar.Fill.Brush = new SolidBrush(color); curveItem.Tag = new IdentityPath(identityPath, docNode.Id); CurveList.Add(curveItem); } } ParentGroupNode = parentGroupNode; SumAreas = sumAreas; // Draw a box around the currently selected replicate if (ShowSelection && maxArea > -double.MaxValue) { double yValue; switch (BarSettings.Type) { case BarType.Stack: // The Math.Min(sumArea, .999) makes sure that if graph is in normalized view // height of the selection rectangle does not exceed 1, so that top of the rectangle // can be viewed when y-axis scale maximum is at 1 yValue = (areaView == AreaNormalizeToView.area_maximum_view ? Math.Min(sumArea, .999) : sumArea); break; case BarType.PercentStack: yValue = 99.99; break; default: // Scale the selection box to fit exactly the bar height yValue = (areaView == AreaNormalizeToView.area_maximum_view ? Math.Min(maxArea, .999) : maxArea); break; } GraphObjList.Add(new BoxObj(selectedReplicateIndex + .5, yValue, 0.99, yValue, Color.Black, Color.Empty) { IsClippedToChartRect = true, }); } // Reset the scale when the parent node changes bool resetAxes = (_parentNode == null || !ReferenceEquals(_parentNode.Id, parentNode.Id)); _parentNode = parentNode; UpdateAxes(resetAxes, aggregateOp, normalizeData, areaView, standardType); }
public override void UpdateGraph(bool checkData) { SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI; var results = document.Settings.MeasuredResults; bool resultsAvailable = results != null; Clear(); if (!resultsAvailable) { Title.Text = Resources.RTReplicateGraphPane_UpdateGraph_No_results_available; EmptyGraph(document); return; } var selectedTreeNode = GraphSummary.StateProvider.SelectedNode as SrmTreeNode; if (selectedTreeNode == null || document.FindNode(selectedTreeNode.Path) == null) { EmptyGraph(document); return; } Title.Text = null; DisplayTypeChrom displayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); DocNode selectedNode = selectedTreeNode.Model; DocNode parentNode = selectedNode; IdentityPath identityPath = selectedTreeNode.Path; // If the selected tree node is a transition, then its siblings are displayed. if (selectedTreeNode is TransitionTreeNode) { if (displayType != DisplayTypeChrom.single) { SrmTreeNode parentTreeNode = selectedTreeNode.SrmParent; parentNode = parentTreeNode.Model; identityPath = parentTreeNode.Path; } } // If the selected node is a peptide with one child, then show the children, // unless chromatogram display type is total else if (selectedTreeNode is PeptideTreeNode) { var children = ((DocNodeParent)selectedNode).Children; if (children.Count == 1 && displayType != DisplayTypeChrom.total) { selectedNode = parentNode = children[0]; identityPath = new IdentityPath(identityPath, parentNode.Id); } } else if (!(selectedTreeNode is TransitionGroupTreeNode)) { Title.Text = Resources.RTReplicateGraphPane_UpdateGraph_Select_a_peptide_to_see_the_retention_time_graph; CanShowRTLegend = false; return; } // If a precursor is going to be displayed with display type single if (parentNode is TransitionGroupDocNode && displayType == DisplayTypeChrom.single) { // If no optimization data, then show all the transitions if (!results.Chromatograms.Contains(chrom => chrom.OptimizationFunction != null)) { displayType = DisplayTypeChrom.all; } } var rtTransformOp = GraphSummary.StateProvider.GetRetentionTimeTransformOperation(); var rtValue = RTPeptideGraphPane.RTValue; GraphValues.ReplicateGroupOp replicateGroupOp; if (rtValue == RTPeptideValue.All) { replicateGroupOp = GraphValues.ReplicateGroupOp.FromCurrentSettings(document.Settings, GraphValues.AggregateOp.MEAN); } else { replicateGroupOp = GraphValues.ReplicateGroupOp.FromCurrentSettings(document.Settings); } var retentionTimeValue = new GraphValues.RetentionTimeTransform(rtValue, rtTransformOp, replicateGroupOp.AggregateOp); YAxis.Title.Text = retentionTimeValue.GetAxisTitle(); GraphData graphData = new RTGraphData(document, parentNode, displayType, retentionTimeValue, replicateGroupOp); CanShowRTLegend = graphData.DocNodes.Count != 0; InitFromData(graphData); int selectedReplicateIndex = SelectedIndex; double minRetentionTime = double.MaxValue; double maxRetentionTime = -double.MaxValue; int iColor = 0, iCharge = -1; int? charge = null; int countLabelTypes = document.Settings.PeptideSettings.Modifications.CountLabelTypes; int colorOffset = 0; var transitionGroupDocNode = parentNode as TransitionGroupDocNode; if (transitionGroupDocNode != null && displayType == DisplayTypeChrom.products) { // If we are only displaying product ions, we want to use an offset in the colors array // so that we do not re-use colors that would be used for any precursor ions. colorOffset = GraphChromatogram.GetDisplayTransitions(transitionGroupDocNode, DisplayTypeChrom.precursors).Count(); } for (int i = 0; i < graphData.DocNodes.Count; i++) { var docNode = graphData.DocNodes[i]; var pointPairLists = graphData.PointPairLists[i]; int numSteps = pointPairLists.Count / 2; for (int iStep = 0; iStep < pointPairLists.Count; iStep++) { int step = iStep - numSteps; var pointPairList = pointPairLists[iStep]; Color color; var nodeGroup = docNode as TransitionGroupDocNode; if (parentNode is PeptideDocNode) { // Resharper code inspection v9.0 on TC gets this one wrong // ReSharper disable ExpressionIsAlwaysNull int iColorGroup = GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge); // ReSharper restore ExpressionIsAlwaysNull color = COLORS_GROUPS[iColorGroup % COLORS_GROUPS.Length]; } else if (displayType == DisplayTypeChrom.total) { color = COLORS_GROUPS[iColor % COLORS_GROUPS.Length]; } else if (docNode.Equals(selectedNode) && step == 0) { color = ChromGraphItem.ColorSelected; } else { color = COLORS_TRANSITION[(iColor + colorOffset) % COLORS_TRANSITION.Length]; } iColor++; string label = graphData.DocNodeLabels[i]; if (step != 0) { label = string.Format(Resources.RTReplicateGraphPane_UpdateGraph_Step__0__, step); } BarItem curveItem; if (HiLowMiddleErrorBarItem.IsHiLoMiddleErrorList(pointPairList)) { curveItem = new HiLowMiddleErrorBarItem(label, pointPairList, color, Color.Black); } else { curveItem = new MeanErrorBarItem(label, pointPairList, color, Color.Black); } if (selectedReplicateIndex != -1 && selectedReplicateIndex < pointPairList.Count) { PointPair pointPair = pointPairList[selectedReplicateIndex]; if (!pointPair.IsInvalid) { minRetentionTime = Math.Min(minRetentionTime, pointPair.Z); maxRetentionTime = Math.Max(maxRetentionTime, pointPair.Y); } } curveItem.Bar.Border.IsVisible = false; curveItem.Bar.Fill.Brush = new SolidBrush(color); curveItem.Tag = new IdentityPath(identityPath, docNode.Id); CurveList.Add(curveItem); } } // Draw a box around the currently selected replicate if (ShowSelection && minRetentionTime != double.MaxValue) { GraphObjList.Add(new BoxObj(selectedReplicateIndex + .5, maxRetentionTime, 1, maxRetentionTime - minRetentionTime, Color.Black, Color.Empty) { IsClippedToChartRect = true, }); } // Reset the scale when the parent node changes if (_parentNode == null || !ReferenceEquals(_parentNode.Id, parentNode.Id)) { XAxis.Scale.MaxAuto = XAxis.Scale.MinAuto = true; YAxis.Scale.MaxAuto = YAxis.Scale.MinAuto = true; } _parentNode = parentNode; Legend.IsVisible = Settings.Default.ShowRetentionTimesLegend; AxisChange(); }
private void ValidateTimeRange(GraphChromatogram graphChromatogram, double[] msMsRTs, double range, double gradientLength) { var statMsMsRTs = new Statistics(msMsRTs); double minRT = double.MaxValue, maxRT = double.MinValue; foreach (var curve in graphChromatogram.CurveList) { minRT = Math.Min(minRT, curve.Points[0].X); maxRT = Math.Max(maxRT, curve.Points[curve.NPts - 1].X); } if (statMsMsRTs.Min() < range/2) { Assert.AreEqual(minRT, 0.0, 1); minRT = statMsMsRTs.Min() - range/2; } if (statMsMsRTs.Max() > gradientLength - range/2) { Assert.AreEqual(maxRT, gradientLength, 1); maxRT = statMsMsRTs.Max() + range/2; } double msMsRtsRange = statMsMsRTs.Range(); double rangeActual = maxRT - minRT - msMsRtsRange; if (Math.Abs(range - rangeActual) > 0.2) { // Some cases with very wide range of scans may not have enough gradient // to accomodate the desired range. string message = string.Format("Expected: {0}, Actual: {1}, RangeIds: {2}, Min: {3}, Max: {4}, MinIds: {5}, MaxIds: {6}", range, rangeActual, msMsRtsRange, minRT, maxRT, statMsMsRTs.Min(), statMsMsRTs.Max()); Assert.IsTrue(msMsRtsRange > 10, message); Assert.IsTrue(rangeActual > range - 1, message); } }
protected static int GetColorIndex(TransitionGroupDocNode nodeGroup, int countLabelTypes, ref Adduct charge, ref int iCharge) { return(GraphChromatogram.GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge)); }
public override void UpdateGraph(bool selectionChanged) { CurveList.Clear(); GraphObjList.Clear(); SrmDocument document = GraphSummary.DocumentUIContainer.DocumentUI; var selectedTreeNode = GraphSummary.StateProvider.SelectedNode as SrmTreeNode; if (selectedTreeNode == null || document.FindNode(selectedTreeNode.Path) == null) { Title.Text = Helpers.PeptideToMoleculeTextMapper.Translate(Resources.MassErrorReplicateGraphPane_UpdateGraph_Select_a_peptide_to_see_the_mass_error_graph, document.DocumentType); EmptyGraph(document); return; } if (!document.Settings.HasResults) { Title.Text = Resources.AreaReplicateGraphPane_UpdateGraph_No_results_available; EmptyGraph(document); return; } DisplayTypeChrom displayType; if (Equals(PaneKey, PaneKey.PRECURSORS)) { displayType = DisplayTypeChrom.precursors; } else if (Equals(PaneKey, PaneKey.PRODUCTS)) { displayType = DisplayTypeChrom.products; } else { displayType = GraphChromatogram.GetDisplayType(document, selectedTreeNode); } Title.Text = null; var aggregateOp = GraphValues.AggregateOp.FromCurrentSettings(); YAxis.Title.Text = aggregateOp.Cv ? aggregateOp.AnnotateTitle(Resources.MassErrorReplicateGraphPane_UpdateGraph_Mass_Error_No_Ppm) : Resources.MassErrorReplicateGraphPane_UpdateGraph_Mass_Error; DocNode selectedNode = selectedTreeNode.Model; DocNode parentNode = selectedNode; IdentityPath identityPath = selectedTreeNode.Path; // If the selected tree node is a transition, then its siblings are displayed. if (selectedTreeNode is TransitionTreeNode) { if (displayType != DisplayTypeChrom.single) { SrmTreeNode parentTreeNode = selectedTreeNode.SrmParent; parentNode = parentTreeNode.Model; identityPath = parentTreeNode.Path; } } // If the selected node is a peptide with one child, then show the children, // unless chromatogram display type is total else if (selectedTreeNode is PeptideTreeNode) { var children = ((PeptideDocNode)selectedNode).TransitionGroups .Where(PaneKey.IncludesTransitionGroup) .ToArray(); if (children.Length == 1 && displayType != DisplayTypeChrom.total) { selectedNode = parentNode = children[0]; identityPath = new IdentityPath(identityPath, parentNode.Id); } } else if (!(selectedTreeNode is TransitionGroupTreeNode)) { Title.Text = Helpers.PeptideToMoleculeTextMapper.Translate(Resources.MassErrorReplicateGraphPane_UpdateGraph_Select_a_peptide_to_see_the_mass_error_graph, document.DocumentType); EmptyGraph(document); CanShowMassErrorLegend = false; return; } // If a precursor is going to be displayed with display type single if (parentNode is TransitionGroupDocNode && displayType == DisplayTypeChrom.single) { // If no optimization data, then show all the transitions displayType = DisplayTypeChrom.all; } var replicateGroupOp = ReplicateGroupOp.FromCurrentSettings(document.Settings); GraphData graphData = new MassErrorGraphData(document, identityPath, displayType, replicateGroupOp, PaneKey); CanShowMassErrorLegend = graphData.DocNodes.Count != 0; InitFromData(graphData); int selectedReplicateIndex = SelectedIndex; double minRetentionTime = double.MaxValue; double maxRetentionTime = double.MinValue; int iColor = 0, iCharge = -1; var charge = Adduct.EMPTY; int countLabelTypes = document.Settings.PeptideSettings.Modifications.CountLabelTypes; int colorOffset = 0; var transitionGroupDocNode = parentNode as TransitionGroupDocNode; if (transitionGroupDocNode != null && displayType == DisplayTypeChrom.products) { // If we are only displaying product ions, we want to use an offset in the colors array // so that we do not re-use colors that would be used for any precursor ions. colorOffset = GraphChromatogram.GetDisplayTransitions(transitionGroupDocNode, DisplayTypeChrom.precursors).Count(); } for (int i = 0; i < graphData.DocNodes.Count; i++) { var docNode = graphData.DocNodes[i]; var pointPairLists = graphData.PointPairLists[i]; int numSteps = pointPairLists.Count / 2; for (int iStep = 0; iStep < pointPairLists.Count; iStep++) { int step = iStep - numSteps; var pointPairList = pointPairLists[iStep]; Color color; // ReSharper disable ExpressionIsAlwaysNull var nodeGroup = docNode as TransitionGroupDocNode; if (parentNode is PeptideDocNode) { int iColorGroup = GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge); color = COLORS_GROUPS[iColorGroup % COLORS_GROUPS.Count]; } else if (displayType == DisplayTypeChrom.total) { color = COLORS_GROUPS[iColor % COLORS_GROUPS.Count]; } else if (docNode.Equals(selectedNode) && step == 0) { color = ChromGraphItem.ColorSelected; } else { color = COLORS_TRANSITION[(iColor + colorOffset) % COLORS_TRANSITION.Count]; } // ReSharper restore ExpressionIsAlwaysNull iColor++; string label = graphData.DocNodeLabels[i]; if (step != 0) { label = string.Format(Resources.RTReplicateGraphPane_UpdateGraph_Step__0__, step); } BarItem curveItem = new MeanErrorBarItem(label, pointPairList, color, Color.Black); if (selectedReplicateIndex != -1 && selectedReplicateIndex < pointPairList.Count) { PointPair pointPair = pointPairList[selectedReplicateIndex]; if (!pointPair.IsInvalid) { minRetentionTime = Math.Min(minRetentionTime, pointPair.Y); maxRetentionTime = Math.Max(maxRetentionTime, pointPair.Y); } } curveItem.Bar.Border.IsVisible = false; curveItem.Bar.Fill.Brush = new SolidBrush(color); curveItem.Tag = new IdentityPath(identityPath, docNode.Id); CurveList.Add(curveItem); } } // Draw a box around the currently selected replicate if (ShowSelection && minRetentionTime != double.MaxValue) { maxRetentionTime = Math.Max(maxRetentionTime, 0); minRetentionTime = Math.Min(minRetentionTime, 0); GraphObjList.Add(new BoxObj(selectedReplicateIndex + .5, maxRetentionTime, 1, maxRetentionTime - minRetentionTime, Color.Black, Color.Empty) { IsClippedToChartRect = true, }); } XAxis.Scale.MinAuto = XAxis.Scale.MaxAuto = selectionChanged; YAxis.Scale.MinAuto = YAxis.Scale.MaxAuto = true; if (Settings.Default.MinMassError != 0) { YAxis.Scale.Min = Settings.Default.MinMassError; } if (Settings.Default.MaxMassError != 0) { YAxis.Scale.Max = Settings.Default.MaxMassError; } Legend.IsVisible = Settings.Default.ShowMassErrorLegend; AxisChange(); }