private int GetControlPoint(Canvas canvas, Point p, IPointSeries pp0)
{
List <Rect> rr = new List <Rect>();
VisualTreeHelper.HitTest(Canvas,
o => o is Ellipse
? HitTestFilterBehavior.Continue
: HitTestFilterBehavior.ContinueSkipSelf,
result =>
{
if (result.VisualHit is Ellipse e)
{
Rect r = new Rect(Canvas.GetLeft(e), Canvas.GetTop(e), e.Width, e.Height);
rr.Add(r);
}
return(HitTestResultBehavior.Continue);
}, new PointHitTestParameters(p));
foreach (Rect r1 in rr)
{
for (int i = 0; i < pp0.Count; ++i)
{
Point p0 = _transform.Transform(pp0[i]);
if (r1.Contains(p0))
{
return(i);
}
}
}
return(-1);
}
private void Paste(object sender, ExecutedRoutedEventArgs e)
{
PointSeries ps = PointSeriesConverter.GetClipboard();
if (ps != null)
{
IPointSeries pp1 = PointSeries.Union(_controlPoints, ps);
UndoRedo.PushUndo(new UndoObject(
"paste " + Channel.ToString() + " points.",
new UndoContext(new PointSeries(_controlPoints), new PointSeries(pp1)),
(uc) => {
Palette.UpdateControlPoints(Channel, uc[0] as PointSeries);
InvalidateVisual();
return(uc);
},
(rc) =>
{
Palette.UpdateControlPoints(Channel, rc[1] as PointSeries);
InvalidateVisual();
}));
Palette.UpdateControlPoints(Channel, pp1);
_controlPoints = Palette.GetControlPoints(Channel);
InvalidateVisual();
_adorner.ClearSelection();
}
}
private void CustomTransform(IPointSeries pointSeries, double currentProgress)
{
if (pointSeries.Count > 1)
{
lock (RenderableSeries.DataSeries.SyncRoot)
{
if (pointSeries.Count > 1)
{
var addedPointSeriesIndex = pointSeries.Count - 1;
var prevPointSeriesIndex = pointSeries.Count - 2;
// Find corresponding indexes in DataSeries
var addedDataSeriesIndex = pointSeries.Indexes[addedPointSeriesIndex];
var prevDataSeriesIndex = pointSeries.Indexes[prevPointSeriesIndex];
// Get X,Y data values from DataSeries by indexes
var addedXValue = Convert.ToDouble(RenderableSeries.DataSeries.XValues[addedDataSeriesIndex]);
var addedYValue = Convert.ToDouble(RenderableSeries.DataSeries.YValues[addedDataSeriesIndex]);
var prevXValue = Convert.ToDouble(RenderableSeries.DataSeries.XValues[prevDataSeriesIndex]);
var prevYValue = Convert.ToDouble(RenderableSeries.DataSeries.YValues[prevDataSeriesIndex]);
// Update last point in PointSeries using linear interpolation
// this PointSeries will be drawn in current frame
pointSeries.XValues[addedPointSeriesIndex] = prevXValue + currentProgress * (addedXValue - prevXValue);
pointSeries.YValues[addedPointSeriesIndex] = prevYValue + currentProgress * (addedYValue - prevYValue);
}
}
}
}
private WaterfallDataSeries3D <double> ResampleDataSeries(WaterfallDataSeries3D <double> dataSeries, double[] slicePositions)
{
var pointsPerSlice = dataSeries.XSize;
var sliceCount = dataSeries.ZSize;
var resamplerFactory = new PointResamplerFactory();
var resamplingParams = new ResamplingParams
{
IsSortedData = true,
IsEvenlySpacedData = true,
IsCategoryData = false,
ContainsNaN = false,
ZeroLineY = 0.0,
PointRange = new IndexRange(0, pointsPerSlice - 1),
VisibleRange = dataSeries.XRange,
ViewportWidth = Width > 0.0 ? (int)Width : 640,
ResamplingPrecision = 1
};
var resampledSeriesesArray = new IPointSeries[sliceCount];
var sliceAsXySeries = new XyDataSeries <double>(pointsPerSlice);
var sliceAsXySeriesYValues = sliceAsXySeries.YValues as ISciList <double>;
sliceAsXySeriesYValues.SetCount(pointsPerSlice);
var xValues = new double[pointsPerSlice];
var xRangeMin = (double)dataSeries.XRange.Min;
var stepX = dataSeries.StepX;
for (int i = 0; i < pointsPerSlice; i++)
{
xValues[i] = xRangeMin + stepX * i;
}
// Init the XY series by first slice of the waterfall data series
sliceAsXySeries.InsertRange(0, xValues, dataSeries.InternalArray[0]);
resampledSeriesesArray[0] = sliceAsXySeries.ToPointSeries(resamplingParams, ResamplingMode.Auto, resamplerFactory, null);
for (int i = 1; i < sliceCount; i++)
{
var curRow = dataSeries.GetRowAt(i);
Array.Copy(curRow, sliceAsXySeriesYValues.ItemsArray, pointsPerSlice);
resampledSeriesesArray[i] = sliceAsXySeries.ToPointSeries(resamplingParams, ResamplingMode.Auto, resamplerFactory, null);
}
var resampledPerPointsPerSlice = resampledSeriesesArray[0].Count;
var resampledDataSeries = new WaterfallDataSeries3D <double>(resampledPerPointsPerSlice, slicePositions);
resampledDataSeries.StartX = dataSeries.StartX;
resampledDataSeries.StepX = dataSeries.StepX;
for (int i = 0; i < sliceCount; i++)
{
resampledDataSeries.SetRowAt(i, resampledSeriesesArray[i].YValues.Items);
}
return(resampledDataSeries);
}
public SeriesElementViewModel(IPointSeries series, Int32 index)
{
_index = index;
_series = series;
Title = series.Label;
Color = series.Color.BrushFromString();
Symbol = series.Symbol;
Lines = series.Lines;
}
void UpdateScatterSeries(ScatterErrorSeries series, IPointSeries points)
{
UpdateXySeries(series, points);
series.ErrorBarColor = points.Color.OxyColorFromString();
series.MarkerType = (MarkerType)((int)points.Symbol);
series.MarkerFill = series.ErrorBarColor;
series.MarkerSize = 3.0;
series.MarkerStroke = series.ErrorBarColor;
series.MarkerStrokeThickness = 1.0;
}
protected void UpdateLineSeries(LineSeries series, IPointSeries points)
{
UpdateXySeries(series, points);
series.StrokeThickness = points.Lines ? points.LineWidth : 0.0;
series.Color = points.Color.OxyColorFromString();
series.MarkerType = (MarkerType)((int)points.Symbol);
series.MarkerFill = series.Color;
series.MarkerSize = 3.0;
series.MarkerStroke = series.Color;
series.MarkerStrokeThickness = 1.0;
}
/// <summary>
/// Adds a new series to the plot. This function automatically
/// selects a new color for the series, such that no color
/// should be taken twice.
/// </summary>
/// <param name="series">The series to add.</param>
/// <param name="nameSeries">Should the series be named?</param>
/// <param name="colorSeries">Should the series be colored automatically?</param>
public void AddSeries(IPointSeries series, bool nameSeries = true, bool colorSeries = true)
{
if (nameSeries)
{
series.Label = "Series " + (points.Count + 1);
}
if (colorSeries)
{
series.Color = StandardColors[Count % StandardColors.Length];
}
points.Add(series);
}
public static void SetClipboard(IPointSeries ps)
{
try
{
Clipboard.Clear();
DataObject d = new DataObject();
d.SetData(ClipboardFormat, ps);
d.SetData(DataFormats.CommaSeparatedValue, ps.ToString());
Clipboard.SetDataObject(d);
}
catch (Exception e)
{
Trace.WriteLine("Unable to set clipboard with Point Series: " + e.Message);
}
}
public void TestGetSetControlPoints()
{
ColorPalette ut = new ColorPalette(_fixture.GreyColors);
IPointSeries p = ut.GetControlPoints(ColorChannel.Blue);
Assert.NotNull(p);
Assert.Equal(2, p.Count);
PointSeries ps = new PointSeries(p);
ps.Add(new Point(128.0, 0.0));
ut.UpdateControlPoints(ColorChannel.Blue, ps);
Assert.Equal(0, ut.Colors[100].B);
Assert.Equal(255, ut.Colors[255].B);
IPointSeries p1 = ut.GetControlPoints(ColorChannel.Blue, 5e-3f);
Assert.Equal(3, p1.Count);
}
void UpdateSeries(ContourSeries series, IPointSeries points)
{
series.StrokeThickness = points.LineWidth;
series.Title = points.Label;
series.ContourColors = _plot.ColorPalette.GenerateOxyColors(_plot.Levels.Length);
if (_plot.ShowLevel)
{
series.FontSize = Double.NaN;
series.LabelBackground = OxyColor.FromArgb(220, 255, 255, 255);
}
else
{
series.FontSize = 0;
series.LabelBackground = OxyColors.Transparent;
}
series.CalculateContours();
}
private void DeleteSelection()
{
IPointSeries plp = PointSeries.Union(_controlPoints.EndPoints,
PointSeries.Difference(_controlPoints, _adorner.SelectedPoints));
UndoRedo.PushUndo(new UndoObject(
"delete " + Channel.ToString() + " point deletion.",
new UndoContext(new PointSeries(_controlPoints), new PointSeries(plp)),
(uc) => { Palette.UpdateControlPoints(Channel, uc[0] as PointSeries);
InvalidateVisual();
return(uc); },
(rc) =>
{
Palette.UpdateControlPoints(Channel, rc[1] as PointSeries);
InvalidateVisual();
}));
Palette.UpdateControlPoints(Channel, plp);
_controlPoints = Palette.GetControlPoints(Channel);
_adorner.ClearSelection();
InvalidateVisual();
}
// Cubic Spline interpolation: http://www.codeproject.com/Articles/560163/Csharp-Cubic-Spline-Interpolation
private IList <Point> ComputeSplineSeries(IPointSeries inputPointSeries, bool isSplineEnabled, int upsampleBy)
{
IList <Point> result = null;
if (!isSplineEnabled)
{
// No spline, just return points. Note: for large datasets, even the copy here causes performance problems!
result = new List <Point>(inputPointSeries.Count);
for (int i = 0; i < inputPointSeries.Count; i++)
{
result.Add(new Point(inputPointSeries.XValues[i], inputPointSeries.YValues[i]));
}
return(result);
}
// Spline enabled
int n = inputPointSeries.Count * upsampleBy;
var x = inputPointSeries.XValues.ToArray();
var y = inputPointSeries.YValues.ToArray();
double[] xs = new double[n];
double stepSize = (x[x.Length - 1] - x[0]) / (n - 1);
for (int i = 0; i < n; i++)
{
xs[i] = x[0] + i * stepSize;
}
var cubicSpline = new CubicSpline();
double[] ys = cubicSpline.FitAndEval(x, y, xs);
result = new List <Point>(n);
for (int i = 0; i < xs.Length; i++)
{
result.Add(new Point(xs[i], ys[i]));
}
return(result);
}
/// <summary>
/// Adds a new series to the plot. This function automatically
/// selects a new color for the series, such that no color
/// should be taken twice.
/// </summary>
/// <param name="series">The series to add.</param>
/// <param name="nameSeries">Should the series be named?</param>
/// <param name="colorSeries">Should the series be colored automatically?</param>
public void AddSeries(IPointSeries series, bool nameSeries = true, bool colorSeries = true)
{
if(nameSeries)
series.Label = "Series " + (points.Count + 1);
if(colorSeries)
series.Color = StandardColors[Count % StandardColors.Length];
points.Add(series);
}
protected void UpdateXySeries(XYAxisSeries series, IPointSeries points)
{
series.Title = points.Label;
}
