void TransformToScreenCo(ChartTransform.ChartCartesianTransformer cartesianTransformer)
{
int i = 0;
bool x_isInversed = cartesianTransformer.XAxis.IsInversed;
bool y_isInversed = cartesianTransformer.YAxis.IsInversed;
double xStart = cartesianTransformer.XAxis.VisibleRange.Start;
double xEnd = cartesianTransformer.XAxis.VisibleRange.End;
double yStart = cartesianTransformer.YAxis.VisibleRange.Start;
double yEnd = cartesianTransformer.YAxis.VisibleRange.End;
double xDelta = x_isInversed ? xStart - xEnd : xEnd - xStart;
double yDelta = y_isInversed ? yStart - yEnd : yEnd - yStart;
double width = cartesianTransformer.XAxis.RenderedRect.Width;
double height = cartesianTransformer.YAxis.RenderedRect.Height;
availableSize = new Size(width, height);
double xTolerance = Math.Abs((xDelta * 1) / availableSize.Width);
double yTolerance = Math.Abs((yDelta * 1) / availableSize.Height);
double left = cartesianTransformer.XAxis.RenderedRect.Left - fastSeries.Area.SeriesClipRect.Left;
double top = cartesianTransformer.YAxis.RenderedRect.Top - fastSeries.Area.SeriesClipRect.Top;
int count = (int)(Math.Ceiling(xEnd));
int start = (int)(Math.Floor(xStart));
if (x_isInversed)
{
double temp = xStart;
xStart = xEnd;
xEnd = temp;
}
if (y_isInversed)
{
double temp = yStart;
yStart = yEnd;
yEnd = temp;
}
if (RenderingMode == RenderingMode.Default)
{
Points = new PointCollection();
double xValue = 0;
double yValue = 0;
double prevXValue = 0;
double prevYValue = 0;
if (fastSeries.IsIndexed)
{
int length = Length - 1;
start = start > length ? start : length;
start = start < 0 ? 0 : start;
count = count > yChartVals.Count ? yChartVals.Count : count;
for (i = start; i <= count; i++)
{
double xVal = 0;
double yVal = 0;
if (i >= 0 && i < yChartVals.Count)
{
xVal = xChartVals[i];
yVal = yChartVals[i];
}
else
{
continue;
}
if (Math.Abs(prevXValue - i) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
if (xVal <= xEnd && xVal >= xStart)
{
xValue = left + (availableSize.Width * ((i - xStart) / xDelta));
yValue = top + (availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
Points.Add(new Point(xValue, yValue));
}
else if (xVal < xStart && i + 1 < yChartVals.Count)
{
double y = ChartMath.GetInterpolarationPoint(xChartVals[i], xChartVals[i + 1], yVal, yChartVals[i + 1], xStart);
xValue = left;
yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
Points.Add(new Point(xValue, yValue));
}
else if (xVal > xEnd && i - 1 > 0)
{
double y = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yVal, xEnd);
xValue = left + availableSize.Width;
yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
Points.Add(new Point(xValue, yValue));
}
prevXValue = i;
prevYValue = yVal;
}
}
}
else
{
int startIndex = 0;
for (i = Length - 1; i < xChartVals.Count; i++)
{
double xVal = xChartVals[i];
double yVal = yChartVals[i];
if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
if ((xVal <= xEnd) && (xVal >= xStart))
{
xValue = left + (availableSize.Width * ((xVal - xStart) / xDelta));
yValue = top + (availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
Points.Add(new Point(xValue, yValue));
}
else if (xVal < xStart)
{
startIndex = i;
}
else if (xVal > xEnd)
{
if (i - 1 > -1)
{
double y = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yVal, xEnd);
xValue = left + availableSize.Width;
yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
Points.Add(new Point(xValue, yValue));
break;
}
}
}
prevXValue = xVal;
prevYValue = yVal;
}
if (startIndex > 0)
{
if (startIndex + 1 < xChartVals.Count)
{
double y = ChartMath.GetInterpolarationPoint(xChartVals[startIndex], xChartVals[startIndex + 1], yChartVals[startIndex], yChartVals[startIndex + 1], xStart);
xValue = left;
yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
Points.Insert(0, new Point(xValue, yValue));
}
}
}
}
else
{
xValues.Clear();
yValues.Clear();
double prevXValue = 0;
double prevYValue = 0;
float xValue = 0;
float yValue = 0;
if (fastSeries.IsIndexed)
{
prevXValue = 1;
for (i = start; i <= count; i++)
{
double yVal = yChartVals[i];
if (Math.Abs(prevXValue - i) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
xValues.Add(xValue);
yValues.Add(yValue);
prevXValue = i;
prevYValue = yVal;
}
}
if (start > 0)
{
i = start - 1;
double yVal = yChartVals[i];
xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
xValues.Insert(0, xValue);
yValues.Insert(0, yValue);
}
if (count < yChartVals.Count - 1)
{
i = count + 1;
double yVal = yChartVals[i];
xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
xValues.Add(xValue);
yValues.Add(yValue);
}
}
else
{
int startIndex = 0;
for (i = Length - 1; i < xChartVals.Count; i++)
{
double xVal = xChartVals[i];
double yVal = yChartVals[i];
if ((xVal <= count) && (xVal >= start))
{
if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
xValue = (float)(left + availableSize.Width * ((xVal - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
xValues.Add(xValue);
yValues.Add(yValue);
prevXValue = xVal;
prevYValue = yVal;
}
}
else if (xVal < start)
{
startIndex = i;
}
else if (xVal > count)
{
xValue = (float)(left + availableSize.Width * ((xVal - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
xValues.Add(xValue);
yValues.Add(yValue);
break;
}
}
if (startIndex > 0)
{
xValue = (float)(left + availableSize.Width * ((xChartVals[startIndex] - xStart) / xDelta));
yValue = (float)(top + availableSize.Height * (1 - ((yChartVals[startIndex] - yStart) / yDelta)));
xValues.Insert(0, xValue);
yValues.Insert(0, yValue);
}
}
}
}
private void TransformToScreenCoVertical()
{
Points = new PointCollection();
double prevXValue = 0;
double prevYValue = 0;
int i = 0;
double yCoefficient = 0;
var numericalAxis = fastSeries.ActualYAxis as NumericalAxis;
bool isScaleBreak = numericalAxis != null && numericalAxis.AxisRanges != null && numericalAxis.AxisRanges.Count > 0;
xValues = (Series.ActualXValues is List <double> && !Series.IsIndexed) ? Series.ActualXValues as List <double> : Series.GetXValues();
var isGrouping = (fastSeries.ActualXAxis is CategoryAxis) ? (fastSeries.ActualXAxis as CategoryAxis).IsIndexed : true;
int startIndex = 0;
prevXValue = fastSeries.IsIndexed ? 1 : xChartVals[0];
prevYValue = yChartVals[0];
int cnt = xChartVals.Count - 1;
if (fastSeries.isLinearData)
{
for (i = 1; i < cnt; i++)
{
double xVal = xChartVals[i];
double yVal = yChartVals[i];
if ((xVal <= xEnd) && (xVal >= xStart))
{
if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
prevXValue = xVal;
prevYValue = yVal;
}
}
else if (xVal < xStart)
{
if (x_isInversed)
{
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
}
else
{
startIndex = i;
}
}
else if (xVal > xEnd)
{
double yValue = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yChartVals[i], xEnd);
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yValue) : 1 - ((yEnd - yValue) / yDelta));
Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset)));
break;
}
}
}
else
{
for (i = 1; i < cnt; i++)
{
double xVal = xChartVals[i];
double yVal = yChartVals[i];
if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
{
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
prevXValue = xVal;
prevYValue = yVal;
}
}
}
if (startIndex > 0)
{
double yValue = ChartMath.GetInterpolarationPoint(xChartVals[startIndex], xChartVals[startIndex + 1], yChartVals[startIndex], yChartVals[startIndex + 1], xStart);
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yValue) : 1 - ((yEnd - yValue) / yDelta));
Points.Insert(0, new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xStart) / xDelta))));
}
else
{
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yChartVals[startIndex]) : 1 - ((yEnd - yChartVals[startIndex]) / yDelta));
Points.Insert(0, new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xChartVals[startIndex]) / xDelta))));
}
if (i == cnt)
{
yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yChartVals[cnt]) : 1 - ((yEnd - yChartVals[cnt]) / yDelta));
Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xChartVals[cnt]) / xDelta))));
}
}
