//public void Create3dPlot(double mz, double tolerance)
//{
// LinesVisual3D plot = new LinesVisual3D();
// plot.Thickness = 20;
// Console.WriteLine("mz = " + mz);
// Console.WriteLine("tolerance = " + tolerance);
// List<IntensityPoint> uimfPointList = this.UimfUtil.GetXic(mz, tolerance, DataReader.FrameType.MS1, DataReader.ToleranceType.PPM);
// Console.WriteLine("# points = " + uimfPointList.Count);
// foreach (var intensityPoint in uimfPointList)
// {
// Point3D point = new Point3D(intensityPoint.ScanLc, intensityPoint.ScanIms, intensityPoint.Intensity);
// plot.Points.Add(point);
// }
// this.XicPlotPoints = plot.Points;
// this.XicPlot = plot;
// //OnPropertyChanged("XicPlotPoints");
// //OnPropertyChanged("XicPlot");
// this.XicMeshPlot = new Mesh3D();
//}
//public void CreateContourPlot(double mz, double tolerance)
//{
// PlotModel plotModel = new PlotModel("XIC Contour Plot");
// ContourSeries contourSeries = new ContourSeries();
// contourSeries.Data = this.UimfUtil.GetXicAsArray(mz, tolerance, DataReader.FrameType.MS1, DataReader.ToleranceType.PPM);
// contourSeries.ContourColors = new[] { OxyColors.Blue, OxyColors.Yellow, OxyColors.Red };
// contourSeries.RowCoordinates = ArrayHelper.CreateVector(0, 1, 2);
// contourSeries.ColumnCoordinates = ArrayHelper.CreateVector(0, 1, 2);
// plotModel.Series.Add(contourSeries);
// //Func<double, double, double> peaks = (x, y) =>
// // 3 * (1 - x) * (1 - x) * Math.Exp(-(x * x) - (y + 1) * (y + 1))
// // - 10 * (x / 5 - x * x * x - y * y * y * y * y) * Math.Exp(-x * x - y * y)
// // - 1.0 / 3 * Math.Exp(-(x + 1) * (x + 1) - y * y);
// //var cs = new ContourSeries
// //{
// // ColumnCoordinates = ArrayHelper.CreateVector(-3, 3, 0.05),
// // RowCoordinates = ArrayHelper.CreateVector(-3.1, 3.1, 0.05),
// // ContourColors = new[] { OxyColors.SeaGreen, OxyColors.RoyalBlue, OxyColors.IndianRed }
// //};
// //cs.Data = ArrayHelper.Evaluate(peaks, cs.ColumnCoordinates, cs.RowCoordinates);
// //plotModel.Series.Add(cs);
// this.XicContourPlot = plotModel;
// OnPropertyChanged("XicContourPlot");
//}
public void FeatureSelectionChange(FeatureBlob featureBlob)
{
CurrentFeature = featureBlob;
OnPropertyChanged("CurrentFeature");
CreateLcAndImsSlicePlots(featureBlob);
}
private void FeatureSelectionChange(object sender, SelectionChangedEventArgs e)
{
var selectedItem = (sender as DataGrid).SelectedItem;
if (selectedItem != null && ReferenceEquals(selectedItem.GetType(), typeof(FeatureBlob)))
{
FeatureBlob featureBlob = (FeatureBlob)selectedItem;
this.XicBrowserViewModel.CreateLcAndImsSlicePlots(featureBlob);
}
}
public static double CorrelateFeaturesUsingIms(FeatureBlob referenceFeature, FeatureBlob featureToTest)
{
var referenceStatistics = referenceFeature.Statistics;
var testStatistics = featureToTest.Statistics;
var referenceScanImsMin = referenceStatistics.ScanImsMin;
var referenceScanImsMax = referenceStatistics.ScanImsMax;
var testScanImsMin = testStatistics.ScanImsMin;
var testScanImsMax = testStatistics.ScanImsMax;
// If these features do not overlap, then just return 0
if (testScanImsMin > referenceScanImsMax || testScanImsMax < referenceScanImsMin)
{
return(0);
}
var scanImsOffset = referenceScanImsMin - testScanImsMin;
var referenceImsProfile = Array.ConvertAll(referenceStatistics.ImsApexPeakProfile, x => (double)x);
var testImsProfile = new double[referenceScanImsMax - referenceScanImsMin + 1];
var testImsProfileAsFloat = testStatistics.ImsApexPeakProfile;
var numPointsInTestImsProfile = testImsProfileAsFloat.Length;
for (var i = 0; i < referenceImsProfile.Length; i++)
{
var testImsProfileIndex = i + scanImsOffset;
if (testImsProfileIndex < 0)
{
continue;
}
if (testImsProfileIndex >= numPointsInTestImsProfile)
{
break;
}
testImsProfile[i] = testImsProfileAsFloat[testImsProfileIndex];
}
double slope, intercept, rSquared;
GetLinearRegression(referenceImsProfile, testImsProfile, out slope, out intercept, out rSquared);
return(rSquared);
}
public void CreateLcAndImsSlicePlots(FeatureBlob feature)
{
CurrentFeature = feature;
OnPropertyChanged("CurrentFeature");
if (feature != null)
{
CreateLcSlicePlot(feature);
CreateImsSlicePlot(feature);
MatchPrecursorToFragments();
AddIsotopesToPlots();
OnPropertyChanged("LcSlicePlot");
OnPropertyChanged("ImsSlicePlot");
}
}
private void AddToImsPlot(FeatureBlob feature, string title, OxyColor color)
{
// TODO: Use unique colors
var newImsSeries = new LineSeries()
{
Color = color,
StrokeThickness = 1,
Title = title
};
newImsSeries.MouseDown += SeriesOnSelected;
foreach (var group in feature.PointList.GroupBy(x => x.ScanIms).OrderBy(x => x.Key))
{
var scanLc = group.Key;
var intensity = group.Sum(x => x.Intensity);
var dataPoint = new DataPoint(scanLc, intensity / m_maxImsIntensity);
newImsSeries.Points.Add(dataPoint);
}
ImsSlicePlot.Series.Add(newImsSeries);
}
private void CreateImsSlicePlot(FeatureBlob feature)
{
var plotModel = new PlotModel
{
Title = "IMS Slice",
TitleFontSize = 12,
Padding = new OxyThickness(0),
PlotMargins = new OxyThickness(0),
IsLegendVisible = false
};
var imsSeries = new LineSeries {
Color = OxyColors.Blue
};
imsSeries.MouseDown += SeriesOnSelected;
var minScanIms = int.MaxValue;
var maxScanIms = int.MinValue;
var maxIntensity = double.MinValue;
// Find the maximum intensity so that we can scale the Y values to be between 0 and 1
foreach (var group in feature.PointList.GroupBy(x => x.ScanIms).OrderBy(x => x.Key))
{
var intensity = group.Sum(x => x.Intensity);
if (intensity > maxIntensity)
{
maxIntensity = intensity;
}
}
foreach (var group in feature.PointList.GroupBy(x => x.ScanIms).OrderBy(x => x.Key))
{
var scanIms = group.Key;
var intensity = group.Sum(x => x.Intensity);
if (scanIms < minScanIms)
{
minScanIms = scanIms;
}
if (scanIms > maxScanIms)
{
maxScanIms = scanIms;
}
var dataPoint = new DataPoint(scanIms, intensity / maxIntensity);
imsSeries.Points.Add(dataPoint);
}
plotModel.Series.Add(imsSeries);
var yAxis = new LinearAxis
{
Position = AxisPosition.Left,
Title = "Relative Intensity",
Minimum = 0,
AbsoluteMinimum = 0,
Maximum = 1.01,
AbsoluteMaximum = 1.01,
IsPanEnabled = true,
IsZoomEnabled = true
};
yAxis.AxisChanged += OnYAxisChange;
var xAxis = new LinearAxis
{
Position = AxisPosition.Bottom,
Title = "IMS Scan #",
Minimum = minScanIms - 5,
AbsoluteMinimum = minScanIms - 5,
Maximum = maxScanIms + 5,
AbsoluteMaximum = maxScanIms + 5,
IsPanEnabled = true,
IsZoomEnabled = true
};
plotModel.Axes.Add(xAxis);
plotModel.Axes.Add(yAxis);
m_maxImsIntensity = maxIntensity;
ImsSlicePlot = plotModel;
OnPropertyChanged("ImsSlicePlot");
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureBlobNet"/> class.
/// </summary>
/// <param name="featureBlob">
/// The feature blob.
/// </param>
/// <param name="normalizedElutionTime">
/// The normalized elution time.
/// </param>
public FeatureBlobNet(FeatureBlob featureBlob, double normalizedElutionTime)
{
this.FeatureBlob = featureBlob;
this.NormalizedElutionTime = normalizedElutionTime;
}
public static double CorrelateFeaturesLinearRegression(FeatureBlob referencesFeature, FeatureBlob featureToTest)
{
var pointComparer = new AnonymousComparer <Point>((x, y) => x.ScanLc != y.ScanLc ? x.ScanLc.CompareTo(y.ScanLc) : x.ScanIms.CompareTo(y.ScanIms));
var numPoints = referencesFeature.PointList.Count;
var inputData = new double[numPoints, 2];
var testPointList = featureToTest.PointList;
testPointList.Sort(pointComparer);
var index = 0;
double sumOfTestValues = 0;
// Get the corresponding reference:test intensity values
foreach (var referencePoint in referencesFeature.PointList)
{
inputData[index, 0] = referencePoint.Intensity;
var binarySearchResult = testPointList.BinarySearch(referencePoint, pointComparer);
if (binarySearchResult < 0)
{
inputData[index, 1] = 0;
}
else
{
var intensity = testPointList[binarySearchResult].Intensity;
inputData[index, 1] = intensity;
sumOfTestValues += intensity;
}
index++;
}
var numIndependentVariables = 1;
int info;
alglib.linearmodel linearModel;
alglib.lrreport regressionReport;
alglib.lrbuild(inputData, numPoints, numIndependentVariables, out info, out linearModel, out regressionReport);
double[] regressionLineInfo;
alglib.lrunpack(linearModel, out regressionLineInfo, out numIndependentVariables);
var slope = regressionLineInfo[0];
var intercept = regressionLineInfo[1];
double rSquared = 0;
var averageOfTestValues = sumOfTestValues / numPoints;
double sumOfSquaredMeanResiduals = 0;
double sumOfSquaredResiduals = 0;
for (var i = 0; i < numPoints; i++)
{
var referenceValue = inputData[i, 0];
var testValue = inputData[i, 1];
var calculatedTestValue = alglib.lrprocess(linearModel, new double[] { referenceValue });
var residual = testValue - calculatedTestValue;
sumOfSquaredResiduals += (residual * residual);
var meanResidual = testValue - averageOfTestValues;
sumOfSquaredMeanResiduals += (meanResidual * meanResidual);
}
if (sumOfSquaredMeanResiduals > 0)
{
rSquared = 1 - (sumOfSquaredResiduals / sumOfSquaredMeanResiduals);
}
return(rSquared);
}
public static double CorrelateFeatures(FeatureBlob referenceFeature, FeatureBlob featureToTest)
{
double refMaxIntensity = 0;
var refScanLcMin = int.MaxValue;
var refScanLcMax = 0;
var refScanImsMin = int.MaxValue;
var refScanImsMax = 0;
var refScanLcRep = 0;
var refScanImsRep = 0;
foreach (var point in referenceFeature.PointList)
{
var scanIms = point.ScanIms;
var scanLc = point.ScanLc;
var intensity = point.Intensity;
if (scanIms < refScanImsMin)
{
refScanImsMin = scanIms;
}
if (scanIms > refScanImsMax)
{
refScanImsMax = scanIms;
}
if (scanLc < refScanLcMin)
{
refScanLcMin = scanLc;
}
if (scanLc > refScanLcMax)
{
refScanLcMax = scanLc;
}
if (intensity > refMaxIntensity)
{
refMaxIntensity = intensity;
refScanLcRep = scanLc;
refScanImsRep = scanIms;
}
}
double testMaxIntensity = 0;
var testScanLcMin = int.MaxValue;
var testScanLcMax = 0;
var testScanImsMin = int.MaxValue;
var testScanImsMax = 0;
var testScanLcRep = 0;
var testScanImsRep = 0;
foreach (var point in featureToTest.PointList)
{
var scanIms = point.ScanIms;
var scanLc = point.ScanLc;
var intensity = point.Intensity;
if (scanIms < testScanImsMin)
{
testScanImsMin = scanIms;
}
if (scanIms > testScanImsMax)
{
testScanImsMax = scanIms;
}
if (scanLc < testScanLcMin)
{
testScanLcMin = scanLc;
}
if (scanLc > testScanLcMax)
{
testScanLcMax = scanLc;
}
if (intensity > testMaxIntensity)
{
testMaxIntensity = intensity;
testScanLcRep = scanLc;
testScanImsRep = scanIms;
}
}
Console.WriteLine("RefLcRep = " + refScanLcRep + "\tTestLcRep = " + testScanLcRep + "\tRefImsRep = " + refScanImsRep + "\tTestImsRep = " + testScanImsRep + "\tRefLc = " + refScanLcMin + " - " + refScanLcMax + "\tTestLc = " + testScanLcMin + " - " + testScanLcMax + "\tRefIms = " + refScanImsMin + " - " + refScanImsMax + "\tTestIms = " + testScanImsMin + " - " + testScanImsMax + "\tRefIntensity = " + refMaxIntensity + "\tTestIntensity = " + testMaxIntensity);
return(0);
}
