public void AddLine(DataPoint[] data) { var lineSeries = new LineSeries(); lineSeries.ItemsSource = data; Plot.Series.Add(lineSeries); var x = data.Select(d => d.X); _xAxis = new LinearAxis { Position = OxyPlot.Axes.AxisPosition.Bottom }; //, Minimum = x.Min(), Maximum = x.Max() }; Plot.Axes.Add(_xAxis); }
private void HandleNewStockPrice(StockPriceMessage message) { if (_series.ContainsKey(message.StockSymbol)) { var seriesToUpdate = _series[message.StockSymbol]; var newDataPoint = new DataPoint(DateTimeAxis.ToDouble(message.Date), Axis.ToDouble(message.StockPrice)); if (seriesToUpdate.Points.Count > 10) { seriesToUpdate.Points.RemoveAt(0); } seriesToUpdate.Points.Add(newDataPoint); RefreshChart(); } }
public async Task <List <DataPoint> > FetchData(DateTime startTime, DateTime endTime) { List <DataPoint> dataPoints = new List <DataPoint>(); // using data layer for fetching data ConfigurationManagerJSON configManager = new ConfigurationManagerJSON(); configManager.Initialize(); PspDataAdapter adapter = new PspDataAdapter { ConfigurationManager = configManager }; Dictionary <string, List <PspDataLayer.DataPoint> > res = await adapter.GetDataAsync(startTime, endTime, MeasLabel); // check if result has one key since we queried for only one key if (res.Keys.Count == 1) { // todo check the measId also List <PspDataLayer.DataPoint> dataResults = res.Values.ElementAt(0); for (int resIter = 0; resIter < dataResults.Count; resIter++) { DateTime dataTime = dataResults[resIter].Time; // convert the time from utc to local //dataTime = DateTime.SpecifyKind((TimeZoneInfo.ConvertTime(dataTime, TimeZoneInfo.Utc, TimeZoneInfo.Local)), DateTimeKind.Local); DataPoint dataPoint = new DataPoint(DateTimeAxis.ToDouble(dataTime), dataResults[resIter].Value); dataPoints.Add(dataPoint); } // Create dataPoints based on the fetch strategy and max Resolution dataPoints = FetchHelper.GetDataPointsWithGivenMaxSampleInterval(dataPoints, MaxResolution, SamplingStrategy, DateTimeAxis.ToDouble(startTime)); } return(dataPoints); }
private void Plot_model_MouseDown(object sender, OxyMouseDownEventArgs e) { if (e.ChangedButton == OxyMouseButton.Right) { mouse_point = new DataPoint(e.Position.X, e.Position.Y); } }
public void AddPoint(int i, DataPoint dataPoint) { _series[i].Points.Add(dataPoint); // Axes are created automatically if they are not defined // Set the Model property, the INotifyPropertyChanged event will make the WPF Plot control update its content Model = _tmp; }
public TrackerHitResult(Series.Series series, DataPoint dp, ScreenPoint sp, object item = null, double index = -1, string text = null) { this.DataPoint = dp; this.Position = sp; this.Item = item; this.Index = index; this.Series = series; this.Text = text; }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { int[] v = value as int[]; DataPoint[] ret = new DataPoint[v.Length]; for (int i = 0; i < v.Length; i++) { ret[i] = new DataPoint(i, v[i]); } return ret; }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { IList<double> v = value as IList<double>; DataPoint[] ret = new DataPoint[v.Count()]; Console.WriteLine(ret.Length); for(int x=0; x<v.Count(); x++) { ret[x] = new DataPoint(x, v[x]); } return ret; }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { IntHistogram hist = value as IntHistogram; Debug.WriteLine("Beeeeee {0}", hist == null); if (hist == null) return null; DataPoint[] ret = new DataPoint[hist.NBins]; for (int i = 0; i < hist.NBins; i++) { ret[i] = new DataPoint(i, hist.Channel[i]); } Debug.WriteLine(ret.Length); return ret; }
public void PushSample(double sample) { // remove the oldest item if we have filled our buffer if (Points.Count >= MaxPoints) { Points.RemoveAt(0);// remove oldest item } // adjust everyone's time for (int i = 0; i < Points.Count; i++) { var point = Points[i]; Points[i] = new DataPoint(point.X - SampleRate, point.Y); } // add new point Points.Add(sample == UNDEFINED_SAMPLE ? DataPoint.Undefined : new DataPoint(0, sample)); }
public void ShowMovingAverage(pres.TimeFrame timeFrame, IList<StockIntervalData> candelSeries) { Average.Points.Clear(); foreach (Worker.Average c in worker.movingAverage(candelSeries, 50)) { DataPoint p = new DataPoint(OxyPlot.Axes.DateTimeAxis.ToDouble(c.date),(double)c.valueAverage); Average.Points.Add(p); } }
private static Series CreateRandomLineSeries(int n, string title, MarkerType markerType) { var s1 = new LineSeries { Title = title, MarkerType = markerType, MarkerStroke = OxyColors.Black, MarkerStrokeThickness = 1.0 }; double x = 0; double y = 0; for (int i = 0; i < n; i++) { x += 2 + Randomizer.NextDouble() * 10; y += 1 + Randomizer.NextDouble(); var p = new DataPoint(x, y); s1.Points.Add(p); } return s1; }
/// <summary> /// Gets the point on the series that is nearest the specified point. /// </summary> /// <param name="point">The point.</param> /// <param name="interpolate">Interpolate the series if this flag is set to <c>true</c>.</param> /// <returns>A TrackerHitResult for the current hit.</returns> public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate) { var points = this.Points; if (points == null) { return null; } var spn = default(ScreenPoint); var dpn = default(DataPoint); double index = -1; double minimumDistance = double.MaxValue; for (int i = 0; i + 1 < points.Count; i += 2) { var p1 = points[i]; var p2 = points[i + 1]; if (!this.IsValidPoint(p1) || !this.IsValidPoint(p2)) { continue; } var sp1 = this.Transform(p1); var sp2 = this.Transform(p2); // Find the nearest point on the line segment. var spl = ScreenPointHelper.FindPointOnLine(point, sp1, sp2); if (ScreenPoint.IsUndefined(spl)) { // P1 && P2 coincident continue; } double l2 = (point - spl).LengthSquared; if (l2 < minimumDistance) { double u = (spl - sp1).Length / (sp2 - sp1).Length; dpn = new DataPoint(p1.X + (u * (p2.X - p1.X)), p1.Y + (u * (p2.Y - p1.Y))); spn = spl; minimumDistance = l2; index = i + u; } } if (minimumDistance < double.MaxValue) { return new TrackerHitResult { Series = this, DataPoint = dpn, Position = spn, Item = this.GetItem((int)index), Index = index }; } return null; }
void ConstuctPlot(DataPointCollection dataPointCollection) { // function to filter the results if we're not auto-scaling Func <DataPoint, bool> isWithinAxes = p => (AutoScaleX || (p.X <= MaxXValue && p.X >= MinXValue)) && (AutoScaleY || (p.Y <= MaxYValue && p.Y >= MinYValue)); // function to filter out any invalid data points Func <DataPoint, bool> isValidDataPoint = p => !double.IsInfinity(Math.Abs(p.X)) && !double.IsNaN(p.X) && !double.IsInfinity(Math.Abs(p.Y)) && !double.IsNaN(p.Y); //check if any normalization is selected var normToCurve = PlotNormalizationTypeOptionVM.SelectedValue == PlotNormalizationType.RelativeToCurve && DataSeriesCollection.Count > 1; var normToMax = PlotNormalizationTypeOptionVM.SelectedValue == PlotNormalizationType.RelativeToMax && DataSeriesCollection.Count > 0; var tempPointArrayA = new List <Point>(); var tempPointArrayB = new List <Point>(); double x; double y; var lineSeriesA = new LineSeries(); var lineSeriesB = new LineSeries(); //we need B for complex if (dataPointCollection.DataPoints[0] is ComplexDataPoint) { // normalization calculations var max = 1.0; if (normToMax) { var points = dataPointCollection.DataPoints.Cast <ComplexDataPoint>().ToArray(); max = points.Select(p => p.Y.Real).Max(); } double[] tempY = null; if (normToCurve) { tempY = (from ComplexDataPoint dp in DataSeriesCollection[0].DataPoints select dp.Y.Real).ToArray(); } var curveIndex = 0; foreach (var dp in dataPointCollection.DataPoints.Cast <ComplexDataPoint>()) { x = XAxisSpacingOptionVM.SelectedValue == ScalingType.Log ? Math.Log10(dp.X) : dp.X; switch (PlotToggleTypeOptionVM.SelectedValue) { case PlotToggleType.Phase: y = -(dp.Y.Phase * (180 / Math.PI)); break; case PlotToggleType.Amp: y = dp.Y.Magnitude; break; default: // case PlotToggleType.Complex: y = dp.Y.Real; switch (PlotNormalizationTypeOptionVM.SelectedValue) { case PlotNormalizationType.RelativeToCurve: var curveY = normToCurve && tempY != null ? tempY[curveIndex] : 1.0; y = y / curveY; break; case PlotNormalizationType.RelativeToMax: y = y / max; break; } y = YAxisSpacingOptionVM.SelectedValue == ScalingType.Log ? Math.Log10(y) : y; var p = new DataPoint(x, y); if (isValidDataPoint(p) && isWithinAxes(p)) { lineSeriesB.Points.Add(p); //Add the data to the tempPointArray to add to the PlotSeriesCollection tempPointArrayB.Add(new Point(x, y)); } y = dp.Y.Imaginary; break; } switch (PlotNormalizationTypeOptionVM.SelectedValue) { case PlotNormalizationType.RelativeToCurve: var curveY = normToCurve && tempY != null ? tempY[curveIndex] : 1.0; y = y / curveY; break; case PlotNormalizationType.RelativeToMax: y = y / max; break; } y = YAxisSpacingOptionVM.SelectedValue == ScalingType.Log ? Math.Log10(y) : y; var point = new DataPoint(x, y); if (isValidDataPoint(point) && isWithinAxes(point)) { lineSeriesA.Points.Add(point); //Add the data to the tempPointArray to add to the PlotSeriesCollection tempPointArrayA.Add(new Point(x, y)); } curveIndex += 1; } ShowComplexPlotToggle = true; // right now, it's all or nothing - assume all plots are ComplexDataPoints } else { // normalization calculations var max = 1.0; if (normToMax) { var points = dataPointCollection.DataPoints.Cast <DoubleDataPoint>().ToArray(); max = points.Select(p => p.Y).Max(); } double[] tempY = null; if (normToCurve) { tempY = (from DoubleDataPoint dp in DataSeriesCollection[0].DataPoints select dp.Y).ToArray(); } var curveIndex = 0; foreach (var dp in dataPointCollection.DataPoints.Cast <DoubleDataPoint>()) { x = XAxisSpacingOptionVM.SelectedValue == ScalingType.Log ? Math.Log10(dp.X) : dp.X; switch (PlotNormalizationTypeOptionVM.SelectedValue) { case PlotNormalizationType.RelativeToCurve: var curveY = normToCurve && tempY != null ? tempY[curveIndex] : 1.0; y = dp.Y / curveY; break; case PlotNormalizationType.RelativeToMax: y = dp.Y / max; break; default: y = dp.Y; break; } y = YAxisSpacingOptionVM.SelectedValue == ScalingType.Log ? Math.Log10(y) : y; var point = new DataPoint(x, y); if (isValidDataPoint(point) && isWithinAxes(point)) { lineSeriesA.Points.Add(point); //Add the data to the tempPointArray to add to the PlotSeriesCollection tempPointArrayA.Add(new Point(x, y)); } curveIndex += 1; } } if (ShowComplexPlotToggle) { switch (PlotToggleTypeOptionVM.SelectedValue) { case PlotToggleType.Complex: lineSeriesA.Title = dataPointCollection.Title + " (imag)"; lineSeriesB.Title = dataPointCollection.Title + " (real)"; lineSeriesB.MarkerType = MarkerType.Circle; PlotModel.Series.Add(lineSeriesB); PlotSeriesCollection.Add(tempPointArrayB.ToArray()); break; case PlotToggleType.Phase: lineSeriesA.Title = dataPointCollection.Title + " (phase)"; break; case PlotToggleType.Amp: lineSeriesA.Title = dataPointCollection.Title + " (amp)"; break; } lineSeriesA.MarkerType = MarkerType.Circle; PlotModel.Series.Add(lineSeriesA); PlotModel.Title = PlotTitles[PlotTitles.Count - 1]; PlotSeriesCollection.Add(tempPointArrayA.ToArray()); } else { lineSeriesA.Title = dataPointCollection.Title; lineSeriesA.MarkerType = MarkerType.Circle; PlotModel.Series.Add(lineSeriesA); PlotModel.Title = PlotTitles[PlotTitles.Count - 1]; PlotSeriesCollection.Add(tempPointArrayA.ToArray()); } }
protected bool GetNearestPointInternal( IEnumerable<IDataPoint> points, ScreenPoint point, out DataPoint dpn, out ScreenPoint spn, out int index) { spn = default(ScreenPoint); dpn = default(DataPoint); index = -1; double minimumDistance = double.MaxValue; int i = 0; foreach (DataPoint p in points) { ScreenPoint sp = AxisBase.Transform(p, this.XAxis, this.YAxis); double dx = sp.x - point.x; double dy = sp.y - point.y; double d2 = dx * dx + dy * dy; if (d2 < minimumDistance) { dpn = p; spn = sp; minimumDistance = d2; index = i; } i++; } return minimumDistance < double.MaxValue; }
public void DrawLine(DataPoint start, double angle, double length, LineStyle style = LineStyle.Solid) { var a = Math.Sin(DegreeToRadian(angle)) * length; var b = Math.Cos(DegreeToRadian(angle)) * length; DrawLine(start, new DataPoint(start.X + b, start.Y + a), style); }
protected virtual string GetSelectedPointInfo(LineSeries lineSeries, DataPoint point) { return string.Format("{0}{1}{2}: {3}{1}{4}: {5}", lineSeries.Title, Environment.NewLine, lineSeries.XAxis.Title, point.X, lineSeries.YAxis.Title, point.Y); }
/// <summary> /// CTOR /// </summary> public CPUCoreWorkloadChartUserControl() { InitializeComponent(); this.CPUCoreWorkloadPlot = new PlotModel(); this.CPUCoreWorkloadPlot.Axes.Add(new LinearAxis() { IsZoomEnabled = false, Maximum = 102, Minimum = 0, MajorGridlineStyle = LineStyle.Solid, MinorGridlineStyle = LineStyle.Dot, Position = AxisPosition.Left }); this.CPUCoreWorkloadPlot.Axes.Add(new LinearAxis() { IsZoomEnabled = false, Maximum = 102, Minimum = 0, MajorGridlineStyle = LineStyle.Solid, MinorGridlineStyle = LineStyle.Dot, Position = AxisPosition.Right }); this.CPUCoreWorkloadPlot.Axes.Add(new LinearAxis() { IsZoomEnabled = false, Position = AxisPosition.Bottom, TickStyle = TickStyle.None, IsAxisVisible = false }); var areaSeries = new LineSeries() { StrokeThickness = 1, LineStyle = OxyPlot.LineStyle.Solid, Color = OxyColors.Blue, // Color2 = OxyColors.Transparent, // Fill = OxyColor.FromRgb(214, 231, 242), // DataFieldX = "X", // DataFieldY = "Y", // DataFieldX2 = "X" }; for (int i = 0; i < 60; i++) { var dp = new DataPoint(i, 0); areaSeries.Points.Add(dp); } this.CPUCoreWorkloadPlot.Series.Add(areaSeries); }
/// <summary> /// This is a non-static version of the dep. property changed event /// </summary> /// <param name="args"></param> void CurrentCoreWorkloadChangedPropertyCallback(DependencyPropertyChangedEventArgs args) { var areaSeries = (LineSeries)this.CPUCoreWorkloadPlot.Series[0]; if (areaSeries.Points.Count > 60) areaSeries.Points.RemoveAt(0); double x = areaSeries.Points.Count > 0 ? areaSeries.Points[areaSeries.Points.Count - 1].X + 1 : 0; var dp = new DataPoint(x, Convert.ToDouble(args.NewValue)); areaSeries.Points.Add(dp); if (this.CurrentCpuWorkloadSeries != null && this.CurrentCpuWorkloadSeries.Count == 0) { this.CurrentCpuWorkloadSeries.Add(new ChartDataPoint() { Name = "Workload", Value = Convert.ToDouble(args.NewValue) }); } else { this.CurrentCpuWorkloadSeries.FirstOrDefault().Value = Convert.ToDouble(args.NewValue); } this.CPUCoreWorkloadPlot.InvalidatePlot(true); }
/// <summary> /// Transforms the specified point to screen coordinates. /// </summary> /// <param name="p"> /// The point. /// </param> /// <param name="xaxis"> /// The x axis. /// </param> /// <param name="yaxis"> /// The y axis. /// </param> /// <returns> /// The transformed point. /// </returns> public static ScreenPoint Transform(DataPoint p, Axis xaxis, Axis yaxis) { return xaxis.Transform(p.x, p.y, yaxis); }
/// <summary> /// Gets the point on the series that is nearest the specified point. /// </summary> /// <param name="point">The point.</param> /// <param name="interpolate">Interpolate the series if this flag is set to <c>true</c>.</param> /// <returns> /// A TrackerHitResult for the current hit. /// </returns> public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate) { if (interpolate) { return null; } TrackerHitResult result = null; // http://local.wasp.uwa.edu.au/~pbourke/geometry/pointline/ double minimumDistance = double.MaxValue; var points = this.Points; for (int i = 0; i < points.Count; i++) { var p1 = points[i]; var basePoint = new DataPoint(p1.X, this.Base); var sp1 = this.Transform(p1); var sp2 = this.Transform(basePoint); var u = ScreenPointHelper.FindPositionOnLine(point, sp1, sp2); if (double.IsNaN(u)) { continue; } if (u < 0 || u > 1) { continue; // outside line } var sp = sp1 + ((sp2 - sp1) * u); double distance = (point - sp).LengthSquared; if (distance < minimumDistance) { result = new TrackerHitResult( this, new DataPoint(p1.X, p1.Y), new ScreenPoint(sp1.x, sp1.y), this.GetItem(i)); minimumDistance = distance; } } return result; }
private static IList<IDataPoint> CreateRandomPoints(int n) { var points = new List<IDataPoint>(); for (int i = 0; i < n; i++) { double x = Randomizer.NextDouble() * 10; double y = Randomizer.NextDouble() * 10; var p = new DataPoint(x, y); points.Add(p); } return points; }
public void DrawLine(DataPoint start, DataPoint end, LineStyle style = LineStyle.Solid) { var line = new LineSeries { StrokeThickness = 2, Smooth = true, Color = OxyColor.FromRgb(0, 0, 0), LineStyle = style, Points = new List<IDataPoint>() }; var deltaX = Math.Abs(start.X - end.X); var deltaY = Math.Abs(start.Y - end.Y); var k = deltaY / deltaX; if (start.Y > end.Y) k = -k; var i = 0.0; while (i <= deltaX) { var x = i; if (start.X > end.X) x = -i; line.Points.Add(new DataPoint(start.X + x, (start.Y + k*i))); i += Opt.Step; } //Shit for vertical line if ((int)start.X == (int)end.X) { var startY = start.Y < end.Y ? start : end; for (var j = startY.Y; j < startY.Y + deltaY; j += Opt.Step) line.Points.Add(new DataPoint(start.X, j)); } _mainPlot.Series.Add(line); }
public PointInfo(DataPoint point, string label = null, bool isVisible = true) { Point = point; Label = label; IsPointVisible = isVisible; }
/// <summary> /// Gets the point on the curve that is nearest the specified point. /// </summary> /// <param name = "point">The point.</param> /// <param name = "dpn">The nearest point (data coordinates).</param> /// <param name = "spn">The nearest point (screen coordinates).</param> /// <returns></returns> protected bool GetNearestInterpolatedPointInternal( IList<IDataPoint> points, ScreenPoint point, out DataPoint dpn, out ScreenPoint spn, out int index) { spn = default(ScreenPoint); dpn = default(DataPoint); index = -1; // http://local.wasp.uwa.edu.au/~pbourke/geometry/pointline/ double minimumDistance = double.MaxValue; for (int i = 0; i + 1 < points.Count; i++) { IDataPoint p1 = points[i]; IDataPoint p2 = points[i + 1]; ScreenPoint sp1 = AxisBase.Transform(p1, this.XAxis, this.YAxis); ScreenPoint sp2 = AxisBase.Transform(p2, this.XAxis, this.YAxis); double sp21X = sp2.x - sp1.x; double sp21Y = sp2.y - sp1.y; double u1 = (point.x - sp1.x) * sp21X + (point.y - sp1.y) * sp21Y; double u2 = sp21X * sp21X + sp21Y * sp21Y; double ds = sp21X * sp21X + sp21Y * sp21Y; if (ds < 4) { // if the points are very close, we can get numerical problems, just use the first point... u1 = 0; u2 = 1; } if (u2 < double.Epsilon && u2 > -double.Epsilon) { continue; // P1 && P2 coincident } double u = u1 / u2; if (u < 0) u = 0; if (u > 1) u = 1; double sx = sp1.x + u * sp21X; double sy = sp1.y + u * sp21Y; double dx = point.x - sx; double dy = point.y - sy; double distance = dx * dx + dy * dy; if (distance < minimumDistance) { double px = p1.X + u * (p2.X - p1.X); double py = p1.Y + u * (p2.Y - p1.Y); dpn = new DataPoint(px, py); spn = new ScreenPoint(sx, sy); minimumDistance = distance; index = i; } } return minimumDistance < double.MaxValue; }
public void Drawing() { var options = new GraphOptions(null, null, 0.01, new GraphSize(0, 720, -40, _sizeY), new SvgFileSize((int)(_sizeY * 3.4 * 2.2 * 4), (int)(_sizeY * 3.4 * 4)), AppDomain.CurrentDomain.BaseDirectory + @"\Graph\Temp\gr2.tmp", ""); options.PosX = App.CurrentEngineType == EngineType.Petrol ? 3000 : 4000; options.PosY = 400; Graph = new Graph(InitPlot(options), options); Graph.DrawLine(new DataPoint(180, _sizeY), new DataPoint(180, -30), LineStyle.Dash); Graph.DrawLine(new DataPoint(360, _sizeY), new DataPoint(360, -30), LineStyle.Dash); Graph.DrawLine(new DataPoint(540, _sizeY), new DataPoint(540, -30), LineStyle.Dash); Graph.DrawLine(new DataPoint(720, _sizeY), new DataPoint(720, -30), LineStyle.Dash); //Inlet var mainLine1Start = new DataPoint(0, -_p0); var mainLine1End = new DataPoint(180, -_p0); Graph.DrawLine(mainLine1Start, mainLine1End); //Outlet var mainLine2Start = new DataPoint(540, _p0); var mainLine2End = new DataPoint(720, _p0); Graph.DrawLine(mainLine2Start, mainLine2End); //Compression and Working stroke lines var pointsCompression = CompressionCurve(); _pointsCompression = pointsCompression; Graph.DrawCurve(pointsCompression); var pointsWorkingStroke = WorkingStrokeCurve(); _pointsWorkingStroke = pointsWorkingStroke; Graph.DrawCurve(pointsWorkingStroke); //Connection line between compression and working stroke lines var connectionLineStart = new DataPoint(360, pointsCompression[pointsCompression.Count - 1].Y); var connectionLineEnd = new DataPoint(360, pointsWorkingStroke[0].Y); Graph.DrawLine(connectionLineStart, connectionLineEnd); Graph.DrawLine(new DataPoint(0, _sizeY - _sizeY * 0.05), new DataPoint(720, _sizeY - _sizeY * 0.05)); //Pj line PjCurve(); //Ro line if (App.CurrentEngineType == EngineType.Diesel) Graph.DrawLine(new DataPoint(360, pointsWorkingStroke[0].Y), new DataPoint(360 + _data["Ro"].Val, pointsWorkingStroke[0].Y)); }
private static DataPoint[] Fractalise(DataPoint[] data, DataPoint[] detail) { var result = new DataPoint[(data.Length - 1) * detail.Length + 1]; int j = 0; for (int i = 0; i + 1 < data.Length; i++) { double dx = data[i + 1].X - data[i].X; double dy = data[i + 1].Y - data[i].Y; foreach (var uv in detail) result[j++] = new DataPoint(data[i].X + dx * uv.X + dy * uv.Y, data[i].Y + dy * uv.X - dx * uv.Y); } result[j] = data.Last(); return result; }
private List<DataPoint> CompressionCurve() { var list = new List<DataPoint>(); var step = 180.0 / _sizeX; //Compression for (var i = 0; i < _mainCurve2X.Count; i++) { list.Add(new DataPoint(360 - (_mainCurve2X[_mainCurve2X.Count - i - 1] - _sc) * step, _mainCurve2Y[_mainCurve2Y.Count - i - 1] - _p0)); } //Some necessary correction list[0] = new DataPoint(180, -_p0); list[1] = new DataPoint(210, 0); var y = list.Select(dataPoint => dataPoint.Y).ToList(); var x = list.Select(dataPoint => dataPoint.X).ToList(); var interpolation = CubicSpline.InterpolateAkima(x, y); list = new List<DataPoint>(); for (var i = 180; i <= 360; i += 30) list.Add(new DataPoint(i, interpolation.Interpolate(i))); //Some necessary correction var scaleY = _data["MaxPressure"].Val < 5 ? 0.025 : _data["MaxPressure"].Val > 8 ? 0.05 : 0.04; list[list.Count - 1] = new DataPoint(360, _data["PressureCompression"].Val / scaleY); return list; }
private List<DataPoint> WorkingStrokeCurve() { var list = new List<DataPoint>(); double step; if (App.CurrentEngineType == EngineType.Petrol) step = 180.0 / _sizeX; else step = (180.0 - _data["Ro"].Val) / _sizeX; //Working stroke var scaleX = _data["PistonStroke"].Val > 80 ? 1 : 0.5; for (var i = 0; i < _mainCurve1X.Count; i++) { list.Add(App.CurrentEngineType == EngineType.Petrol ? new DataPoint((_mainCurve1X[i] - _sc) * step + 360, _mainCurve1Y[i] - _p0) : new DataPoint((_mainCurve1X[i] - _sc - _data["Sigma"].Val / scaleX) * step + 360, _mainCurve1Y[i] - _p0)); } var shitY = list[0].Y; if (App.CurrentEngineType == EngineType.Diesel) { //Just must be! list[list.Count - 1] = new DataPoint(540, list[list.Count - 1].Y); var len = 180; var newLen = len - _data["Ro"].Val; for (var i = 0; i < list.Count; i++) { var newX = (len - (list[list.Count - i - 1].X - 360)) * newLen / len; var a = len - (list[list.Count - i - 1].X - 360) - newX; list[list.Count - i - 1] = new DataPoint(list[list.Count - i - 1].X + a, list[list.Count - i - 1].Y); } } var y = list.Select(dataPoint => dataPoint.Y).ToList(); var x = list.Select(dataPoint => dataPoint.X).ToList(); var interpolation = CubicSpline.InterpolateAkima(x, y); list = new List<DataPoint>(); for (var i = 360; i <= 540; i += 30) if (i != 450) list.Add(new DataPoint(i, interpolation.Interpolate(i))); if (App.CurrentEngineType == EngineType.Diesel) list[0] = new DataPoint(360 + _data["Ro"].Val, shitY); list[list.Count - 1] = new DataPoint(540, list[list.Count - 1].Y - _p0); return list; }
private void PSumCurve() { var line = new List<DataPoint>(); for (var i = 0; i < 12; i++) { line.Add(new DataPoint(i * 30, _data["OrdinatesSpecificSummaryForces" + i].Val)); } var scaleY = _data["MaxPressure"].Val < 5 ? 0.025 : _data["MaxPressure"].Val > 8 ? 0.05 : 0.04; line.Add(new DataPoint(12 * 30, _data["PressureCompression"].Val / scaleY)); Graph.DrawCurve(line, null, LineStyle.Dot); line = new List<DataPoint>(); for (var i = 13; i < 20; i++) { line.Add(new DataPoint((i-1) * 30, _data["OrdinatesSpecificSummaryForces" + i].Val)); } if (App.CurrentEngineType == EngineType.Diesel) { line[0] = new DataPoint(360 + _data["Ro"].Val, line[0].Y); Graph.DrawLine(new DataPoint(360, line[0].Y), line[0], LineStyle.Dot); } Graph.DrawCurve(line, null, LineStyle.Dot); line = new List<DataPoint>(); for (var i = 20; i < 27; i++) { line.Add(new DataPoint((i - 2) * 30, _data["OrdinatesSpecificSummaryForces" + i].Val)); } Graph.DrawCurve(line, null, LineStyle.Dot); }
public void ShowSlider(DataSeries s, DataPoint dp) { }
/// <summary> /// Gets the point in the dataset that is nearest the specified point. /// </summary> /// <param name="point"> /// The point. /// </param> /// <param name="interpolate"> /// The interpolate. /// </param> /// <returns> /// A TrackerHitResult for the current hit. /// </returns> public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate) { for (int i = 0; i < this.ActualBarRectangles.Count; i++) { var r = this.ActualBarRectangles[i]; if (r.Contains(point)) { var item = (IntervalBarItem)this.GetItem(this.ValidItemsIndexInversion[i]); var categoryIndex = item.GetCategoryIndex(i); double value = (this.ValidItems[i].Start + this.ValidItems[i].End) / 2; var dp = new DataPoint(categoryIndex, value); var text = StringHelper.Format( this.ActualCulture, this.TrackerFormatString, item, this.Items[i].Start, this.Items[i].End, this.Items[i].Title); return new TrackerHitResult(this, dp, point, item, i, text); } } return null; }
public void Update() { if (series > 3) series = 0; var points = new DataPoint[NumberOfPoints]; for (int i = 0; i < _xs.Length; i++) { points[i] = new DataPoint(_xs[i], _yss[series][i]); } series++; _lineSeries.ItemsSource = points; PlotModel.InvalidatePlot(true); }
/// <summary> /// Gets the point on the curve that is nearest the specified point. /// </summary> /// <param name = "point">The point.</param> /// <param name = "dpn">The nearest point (data coordinates).</param> /// <param name = "spn">The nearest point (screen coordinates).</param> /// <returns></returns> protected bool GetNearestInterpolatedPointInternal( IList <IDataPoint> points, ScreenPoint point, out DataPoint dpn, out ScreenPoint spn, out int index) { spn = default(ScreenPoint); dpn = default(DataPoint); index = -1; // http://local.wasp.uwa.edu.au/~pbourke/geometry/pointline/ double minimumDistance = double.MaxValue; for (int i = 0; i + 1 < points.Count; i++) { IDataPoint p1 = points[i]; IDataPoint p2 = points[i + 1]; ScreenPoint sp1 = AxisBase.Transform(p1, this.XAxis, this.YAxis); ScreenPoint sp2 = AxisBase.Transform(p2, this.XAxis, this.YAxis); double sp21X = sp2.x - sp1.x; double sp21Y = sp2.y - sp1.y; double u1 = (point.x - sp1.x) * sp21X + (point.y - sp1.y) * sp21Y; double u2 = sp21X * sp21X + sp21Y * sp21Y; double ds = sp21X * sp21X + sp21Y * sp21Y; if (ds < 4) { // if the points are very close, we can get numerical problems, just use the first point... u1 = 0; u2 = 1; } if (u2 < double.Epsilon && u2 > -double.Epsilon) { continue; // P1 && P2 coincident } double u = u1 / u2; if (u < 0) { u = 0; } if (u > 1) { u = 1; } double sx = sp1.x + u * sp21X; double sy = sp1.y + u * sp21Y; double dx = point.x - sx; double dy = point.y - sy; double distance = dx * dx + dy * dy; if (distance < minimumDistance) { double px = p1.X + u * (p2.X - p1.X); double py = p1.Y + u * (p2.Y - p1.Y); dpn = new DataPoint(px, py); spn = new ScreenPoint(sx, sy); minimumDistance = distance; index = i; } } return(minimumDistance < double.MaxValue); }