private void SetSpectraUI(MsDataSpectrum[] spectra) { _msDataFileScanHelper.MsDataSpectra = spectra; _heatMapData = null; if (_msDataFileScanHelper.MsDataSpectra == null) { return; } // Find max values. _maxMz = 0; _maxIntensity = 0; GetMaxMzIntensity(out _maxMz, out _maxIntensity); _maxDriftTime = 0; foreach (var spectrum in spectra) { _maxDriftTime = Math.Max(_maxDriftTime, spectrum.DriftTimeMsec ?? 0); } if (_zoomXAxis) { _zoomXAxis = false; ZoomXAxis(); } if (_zoomYAxis) { _zoomYAxis = false; ZoomYAxis(); } CreateGraph(); UpdateUI(); }
private void SetSpectraUI(MsDataSpectrum[] spectra) { _msDataFileScanHelper.MsDataSpectra = spectra; _heatMapData = null; if (_msDataFileScanHelper.MsDataSpectra == null) { return; } // Find max values. _maxMz = 0; _maxIntensity = 0; GetMaxMzIntensity(out _maxMz, out _maxIntensity); GetMaxMobility(out _maxIonMobility); if (_zoomXAxis) { _zoomXAxis = false; ZoomXAxis(); } if (_zoomYAxis) { _zoomYAxis = false; ZoomYAxis(); } CreateGraph(); UpdateUI(); }
private void ShowHeatmap(double scanTime, int msLevel) { if (ionMobilityBinsByMsLevelAndScanTime.Count <= msLevel) { throw new ArgumentOutOfRangeException("msLevel", "no ion mobility bins for ms level " + msLevel); } var ionMobilityBinsByScanTime = ionMobilityBinsByMsLevelAndScanTime[msLevel]; if (!ionMobilityBinsByScanTime.Contains(scanTime)) { throw new ArgumentOutOfRangeException("scanTime", "no ion mobility bins for scan time " + scanTime); } var heatmapGraphPane = heatmapGraphPaneByMsLevel[msLevel]; heatmapGraphPane.CurveList.Clear(); heatmapGraphPane.GraphObjList.Add(new TextObj("Loading...", 0.5, 0.5, CoordType.ChartFraction) { FontSpec = new FontSpec { Border = new Border { IsVisible = false }, IsBold = true, Size = 24 } }); msGraphControl.Refresh(); var mobilityData = ionMobilityBinsByScanTime[scanTime]; var heatmapPointsTuple = heatmapPointsCache.GetOrAdd(mobilityData, o => o.Get3dSpectrum(), mobilityData); var bounds = heatmapPointsTuple.Item2; var g = msGraphControl.CreateGraphics(); var heatmapData = new HeatMapData(heatmapPointsTuple.Item1); heatmapGraphPane.GraphObjList.Clear(); // remove "Loading..." heatmapGraphPane.SetPoints(heatmapData, bounds.MinY, bounds.MaxY); string isolationMzTitle = String.Empty; if (msLevel + 1 == 2) { isolationMzTitle = " for isolation m/z " + String.Join(", ", isolationMzByScanTime[scanTime].Distinct()); } heatmapGraphPane.Title.Text = String.Format("Ion Mobility Heatmap (ms{0} @ {1:F4} {3}{2})", msLevel + 1, scanTime, isolationMzTitle, Properties.Settings.Default.TimeInMinutes ? "min." : "sec."); setScale(heatmapGraphPane.XAxis.Scale, bounds.MinX, bounds.MaxX); setScale(heatmapGraphPane.YAxis.Scale, bounds.MinY, bounds.MaxY); heatmapGraphPane.AxisChange(g); heatmapGraphPane.SetScale(g); msGraphControl.Refresh(); }
//function for printing out HeatMap structure data public static void printInfo(HeatMapData data) { double total_time = 0; Console.WriteLine("\nts: " + data.ts); Console.WriteLine("player_name: " + data.player_name); Console.WriteLine("gridType: " + data.gridType); foreach (var item in data.heatmap) { total_time += item.Value; } foreach (var item in data.heatmap) { Console.WriteLine("index: " + item.Key + " time % : " + (item.Value / total_time) * 100); } }
public float GetGrayColorRatio(int indexInitialDesired, int indexFinalDesired, int axisDivisionFactr, string requirementName) { float grayColorRatio; HeatMapPoint correspondingHeatMapPoint = HeatMapData.Find( delegate(HeatMapPoint heatMapPoint){ return((heatMapPoint.indexX == indexInitialDesired) && (heatMapPoint.indexY == indexFinalDesired)); }); grayColorRatio = correspondingHeatMapPoint.objectiveFunctionValues[requirementName]; grayColorRatio -= minimumValueOfObjectiveFunctions[requirementName]; if ((maximumValueOfObjectiveFunctions[requirementName] - minimumValueOfObjectiveFunctions[requirementName]) != 0) { grayColorRatio /= (maximumValueOfObjectiveFunctions[requirementName] - minimumValueOfObjectiveFunctions[requirementName]); } else { grayColorRatio = 0; } return(grayColorRatio); }
/// <summary> /// Registers Properties for Heat Map /// </summary> /// <param name="shape">Map Shape</param> private void SetAdditionalData(MapShape shape) { ExtendedData data = shape.ExtendedData; if (data != null) { if (!data.PropertySet.ContainsKey(COUNTRY_PERFORMANCE_FIELD)) { data.PropertySet.RegisterProperty(COUNTRY_PERFORMANCE_FIELD, "CountryPerformance", typeof(int), 0); } if (!data.PropertySet.ContainsKey(COUNTRY_YTD_FIELD)) { data.PropertySet.RegisterProperty(COUNTRY_YTD_FIELD, "CountryYTD", typeof(Decimal), Convert.ToDecimal(0)); } if (!data.PropertySet.ContainsKey(BENCHMARK_YTD_FIELD)) { data.PropertySet.RegisterProperty(BENCHMARK_YTD_FIELD, "BenchmarkYTD", typeof(Decimal), Convert.ToDecimal(0)); } if (heatMapInfo != null) { string countryID = (string)shape.ExtendedData.GetValue("ISO_2DIGIT"); HeatMapData countryRecord = heatMapInfo.Where(r => r.CountryID == countryID).FirstOrDefault(); if (countryRecord != null) { shape.ExtendedData.SetValue(COUNTRY_PERFORMANCE_FIELD, (int)(countryRecord.CountryPerformance)); shape.ExtendedData.SetValue(COUNTRY_YTD_FIELD, countryRecord.CountryYTD); shape.ExtendedData.SetValue(BENCHMARK_YTD_FIELD, countryRecord.BenchmarkYTD); AddColorizerToInformationLayer(shape, countryRecord); } else { shape.ExtendedData.SetValue(COUNTRY_PERFORMANCE_FIELD, null); shape.ExtendedData.SetValue(COUNTRY_YTD_FIELD, null); shape.ExtendedData.SetValue(BENCHMARK_YTD_FIELD, null); AddTransparentColorizerToInformationLayer(shape); } } } }
/// <summary> /// Adding Colour to Each Shape /// </summary> /// <param name="shape">Shape</param> /// <param name="countryRecord">Country record of type heat map data</param> private void AddColorizerToInformationLayer(MapShape shape, HeatMapData countryRecord) { if ((int)(countryRecord.CountryPerformance) == 3) { shape.Fill = new SolidColorBrush(Colors.Green); } else if ((int)(countryRecord.CountryPerformance) == 1) { shape.Fill = new SolidColorBrush(Colors.Red); } else if ((int)(countryRecord.CountryPerformance) == 2) { shape.Fill = new SolidColorBrush(Colors.Gray); } else if ((int)(countryRecord.CountryPerformance) == 0) { shape.Fill = new SolidColorBrush(Colors.White); } }
//aggregatorFunction used in TimeWindow based aggregation private static HeatMapData aggregatorFunction(HeatMapData seed, TimeInCell curr, IList <TimeInCell> expList, long count) { HeatMapData new_seed = new HeatMapData { ts = curr.ts, player_name = curr.player_name, gridType = curr.gridType, heatmap = seed.heatmap }; foreach (var item in expList) { if (item.time_in_cell != -999) { if (new_seed.heatmap.ContainsKey(item.prev_index)) { new_seed.heatmap[item.prev_index] -= item.time_in_cell; if (new_seed.heatmap[item.prev_index] <= 0) { new_seed.heatmap.Remove(item.prev_index); } } else { Console.WriteLine("HeatMapProcessor: Attempt to access non-existent key"); } } } if (curr.time_in_cell != -999) { if (new_seed.heatmap.ContainsKey(curr.prev_index)) { new_seed.heatmap[curr.prev_index] += curr.time_in_cell; } else { new_seed.heatmap.Add(curr.prev_index, curr.time_in_cell); } } return(new_seed); }
private void SetSpectraUI(MsDataSpectrum[] spectra) { _msDataFileScanHelper.MsDataSpectra = spectra; _heatMapData = null; if (_msDataFileScanHelper.MsDataSpectra == null) { return; } foreach (var spectrum in spectra) { if (spectrum.IonMobilities != null) { ArrayUtil.Sort(spectrum.Mzs, spectrum.Intensities, spectrum.IonMobilities); } } // Find max values. _maxMz = 0; _maxIntensity = 0; GetMaxMzIntensity(out _maxMz, out _maxIntensity); GetMaxMobility(out _maxIonMobility); if (_zoomXAxis) { _zoomXAxis = false; ZoomXAxis(); } if (_zoomYAxis) { _zoomYAxis = false; ZoomYAxis(); } CreateGraph(); UpdateUI(); }
public GraphData(SrmDocument document, GraphData dataPrevious, int resultIndex, bool bestResult, PointsTypeMassError pointsType) { _document = document; _resultIndex = resultIndex; _replicateDisplay = ShowReplicate; int[,] counts2D = EMPTY_COUNTS; _displayType = MassErrorGraphController.HistogramDisplayType; _binSizePpm = Settings.Default.MassErorrHistogramBinSize; _transition = MassErrorGraphController.HistogramTransiton; _xAxis = MassErrorGraphController.Histogram2DXAxis; _pointsType = pointsType; if (_pointsType == PointsTypeMassError.targets_1FDR && !document.Settings.PeptideSettings.Integration.PeakScoringModel.IsTrained) { _pointsType = PointsTypeMassError.targets; } bool decoys = pointsType == PointsTypeMassError.decoys; bool precursors = _displayType == DisplayTypeMassError.precursors; while (ReferenceEquals(counts2D, EMPTY_COUNTS)) { if (_maxMass != double.MinValue) { counts2D = new int[xAxisBins, (int)((_maxMass - _minMass) / _binSizePpm + 1)]; } foreach (var nodePep in document.Molecules) { if (decoys != nodePep.IsDecoy) { continue; } var replicateIndex = bestResult && nodePep.BestResult != -1 ? nodePep.BestResult : resultIndex; foreach (var nodeGroup in nodePep.TransitionGroups) { foreach (var nodeTran in nodeGroup.Transitions) { if (precursors != nodeTran.IsMs1) { continue; } var mz = nodeTran.Mz.Value; if (replicateIndex >= 0) { AddChromInfo(nodeGroup, nodeTran, replicateIndex, mz, counts2D); } else { for (int i = 0; i < nodeTran.Results.Count; i++) { AddChromInfo(nodeGroup, nodeTran, i, mz, counts2D); } } } } } // No values. Leave _maxCount == 0 if (_maxMass == double.MinValue) { return; } } var points = new List <Point3D>(); for (int x = 0; x < counts2D.GetLength(0); x++) { for (int y = 0; y < counts2D.GetLength(1); y++) { int count = counts2D[x, y]; if (count > 0) { double binSizeX = (_maxX - _minX) / xAxisBins; double xPoint = x * binSizeX + _minX + binSizeX / 2; double yPoint = y * _binSizePpm + _minMass + _binSizePpm / 2; points.Add(new Point3D(xPoint, yPoint, count)); } _maxCount = Math.Max(_maxCount, count); } } _heatMapData = new HeatMapData(points); }
private void ShowHeatmap(double scanTime, int msLevel) { if (ionMobilityBinsByMsLevelAndScanTime.Count <= msLevel) { throw new ArgumentOutOfRangeException("msLevel", "no ion mobility bins for ms level " + msLevel); } var ionMobilityBinsByScanTime = ionMobilityBinsByMsLevelAndScanTime[msLevel]; if (!ionMobilityBinsByScanTime.Contains(scanTime)) { throw new ArgumentOutOfRangeException("scanTime", "no ion mobility bins for scan time " + scanTime); } var ionMobilityBins = ionMobilityBinsByScanTime[scanTime]; var heatmapPoints = new List <Point3D>(ionMobilityBins.Count); var heatmapGraphPane = heatmapGraphPaneByMsLevel[msLevel]; heatmapGraphPane.CurveList.Clear(); heatmapGraphPane.GraphObjList.Add(new TextObj("Loading...", 0.5, 0.5, CoordType.ChartFraction) { FontSpec = new FontSpec { Border = new Border { IsVisible = false }, IsBold = true, Size = 24 } }); msGraphControl.Refresh(); var bounds = heatmapBoundsByMsLevel[msLevel]; foreach (var bin in ionMobilityBins) { var spectrum = source.GetMassSpectrum(bin.BinIndex); var points = spectrum.Points; for (int j = 0; j < points.Count; ++j) { double mz = points[j].X; double intensity = points[j].Y; bounds.MinX = Math.Min(bounds.MinX, mz); bounds.MinY = Math.Min(bounds.MinY, bin.IonMobility); bounds.MaxX = Math.Max(bounds.MaxX, mz); bounds.MaxY = Math.Max(bounds.MaxY, bin.IonMobility); heatmapPoints.Add(new Point3D(mz, bin.IonMobility, intensity)); } } var g = msGraphControl.CreateGraphics(); var heatmapData = new HeatMapData(heatmapPoints); heatmapGraphPane.GraphObjList.Clear(); // remove "Loading..." heatmapGraphPane.SetPoints(heatmapData, bounds.MinY, bounds.MaxY); heatmapGraphPane.Title.Text = String.Format("Ion Mobility Heatmap (ms{0} @ {1:F4} min.)", msLevel + 1, scanTime); setScale(heatmapGraphPane.XAxis.Scale, bounds.MinX, bounds.MaxX); setScale(heatmapGraphPane.YAxis.Scale, bounds.MinY, bounds.MaxY); heatmapGraphPane.AxisChange(g); heatmapGraphPane.SetScale(g); msGraphControl.Refresh(); }
private void ShowHeatmaps() { var dgv = source.SpectrumListForm.GridView; var scanTimeColumn = dgv.Columns["ScanTime"]; var msLevelColumn = dgv.Columns["MsLevel"]; var heatmapPointsByMsLevel = new List <List <Point3D> >(dgv.RowCount); var msLevels = new Set <int>(); for (int i = 0; i < dgv.RowCount; ++i) { msLevels.Add((int)dgv[msLevelColumn.Index, i].Value - 1); } while (heatmapPointsByMsLevel.Count <= msLevels.Max) { heatmapPointsByMsLevel.Add(new List <Point3D>()); } var peakPicker = new pwiz.CLI.analysis.SpectrumList_PeakPicker(source.Source.MSDataFile.run.spectrumList, new pwiz.CLI.analysis.CwtPeakDetector(1, 0.5), true, new int[] { 1 }); for (int i = 0; i < dgv.RowCount; ++i) { int msLevel = (int)dgv[msLevelColumn.Index, i].Value - 1; var heatmapGraphPane = heatmapGraphPaneByMsLevel[msLevel]; var heatmapPoints = heatmapPointsByMsLevel[msLevel]; if (i == 0 || i + 1 == dgv.RowCount || ((i + 1) % 1000) == 0) { heatmapGraphPane.CurveList.Clear(); heatmapGraphPane.GraphObjList.Add(new TextObj(String.Format("Loading {0}/{1}", i + 1, dgv.RowCount), 0.5, 0.5, CoordType.ChartFraction) { FontSpec = new FontSpec { Border = new Border { IsVisible = false }, IsBold = true, Size = 24 } }); msGraphControl.Refresh(); } Application.DoEvents(); var bounds = heatmapBoundsByMsLevel[msLevel]; var spectrum = source.GetMassSpectrum(source.Source.Spectra[i].Index, peakPicker); double scanTime = (double)dgv[scanTimeColumn.Index, i].Value; var points = spectrum.Points; for (int j = 0; j < points.Count; ++j) { double intensity = points[j].Y; if (intensity == 0) { continue; } double mz = points[j].X; bounds.MinX = Math.Min(bounds.MinX, mz); bounds.MinY = Math.Min(bounds.MinY, scanTime); bounds.MaxX = Math.Max(bounds.MaxX, mz); bounds.MaxY = Math.Max(bounds.MaxY, scanTime); heatmapPoints.Add(new Point3D(mz, scanTime, intensity)); } } var g = msGraphControl.CreateGraphics(); foreach (int msLevel in msLevels) { var bounds = heatmapBoundsByMsLevel[msLevel]; var heatmapData = new HeatMapData(heatmapPointsByMsLevel[msLevel]); var heatmapGraphPane = heatmapGraphPaneByMsLevel[msLevel]; heatmapGraphPane.GraphObjList.Clear(); // remove "Loading..." heatmapGraphPane.SetPoints(heatmapData, bounds.MinY, bounds.MaxY); heatmapGraphPane.Title.Text = String.Format("Time to m/z Heatmap (ms{0})", msLevel + 1); setScale(heatmapGraphPane.XAxis.Scale, bounds.MinX, bounds.MaxX); setScale(heatmapGraphPane.YAxis.Scale, bounds.MinY, bounds.MaxY); heatmapGraphPane.AxisChange(g); heatmapGraphPane.SetScale(g); msGraphControl.Refresh(); } }
public override void UpdateGraph(bool selectionChanged) { if (!GraphSummary.DocumentUIContainer.DocumentUI.Settings.HasResults) { _areaCVGraphData = null; return; } var settings = new AreaCVGraphData.AreaCVGraphSettings(GraphSummary.Type); _document = GraphSummary.DocumentUIContainer.DocumentUI; _percentage = !Settings.Default.AreaCVShowDecimals; _decimals = _percentage ? 1 : 3; CurveList.Clear(); var gotData = _cache.TryGet(_document, settings, DataCallback, out _areaCVGraphData); if (!gotData) { Title.Text = Resources.AreaCVHistogram2DGraphPane_UpdateGraph_Calculating____; return; } if (!_areaCVGraphData.IsValid) { Title.Text = Resources.AreaCVHistogram2DGraphPane_Draw_Not_enough_data; return; } var factor = AreaGraphController.GetAreaCVFactorToDecimal(); Title.Text = string.Empty; YAxis.Title.Text = Resources.AreaCVHistogram2DGraphPane_UpdateGraph_CV + (_percentage ? @" (%)" : string.Empty); XAxis.Title.Text = Resources.AreaCvHistogram2DGraphPane_UpdateGraph_Log10_Mean_Area; XAxis.Scale.MinAuto = XAxis.Scale.MinAuto = XAxis.Scale.MaxAuto = YAxis.Scale.MaxAuto = false; XAxis.Scale.Min = Math.Max(0, double.IsNaN(Settings.Default.AreaCVMinLog10Area) ? _areaCVGraphData.MinMeanArea : Settings.Default.AreaCVMinLog10Area); XAxis.Scale.Max = double.IsNaN(Settings.Default.AreaCVMaxLog10Area) ? _areaCVGraphData.MaxMeanArea : Settings.Default.AreaCVMaxLog10Area; YAxis.Scale.Min = 0.0; YAxis.Scale.Max = double.IsNaN(Settings.Default.AreaCVMaxCV) ? _areaCVGraphData.MaxCV * factor : Settings.Default.AreaCVMaxCV; AxisChange(); var points = _areaCVGraphData.Data .Select(d => new HeatMapData.TaggedPoint3D(new Point3D(d.MeanArea, d.CV * factor, d.Frequency), d)) .ToList(); Items = points.Count; // Because heatmaps can't be trusted to have a consistent number of points on all monitors var heatMapData = new HeatMapData(points); HeatMapGraphPane.GraphHeatMap(this, heatMapData, 17, 2, (float)(_areaCVGraphData.MinCV * factor), (float)(_areaCVGraphData.MaxCV * factor), Settings.Default.AreaCVLogScale, 0); var unit = _percentage ? @"%" : string.Empty; if (Settings.Default.AreaCVShowMedianCV) { string text = string.Format(Resources.AreaCVHistogram2DGraphPane_UpdateGraph_Median___0_, HistogramHelper.FormatDouble(_areaCVGraphData.MedianCV * factor, _decimals) + unit); _lineItems[0] = AddLineItem(text, XAxis.Scale.Min, XAxis.Scale.Max, _areaCVGraphData.MedianCV * factor, _areaCVGraphData.MedianCV * factor, Color.Blue); CurveList.Insert(0, _lineItems[0]); } if (Settings.Default.AreaCVShowCVCutoff) { string text = string.Format(Resources.AreaCVHistogramGraphPane_UpdateGraph_Below__0____1_, Settings.Default.AreaCVCVCutoff + unit, HistogramHelper.FormatDouble(_areaCVGraphData.BelowCVCutoff * factor, _decimals) + unit); _lineItems[1] = AddLineItem(text, XAxis.Scale.Min, XAxis.Scale.Max, Settings.Default.AreaCVCVCutoff, Settings.Default.AreaCVCVCutoff, Color.Red); CurveList.Insert(0, _lineItems[1]); } }
public void AddPoint(HeatMapPoint heatMapPoint) { HeatMapData.Add(heatMapPoint); }
private void ShowHeatmap(double scanTime, int msLevel) { if (ionMobilityBinsByMsLevelAndScanTime.Count <= msLevel) { throw new ArgumentOutOfRangeException("msLevel", "no ion mobility bins for ms level " + msLevel); } var ionMobilityBinsByScanTime = ionMobilityBinsByMsLevelAndScanTime[msLevel]; if (!ionMobilityBinsByScanTime.Contains(scanTime)) { throw new ArgumentOutOfRangeException("scanTime", "no ion mobility bins for scan time " + scanTime); } var ionMobilityBins = ionMobilityBinsByScanTime[scanTime]; var heatmapPoints = new List <Point3D>(ionMobilityBins.Count); var heatmapGraphPane = heatmapGraphPaneByMsLevel[msLevel]; heatmapGraphPane.CurveList.Clear(); heatmapGraphPane.GraphObjList.Add(new TextObj("Loading...", 0.5, 0.5, CoordType.ChartFraction) { FontSpec = new FontSpec { Border = new Border { IsVisible = false }, IsBold = true, Size = 24 } }); msGraphControl.Refresh(); var mainSpectrumList = source.Source.MSDataFile.run.spectrumList; var bounds = heatmapBoundsByMsLevel[msLevel]; int lastBinIndex = -1; foreach (var bin in ionMobilityBins) { // skip bins where the spectrum is the same as the last bin (that spectrum's points were added from its mobility array) if (bin.BinIndex == lastBinIndex) { continue; } lastBinIndex = bin.BinIndex; var s = mainSpectrumList.spectrum(bin.BinIndex, true); var mzArray = s.getMZArray().data; var intensityArray = s.getIntensityArray().data; var mobilityBDA = s.getArrayByCVID(pwiz.CLI.cv.CVID.MS_mean_drift_time_array); if (mobilityBDA == null) { mobilityBDA = s.getArrayByCVID(pwiz.CLI.cv.CVID.MS_mean_inverse_reduced_ion_mobility_array); } if (mobilityBDA != null) { var mobilityArray = mobilityBDA.data; for (int j = 0, end = mzArray.Count; j < end; ++j) { double mz = mzArray[j]; double intensity = intensityArray[j]; double mobility = mobilityArray[j]; bounds.MinX = Math.Min(bounds.MinX, mz); bounds.MinY = Math.Min(bounds.MinY, mobility); bounds.MaxX = Math.Max(bounds.MaxX, mz); bounds.MaxY = Math.Max(bounds.MaxY, mobility); heatmapPoints.Add(new Point3D(mz, mobility, intensity)); } } else { for (int j = 0, end = mzArray.Count; j < end; ++j) { double mz = mzArray[j]; double intensity = intensityArray[j]; bounds.MinX = Math.Min(bounds.MinX, mz); bounds.MinY = Math.Min(bounds.MinY, bin.IonMobility); bounds.MaxX = Math.Max(bounds.MaxX, mz); bounds.MaxY = Math.Max(bounds.MaxY, bin.IonMobility); heatmapPoints.Add(new Point3D(mz, bin.IonMobility, intensity)); } } } var g = msGraphControl.CreateGraphics(); var heatmapData = new HeatMapData(heatmapPoints); heatmapGraphPane.GraphObjList.Clear(); // remove "Loading..." heatmapGraphPane.SetPoints(heatmapData, bounds.MinY, bounds.MaxY); heatmapGraphPane.Title.Text = String.Format("Ion Mobility Heatmap (ms{0} @ {1:F4} min.)", msLevel + 1, scanTime); setScale(heatmapGraphPane.XAxis.Scale, bounds.MinX, bounds.MaxX); setScale(heatmapGraphPane.YAxis.Scale, bounds.MinY, bounds.MaxY); heatmapGraphPane.AxisChange(g); heatmapGraphPane.SetScale(g); msGraphControl.Refresh(); }
/// <summary> /// Create an ion mobility heat map graph. /// </summary> private void CreateIonMobilityHeatmap() { GraphPane.YAxis.Title.Text = IonMobilityFilter.IonMobilityUnitsL10NString(_msDataFileScanHelper.IonMobilityUnits); graphControl.IsEnableVZoom = graphControl.IsEnableVPan = true; if (_heatMapData == null) { var points = new List <Point3D>(5000); foreach (var scan in _msDataFileScanHelper.MsDataSpectra) { if (!scan.IonMobility.HasValue && scan.IonMobilities == null) { continue; } for (int j = 0; j < scan.Mzs.Length; j++) { double mobilityValue = scan.IonMobilities != null ? scan.IonMobilities[j] : scan.IonMobility.Mobility.Value; points.Add(new Point3D(scan.Mzs[j], mobilityValue, scan.Intensities[j])); } } _heatMapData = new HeatMapData(points); } double minDrift; double maxDrift; _msDataFileScanHelper.GetIonMobilityRange(out minDrift, out maxDrift, _msDataFileScanHelper.Source); // There may be a different drift time filter for products in Waters if (minDrift > 0 && maxDrift < double.MaxValue) { // Add gray shaded box behind heat points. var driftTimeBox = new BoxObj( 0.0, maxDrift, 1.0, maxDrift - minDrift, Color.Transparent, Color.FromArgb(50, Color.Gray)) { Location = { CoordinateFrame = CoordType.XChartFractionYScale }, ZOrder = ZOrder.F_BehindGrid, IsClippedToChartRect = true, }; GraphPane.GraphObjList.Add(driftTimeBox); // Add outline in front of heat points, so you can tell where the limits are in a dense graph. var driftTimeOutline = new BoxObj( 0.0, maxDrift, 1.0, maxDrift - minDrift, Color.FromArgb(50, Color.DarkViolet), Color.Transparent) { Location = { CoordinateFrame = CoordType.XChartFractionYScale }, ZOrder = ZOrder.C_BehindChartBorder, IsClippedToChartRect = true, Border = new Border(Color.FromArgb(100, Color.DarkViolet), 2) }; GraphPane.GraphObjList.Add(driftTimeOutline); } if (!Settings.Default.FilterIonMobilityFullScan) { minDrift = 0; maxDrift = double.MaxValue; } var heatMapGraphPane = (HeatMapGraphPane)GraphPane; heatMapGraphPane.SetPoints(_heatMapData, minDrift, maxDrift); }
//function for printing out HeatMap structure data public static void printInfo(HeatMapData data) { double total_time = 0; Console.WriteLine("\nts: " + data.ts); Console.WriteLine("player_name: " + data.player_name); Console.WriteLine("gridType: " + data.gridType); foreach (var item in data.heatmap) total_time += item.Value; foreach (var item in data.heatmap) Console.WriteLine("index: " + item.Key + " time % : " + (item.Value / total_time) * 100); }
//aggregatorFunction used in TimeWindow based aggregation private static HeatMapData aggregatorFunction(HeatMapData seed, TimeInCell curr, IList<TimeInCell> expList, long count) { HeatMapData new_seed = new HeatMapData { ts = curr.ts, player_name = curr.player_name, gridType=curr.gridType, heatmap = seed.heatmap}; foreach(var item in expList) { if (item.time_in_cell != -999) { if (new_seed.heatmap.ContainsKey(item.prev_index)) { new_seed.heatmap[item.prev_index] -= item.time_in_cell; if (new_seed.heatmap[item.prev_index] <= 0) new_seed.heatmap.Remove(item.prev_index); } else { Console.WriteLine("HeatMapProcessor: Attempt to access non-existent key"); } } } if (curr.time_in_cell != -999) { if (new_seed.heatmap.ContainsKey(curr.prev_index)) new_seed.heatmap[curr.prev_index] += curr.time_in_cell; else new_seed.heatmap.Add(curr.prev_index, curr.time_in_cell); } return new_seed; }