private void InsertDataPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index)
{
double x1Val = 0, x2Val = 0, y2Val = 0, y1Val = 0;
GetXYPoints(index, out x1Val, out x2Val, out y1Val, out y2Val);
Point tlpoint = cartesianTransformer.TransformToVisible(x1Val, y1Val);
Point rbpoint = cartesianTransformer.TransformToVisible(x2Val, y2Val);
x1Values.Insert(0, ((float)tlpoint.X));
x2Values.Insert(0, ((float)rbpoint.X));
y1Values.Insert(0, ((float)tlpoint.Y));
y2Values.Insert(0, ((float)rbpoint.Y));
actualIndexes.Insert(0, index);
}
private void GetHiLoPoints(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index,
out Point hipoint, out Point lopoint)
{
if (fastHiloSeries.IsIndexed)
{
hipoint = cartesianTransformer.TransformToVisible(index, yHiChartVals[index]);
lopoint = cartesianTransformer.TransformToVisible(index, yLoChartVals[index]);
}
else
{
hipoint = cartesianTransformer.TransformToVisible(xChartVals[index], yHiChartVals[index]);
lopoint = cartesianTransformer.TransformToVisible(xChartVals[index], yLoChartVals[index]);
}
}
private void CalculatePonts(ChartTransform.ChartCartesianTransformer cartesianTransformer)
{
int cnt = xChartVals.Count - 1;
Points = new PointCollection();
for (int i = 0; i <= cnt; i++)
{
double xVal = xChartVals[i];
double yVal = yChartVals[i];
Point point = cartesianTransformer.TransformToVisible(xVal, yVal);
Points.Add(point);
}
}
private void InsertDataPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index)
{
double xValue, yValue;
GetXYValue(index, out xValue, out yValue);
Point point = cartesianTransformer.TransformToVisible(xValue, yValue);
if (!fastSeries.IsActualTransposed)
{
xValues.Insert(0, point.X);
yValues.Insert(0, point.Y);
}
else
{
xValues.Insert(0, point.Y);
yValues.Insert(0, point.X);
}
}
private void InsertDataPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer,
Thickness areaBorderThickness, int index)
{
double xValue, yValue;
GetXYValue(index, out xValue, out yValue);
Point point = cartesianTransformer.TransformToVisible(xValue, yValue);
if (!fastSeries.IsTransposed)
{
xValues.Insert(0, (point.X - areaBorderThickness.Left));
yValues.Insert(0, (point.Y - areaBorderThickness.Top));
}
else
{
xValues.Insert(0, (point.Y - areaBorderThickness.Left));
yValues.Insert(0, (point.X - areaBorderThickness.Top));
}
}
/// <summary>
/// This method is used to gets the selected data point segment pixel positions
/// </summary>
internal void GenerateStackingColumnPixels()
{
WriteableBitmap bmp = Area.fastRenderSurface;
ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer(
new Size(
Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height),
true) as ChartTransform.ChartCartesianTransformer;
bool x_isInversed = cartesianTransformer.XAxis.IsInversed;
bool y_isInversed = cartesianTransformer.YAxis.IsInversed;
double x1ChartVal, x2ChartVal, y1ChartVal, y2ChartVal;
int i = dataPoint.Index;
DoubleRange sbsInfo = this.GetSideBySideInfo(this);
List <double> xValues = (ActualXValues is List <double>) ? ActualXValues as List <double> : GetXValues();
if (!this.IsIndexed)
{
x1ChartVal = xValues[i] + sbsInfo.Start;
x2ChartVal = xValues[i] + sbsInfo.End;
y1ChartVal = YRangeEndValues[i];
y2ChartVal = YRangeStartValues[i];
}
else
{
x1ChartVal = i + sbsInfo.Start;
x2ChartVal = i + sbsInfo.End;
y1ChartVal = YRangeEndValues[i];
y2ChartVal = YRangeStartValues[i];
}
double x1Val = x_isInversed
? x2ChartVal
: x1ChartVal;
double x2Val = x_isInversed
? x1ChartVal
: x2ChartVal;
double y2Val = y_isInversed
? y1ChartVal
: y2ChartVal;
double y1Val = y_isInversed
? y2ChartVal
: y1ChartVal;
Point tlpoint = cartesianTransformer.TransformToVisible(x1Val, y1Val);
Point rbpoint = cartesianTransformer.TransformToVisible(x2Val, y2Val);
float x1Value = ((float)tlpoint.X);
float x2Value = ((float)rbpoint.X);
float y1Value = ((float)tlpoint.Y);
float y2Value = ((float)rbpoint.Y);
float x1 = 0;
float x2 = 0;
float y1 = 0;
float y2 = 0;
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
selectedSegmentPixels.Clear();
x1 = x1Value;
x2 = x2Value;
y1 = y1ChartVal > 0 ? y1Value : y2Value;
y2 = y1ChartVal > 0 ? y2Value : y1Value;
var spacingSegment = this as ISegmentSpacing;
if (spacingSegment != null)
{
double spacing = spacingSegment.SegmentSpacing;
if (spacing > 0 && spacing <= 1)
{
double leftpos = spacingSegment.CalculateSegmentSpacing(spacing, x2, x1);
double rightpos = spacingSegment.CalculateSegmentSpacing(spacing, x1, x2);
x1 = (float)(leftpos);
x2 = (float)(rightpos);
}
}
if (y1 < y2)
{
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)(x1), (int)y1, (int)x2, (int)y2, selectedSegmentPixels);
}
else
{
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)(x1), (int)y2, (int)x2, (int)y1, selectedSegmentPixels);
}
}
internal override void GeneratePixels()
{
WriteableBitmap bmp = Area.fastRenderSurface;
ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer(new Size(Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height), true) as ChartTransform.ChartCartesianTransformer;
double xStart, xEnd, yStart, yEnd, xSize, ySize, xOffset, yOffset;
bool x_isInversed = cartesianTransformer.XAxis.IsInversed;
bool y_isInversed = cartesianTransformer.YAxis.IsInversed;
xStart = cartesianTransformer.XAxis.VisibleRange.Start;
xEnd = cartesianTransformer.XAxis.VisibleRange.End;
yStart = cartesianTransformer.YAxis.VisibleRange.Start;
yEnd = cartesianTransformer.YAxis.VisibleRange.End;
if (IsActualTransposed)
{
ySize = cartesianTransformer.YAxis.RenderedRect.Width;
xSize = cartesianTransformer.XAxis.RenderedRect.Height;
yOffset = cartesianTransformer.YAxis.RenderedRect.Left - Area.SeriesClipRect.Left;
xOffset = cartesianTransformer.XAxis.RenderedRect.Top - Area.SeriesClipRect.Top;
}
else
{
ySize = cartesianTransformer.YAxis.RenderedRect.Height;
xSize = cartesianTransformer.XAxis.RenderedRect.Width;
yOffset = cartesianTransformer.YAxis.RenderedRect.Top - Area.SeriesClipRect.Top;
xOffset = cartesianTransformer.XAxis.RenderedRect.Left - Area.SeriesClipRect.Left;
}
if (x_isInversed)
{
double temp = xStart;
xStart = xEnd;
xEnd = temp;
}
if (y_isInversed)
{
double temp = yStart;
yStart = yEnd;
yEnd = temp;
}
DoubleRange sbsInfo = GetSideBySideInfo(this);
double x1Val, x2Val, openVal, closeVal, yHiVal, yLoVal, yHiVal1, yLoVal1;
double sbsCenter = sbsInfo.Median;
double sbsStart = sbsInfo.Start;
double sbsEnd = sbsInfo.End;
double tempOpenVal;
double xChartValue = dataPoint.XData;
double openChartValue = dataPoint.Open;
double closeChartValue = dataPoint.Close;
double highChartValue = dataPoint.High;
double lowChartValue = dataPoint.Low;
int i = dataPoint.Index;
float x1Value, x2Value, xValue, openValue, closeValue, highValue, lowValue, highValue1, lowValue1;
var alignedValues = Segments[0].AlignHiLoSegment(openChartValue, closeChartValue, highChartValue, lowChartValue);
highChartValue = alignedValues[0];
lowChartValue = alignedValues[1];
isFill = openChartValue > closeChartValue;
if (IsIndexed)
{
if (!IsActualTransposed)
{
x1Val = !x_isInversed ? (sbsStart + i) : (sbsEnd + i);
x2Val = !x_isInversed ? (sbsEnd + i) : (sbsStart + i);
openVal = y_isInversed
? closeChartValue
: openChartValue;
closeVal = y_isInversed
? openChartValue
: closeChartValue;
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highChartValue;
yLoVal = lowChartValue;
if (openChartValue > closeChartValue)
{
yHiVal1 = openChartValue;
yLoVal1 = closeChartValue;
}
else
{
yHiVal1 = closeChartValue;
yLoVal1 = openChartValue;
}
Point blpoint = cartesianTransformer.TransformToVisible(x1Val, openVal);
Point trpoint = cartesianTransformer.TransformToVisible(x2Val, closeVal);
Point point1 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal);
Point point2 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal);
Point point3 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal1);
Point point4 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal1);
xValue = (float)point1.X;
x1Value = (float)blpoint.X;
x2Value = (float)trpoint.X;
openValue = (float)blpoint.Y;
closeValue = (float)trpoint.Y;
highValue = (float)point1.Y;
lowValue = (float)point2.Y;
highValue1 = (float)point3.Y;
lowValue1 = (float)point4.Y;
}
else
{
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1;
x1Val = !x_isInversed ? (sbsStart + i) : (sbsEnd + i);
x2Val = !x_isInversed ? (sbsEnd + i) : (sbsStart + i);
openVal = y_isInversed
? closeChartValue
: openChartValue;
closeVal = y_isInversed
? openChartValue
: closeChartValue;
x1Val = xBase == 1 ? x1Val : Math.Log(x1Val, xBase);
x2Val = xBase == 1 ? x2Val : Math.Log(x2Val, xBase);
openVal = yBase == 1 ? openVal : Math.Log(openVal, yBase);
closeVal = yBase == 1 ? closeVal : Math.Log(closeVal, yBase);
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highChartValue;
yLoVal = lowChartValue;
if (openChartValue > closeChartValue)
{
yHiVal1 = openChartValue;
yLoVal1 = closeChartValue;
}
else
{
yHiVal1 = closeChartValue;
yLoVal1 = openChartValue;
}
Point point1 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal);
Point point2 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal);
Point point3 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal1);
Point point4 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal1);
xValue = (float)point1.Y;
x1Value = (float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val));
x2Value = (float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val));
openValue = (float)(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(openVal)));
closeValue = (float)(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(closeVal)));
highValue = (float)point1.X;
lowValue = (float)point2.X;
highValue1 = (float)point3.X;
lowValue1 = (float)point4.X;
}
}
else
{
if (!IsActualTransposed)
{
x1Val = x_isInversed ? (xChartValue + sbsEnd) : (xChartValue + sbsStart);
x2Val = x_isInversed ? (xChartValue + sbsStart) : (xChartValue + sbsEnd);
openVal = y_isInversed
? closeChartValue
: openChartValue;
closeVal = y_isInversed
? openChartValue
: closeChartValue;
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highChartValue;
yLoVal = lowChartValue;
if (openChartValue > closeChartValue)
{
yHiVal1 = openChartValue;
yLoVal1 = closeChartValue;
}
else
{
yHiVal1 = closeChartValue;
yLoVal1 = openChartValue;
}
Point blpoint = cartesianTransformer.TransformToVisible(x1Val, openVal);
Point trpoint = cartesianTransformer.TransformToVisible(x2Val, closeVal);
Point point1 = cartesianTransformer.TransformToVisible(xChartValue + sbsCenter, yHiVal);
Point point2 = cartesianTransformer.TransformToVisible(xChartValue + sbsCenter, yLoVal);
Point point3 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal1);
Point point4 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal1);
xValue = (float)point1.X;
x1Value = (float)blpoint.X;
x2Value = (float)trpoint.X;
openValue = (float)blpoint.Y;
closeValue = (float)trpoint.Y;
highValue = (float)point1.Y;
lowValue = (float)point2.Y;
highValue1 = (float)point3.Y;
lowValue1 = (float)point4.Y;
}
else
{
double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1;
double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1;
x1Val = x_isInversed ? (xChartValue + sbsEnd) : (xChartValue + sbsStart);
x2Val = x_isInversed ? (xChartValue + sbsStart) : (xChartValue + sbsEnd);
openVal = y_isInversed
? closeChartValue
: openChartValue;
closeVal = y_isInversed
? openChartValue
: closeChartValue;
x1Val = xBase == 1 ? x1Val : Math.Log(x1Val, xBase);
x2Val = xBase == 1 ? x2Val : Math.Log(x2Val, xBase);
openVal = yBase == 1 ? openVal : Math.Log(openVal, yBase);
closeVal = yBase == 1 ? closeVal : Math.Log(closeVal, yBase);
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highChartValue;
yLoVal = lowChartValue;
if (openChartValue > closeChartValue)
{
yHiVal1 = openChartValue;
yLoVal1 = closeChartValue;
}
else
{
yHiVal1 = closeChartValue;
yLoVal1 = openChartValue;
}
Point point1 = cartesianTransformer.TransformToVisible(xChartValue + sbsCenter, yHiVal);
Point point2 = cartesianTransformer.TransformToVisible(xChartValue + sbsCenter, yLoVal);
Point point3 = cartesianTransformer.TransformToVisible(i + sbsCenter, yHiVal1);
Point point4 = cartesianTransformer.TransformToVisible(i + sbsCenter, yLoVal1);
xValue = (float)point1.Y;
x1Value = (float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val));
x2Value = (float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val));
openValue = (float)(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(openVal)));
closeValue = (float)(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(closeVal)));
highValue = (float)point1.X;
lowValue = (float)point2.X;
highValue1 = (float)point3.X;
lowValue1 = (float)point4.X;
}
}
double spacing = (this as ISegmentSpacing).SegmentSpacing;
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
int leftThickness = (int)StrokeThickness / 2;
int rightThickness = (int)(StrokeThickness % 2 == 0.0
? (StrokeThickness / 2) : (StrokeThickness / 2) + 1);
float x, x1, x2, open, close, high, low, high1, low1;
x = xValue;
x1 = x1Value;
x2 = x2Value;
open = openValue;
close = closeValue;
high = y_isInversed ? lowValue : highValue;
low = y_isInversed ? highValue : lowValue;
high1 = y_isInversed ? lowValue1 : highValue1;
low1 = y_isInversed ? highValue1 : lowValue1;
var leftOffset = x - leftThickness;
var rightOffset = x + rightThickness;
if (spacing > 0 && spacing <= 1)
{
double leftpos = (this as ISegmentSpacing).CalculateSegmentSpacing(spacing, x2, x1);
double rightpos = (this as ISegmentSpacing).CalculateSegmentSpacing(spacing, x1, x2);
x1 = (float)(leftpos);
x2 = (float)(rightpos);
}
selectedSegmentPixels.Clear();
selectedBorderPixels.Clear();
close = open == close ? close + 1 : close;
if (!IsActualTransposed)
{
if (this.ComparisonMode != FinancialPrice.None)
{
selectedBorderPixels = bmp.GetDrawRectangle(width, height, (int)(x1), (int)open, (int)x2, (int)close, selectedBorderPixels);
selectedBorderPixels = bmp.GetRectangle(width, height, (int)leftOffset, (int)high, (int)rightOffset, (int)high1, selectedBorderPixels);
selectedBorderPixels = bmp.GetRectangle(width, height, (int)leftOffset, (int)low1, (int)rightOffset, (int)low, selectedBorderPixels);
}
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)(x1), (int)open, (int)x2, (int)close, selectedSegmentPixels);
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)leftOffset, (int)high, (int)rightOffset, (int)high1, selectedSegmentPixels);
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)leftOffset, (int)low1, (int)rightOffset, (int)low, selectedSegmentPixels);
}
else
{
if (this.ComparisonMode != FinancialPrice.None)
{
selectedBorderPixels = bmp.GetDrawRectangle((int)width, (int)height, (int)(width - close), (int)(height - x2),
(int)(width - open), (int)(height - x1), selectedBorderPixels);
selectedBorderPixels = bmp.GetRectangle(width, height, (int)high, (int)(leftOffset), (int)high1, (int)(rightOffset), selectedBorderPixels);
selectedBorderPixels = bmp.GetRectangle(width, height, (int)low1, (int)(leftOffset), (int)low, (int)(rightOffset), selectedBorderPixels);
}
selectedSegmentPixels = bmp.GetRectangle((int)width, (int)height, (int)(width - close), (int)(height - x2),
(int)(width - open), (int)(height - x1), selectedSegmentPixels);
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)high, (int)(leftOffset), (int)high1, (int)(rightOffset), selectedSegmentPixels);
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)low1, (int)(leftOffset), (int)low, (int)(rightOffset), selectedSegmentPixels);
}
}
/// <summary>
/// This method used to get the chart data at an index.
/// </summary>
/// <returns></returns>
internal override void GeneratePixels()
{
WriteableBitmap bmp = Area.fastRenderSurface;
ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer(new Size(Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height),
true) as ChartTransform.ChartCartesianTransformer;
double xChartValue = dataPoint.XData;
double yChartValue = dataPoint.YData;
int i = dataPoint.Index;
double xValue, yValue;
if (IsIndexed)
{
bool isGrouped = ActualXAxis is CategoryAxis && !((ActualXAxis as CategoryAxis).IsIndexed);
if (!IsActualTransposed)
{
double xVal = (isGrouped) ? xChartValue : i;
double yVal = yChartValue;
Point point = cartesianTransformer.TransformToVisible(xVal, yVal);
xValue = point.X;
yValue = point.Y;
}
else
{
double xVal = (isGrouped) ? xChartValue : i;
double yVal = yChartValue;
Point point = cartesianTransformer.TransformToVisible(xVal, yVal);
xValue = point.Y;
yValue = point.X;
}
}
else
{
if (!IsActualTransposed)
{
double xVal = xChartValue;
double yVal = yChartValue;
Point point = cartesianTransformer.TransformToVisible(xVal, yVal);
xValue = point.X;
yValue = point.Y;
}
else
{
double xVal = xChartValue;
double yVal = yChartValue;
Point point = cartesianTransformer.TransformToVisible(xVal, yVal);
xValue = point.Y;
yValue = point.X;
}
}
double xr = ScatterHeight, yr = ScatterWidth;
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
selectedSegmentPixels.Clear();
if (IsActualTransposed)
{
if (yValue > -1)
{
selectedSegmentPixels = bmp.GetEllipseCentered(height, width, (int)yValue, (int)xValue, (int)xr, (int)yr, selectedSegmentPixels);
}
}
else
{
if (yValue > -1)
{
selectedSegmentPixels = bmp.GetEllipseCentered(height, width, (int)xValue, (int)yValue, (int)xr, (int)yr, selectedSegmentPixels);
}
}
}
/// <summary>
/// This method used to gets the segment pixel positions at data point.
/// </summary>
/// <param name="mousePos"></param>
/// <returns></returns>
internal override void GeneratePixels()
{
WriteableBitmap bmp = Area.fastRenderSurface;
ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer(new Size(Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height),
true) as ChartTransform.ChartCartesianTransformer;
bool y_isInversed = cartesianTransformer.YAxis.IsInversed;
double xChartValue = dataPoint.XData;
double yHiChartValue = dataPoint.High;
double yLoChartValue = dataPoint.Low;
int i = dataPoint.Index;
float xValue, yHiValue, yLoValue;
if (IsIndexed)
{
if (!IsActualTransposed)
{
Point hipoint = cartesianTransformer.TransformToVisible(i, yHiChartValue);
Point lopoint = cartesianTransformer.TransformToVisible(i, yLoChartValue);
xValue = (float)hipoint.X;
yHiValue = (float)hipoint.Y;
yLoValue = (float)lopoint.Y;
}
else
{
Point hipoint = cartesianTransformer.TransformToVisible(i, yHiChartValue);
Point lopoint = cartesianTransformer.TransformToVisible(i, yLoChartValue);
xValue = (float)hipoint.Y;
yHiValue = (float)hipoint.X;
yLoValue = (float)lopoint.X;
}
}
else
{
if (!IsActualTransposed)
{
Point hipoint = cartesianTransformer.TransformToVisible(xChartValue, yHiChartValue);
Point lopoint = cartesianTransformer.TransformToVisible(xChartValue, yLoChartValue);
xValue = (float)hipoint.X;
yHiValue = (float)hipoint.Y;
yLoValue = (float)lopoint.Y;
}
else
{
Point hipoint = cartesianTransformer.TransformToVisible(xChartValue, yHiChartValue);
Point lopoint = cartesianTransformer.TransformToVisible(xChartValue, yLoChartValue);
xValue = (float)hipoint.Y;
yHiValue = (float)hipoint.X;
yLoValue = (float)lopoint.X;
}
}
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
int leftThickness = (int)StrokeThickness / 2;
int rightThickness = (int)(StrokeThickness % 2 == 0
? (StrokeThickness / 2) : StrokeThickness / 2 + 1);
float xStart = xValue;
float yStart = y_isInversed ? yLoValue : yHiValue;
float xEnd = xValue;
float yEnd = y_isInversed ? yHiValue : yLoValue;
var leftOffset = xStart - leftThickness;
selectedSegmentPixels.Clear();
if (!IsActualTransposed)
{
var rightOffset = xStart + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)leftOffset, (int)yStart, (int)rightOffset, (int)yEnd, selectedSegmentPixels);
}
else
{
var rightOffset = (int)xEnd + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)yEnd, (int)leftOffset, (int)yStart, (int)rightOffset, selectedSegmentPixels);
}
}
private void GetPoints(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index,
out Point hiPoint, out Point loPoint, out Point startopenpoint,
out Point endopenpoint, out Point startclosepoint, out Point endclosepoint,
double highValues, double lowValues)
{
if (fastHiLoOpenCloseSeries.IsIndexed)
{
hiPoint = cartesianTransformer.TransformToVisible(index + center, highValues);
loPoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, lowValues);
startopenpoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, yOpenChartVals[index]);
endopenpoint = cartesianTransformer.TransformToVisible(xChartVals[index] + Left, yOpenChartVals[index]);
startclosepoint = cartesianTransformer.TransformToVisible(index + center, yCloseChartVals[index]);
endclosepoint = cartesianTransformer.TransformToVisible(index + Right, yCloseChartVals[index]);
}
else
{
hiPoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, highValues);
loPoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, lowValues);
startopenpoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, yOpenChartVals[index]);
endopenpoint = cartesianTransformer.TransformToVisible(xChartVals[index] + Left, yOpenChartVals[index]);
startclosepoint = cartesianTransformer.TransformToVisible(xChartVals[index] + center, yCloseChartVals[index]);
endclosepoint = cartesianTransformer.TransformToVisible(xChartVals[index] + Right, yCloseChartVals[index]);
}
}
/// <summary>
/// Calculates the transform points.
/// </summary>
/// <param name="cartesianTransformer">The transformer to get the required points from chart values.</param>
private void CalculatePoints(ChartTransform.ChartCartesianTransformer cartesianTransformer)
{
int startIndex = 0;
int endIndex = 0;
ChartAxis xAxis = this.Series.ActualXAxis;
var logarithmicAxis = xAxis as LogarithmicAxis;
double rangeStart = logarithmicAxis != null?Math.Pow(logarithmicAxis.LogarithmicBase, xAxis.VisibleRange.Start) : xAxis.VisibleRange.Start;
double rangeEnd = logarithmicAxis != null?Math.Pow(logarithmicAxis.LogarithmicBase, xAxis.VisibleRange.End) : xAxis.VisibleRange.End;
if (this.Series.IsIndexed)
{
var categoryXAxis = xAxis as CategoryAxis;
var isGrouping = categoryXAxis != null && categoryXAxis.IsIndexed;
int start = 0, end = 0;
var count = AreaValues.Count / 2;
if (!isGrouping)
{
start = 0;
end = count - 1;
}
else
{
start = (int)Math.Floor(xAxis.VisibleRange.Start);
end = (int)Math.Ceiling(xAxis.VisibleRange.End);
end = end > count - 1 ? count - 1 : end;
start = start < 0 ? 0 : start;
}
startIndex = start * 2;
for (int i = startIndex; i < AreaValues.Count; i += 2)
{
var convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
}
endIndex = end * 2 + 1;
for (int i = AreaValues.Count - 1; i >= 1; i -= 2)
{
var convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
}
// Join with the first point.
if (areaPoints.Count > 1)
{
areaPoints.Add(areaPoints[0]);
areaPoints.Add(areaPoints[1]);
}
}
else
{
areaPoints.Clear();
// The point addition goes in the logic bottom left, bottom right, top right and top left.
double xValue = 0d;
Point convertedPoint = new Point();
bool isFirstIndexSet = false;
// Setting lower points from left to right.
for (int i = 0; i < AreaValues.Count; i += 2)
{
xValue = AreaValues[i].X;
if (rangeStart <= xValue && xValue <= rangeEnd)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
}
else if (xValue < rangeStart)
{
isFirstIndexSet = true;
startIndex = i;
}
else if (xValue > rangeEnd)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
break;
}
}
if (isFirstIndexSet)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[startIndex].X, AreaValues[startIndex].Y);
areaPoints.Insert(0, (int)convertedPoint.Y);
areaPoints.Insert(0, (int)convertedPoint.X);
}
// Setting upper points from right to left of the polygon.
// The top right corner point index predefined.
int midIndex = areaPoints.Count;
endIndex = AreaValues.Count - 1;
isFirstIndexSet = false;
for (int i = AreaValues.Count - 1; i >= 1; i -= 2)
{
xValue = AreaValues[i].X;
if (rangeStart <= xValue && xValue <= rangeEnd)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
}
else if (xValue > rangeEnd)
{
isFirstIndexSet = true;
endIndex = i;
}
else if (xValue < rangeStart)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[i].X, AreaValues[i].Y);
areaPoints.Add((int)convertedPoint.X);
areaPoints.Add((int)convertedPoint.Y);
break;
}
}
if (midIndex < areaPoints.Count && isFirstIndexSet)
{
convertedPoint = cartesianTransformer.TransformToVisible(AreaValues[endIndex].X, AreaValues[endIndex].Y);
areaPoints.Insert(midIndex, (int)convertedPoint.Y);
areaPoints.Insert(midIndex, (int)convertedPoint.X);
}
// Join with the first point.
if (areaPoints.Count > 1)
{
areaPoints.Add(areaPoints[0]);
areaPoints.Add(areaPoints[1]);
}
}
}
/// <summary>
/// This method used to get the chart data at an index.
/// </summary>
/// <param name="mousePos"></param>
/// <returns></returns>
internal override void GeneratePixels()
{
WriteableBitmap bmp = Area.fastRenderSurface;
ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer(new Size(Area.SeriesClipRect.Width,
Area.SeriesClipRect.Height),
true) as ChartTransform.ChartCartesianTransformer;
bool x_isInversed = cartesianTransformer.XAxis.IsInversed;
bool y_isInversed = cartesianTransformer.YAxis.IsInversed;
DoubleRange sbsInfo = GetSideBySideInfo(this);
double center = sbsInfo.Median;
double Left = sbsInfo.Start;
double Right = sbsInfo.End;
double xChartValue = dataPoint.XData;
double yOpenChartValue = dataPoint.Open;
double yCloseChartValue = dataPoint.Close;
double yHighChartValue = dataPoint.High;
double yLowChartValue = dataPoint.Low;
int i = dataPoint.Index;
float xValue, yHiValue, yLoValue, yOpenStartValue, yOpenEndValue, yCloseValue, yCloseEndValue;
double spacing = (this as ISegmentSpacing).SegmentSpacing;
double leftpos = (this as ISegmentSpacing).CalculateSegmentSpacing(spacing, Right, Left);
double rightpos = (this as ISegmentSpacing).CalculateSegmentSpacing(spacing, Left, Right);
if (spacing > 0 && spacing <= 1)
{
Left = leftpos;
Right = rightpos;
}
double highValue = yHighChartValue;
double lowValue = yLowChartValue;
var alignedValues = Segments[0].AlignHiLoSegment(yOpenChartValue, yCloseChartValue, highValue, lowValue);
highValue = alignedValues[0];
lowValue = alignedValues[1];
if (IsIndexed)
{
Point hiPoint = cartesianTransformer.TransformToVisible(i + center, highValue);
Point loPoint = cartesianTransformer.TransformToVisible(xChartValue + center, lowValue);
Point startopenpoint = cartesianTransformer.TransformToVisible(xChartValue + center, yOpenChartValue);
Point endopenpoint = cartesianTransformer.TransformToVisible(xChartValue + Left, yOpenChartValue);
Point endclosepoint = cartesianTransformer.TransformToVisible(i + Right, yCloseChartValue);
if (!IsActualTransposed)
{
xValue = (float)hiPoint.X;
yHiValue = (float)hiPoint.Y;
yLoValue = (float)loPoint.Y;
yOpenStartValue = (float)startopenpoint.Y;
yOpenEndValue = (float)endopenpoint.X;
yCloseValue = (float)endclosepoint.Y;
yCloseEndValue = (float)endclosepoint.X;
}
else
{
xValue = (float)hiPoint.Y;
yHiValue = (float)hiPoint.X;
yLoValue = (float)loPoint.X;
yOpenStartValue = (float)startopenpoint.X;
yOpenEndValue = (float)endopenpoint.Y;
yCloseValue = (float)endclosepoint.X;
yCloseEndValue = (float)endclosepoint.Y;
}
}
else
{
Point hiPoint = cartesianTransformer.TransformToVisible(xChartValue + center, highValue);
Point loPoint = cartesianTransformer.TransformToVisible(xChartValue + center, lowValue);
Point startopenpoint = cartesianTransformer.TransformToVisible(xChartValue + center, yOpenChartValue);
Point endopenpoint = cartesianTransformer.TransformToVisible(xChartValue + Left, yOpenChartValue);
Point endclosepoint = cartesianTransformer.TransformToVisible(xChartValue + Right, yCloseChartValue);
if (!IsActualTransposed)
{
xValue = (float)hiPoint.X;
yHiValue = (float)hiPoint.Y;
yLoValue = (float)loPoint.Y;
yOpenStartValue = (float)startopenpoint.Y;
yOpenEndValue = (float)endopenpoint.X;
yCloseValue = (float)endclosepoint.Y;
yCloseEndValue = (float)endclosepoint.X;
}
else
{
xValue = (float)hiPoint.Y;
yHiValue = (float)hiPoint.X;
yLoValue = (float)loPoint.X;
yOpenStartValue = (float)startopenpoint.X;
yOpenEndValue = (float)endopenpoint.Y;
yCloseValue = (float)endclosepoint.X;
yCloseEndValue = (float)endclosepoint.Y;
}
}
int width = (int)Area.SeriesClipRect.Width;
int height = (int)Area.SeriesClipRect.Height;
int leftThickness = (int)StrokeThickness / 2;
int rightThickness = (int)(StrokeThickness % 2 == 0
? (StrokeThickness / 2) : StrokeThickness / 2 + 1);
selectedSegmentPixels.Clear();
float xStart = 0;
float yStart = 0;
float yEnd = 0;
float yOpen = 0;
float yOpenEnd = 0;
float yClose = 0;
float yCloseEnd = 0;
int leftOffset, rightOffset;
xStart = xValue;
yStart = y_isInversed ? yLoValue : yHiValue;
yEnd = y_isInversed ? yHiValue : yLoValue;
yOpen = x_isInversed ? yCloseValue : yOpenStartValue;
yOpenEnd = x_isInversed ? yCloseEndValue : yOpenEndValue;
yClose = x_isInversed ? yOpenStartValue : yCloseValue;
yCloseEnd = x_isInversed ? yOpenEndValue : yCloseEndValue;
if (!IsActualTransposed)
{
leftOffset = (int)xStart - leftThickness;
rightOffset = (int)xStart + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, leftOffset, (int)yStart, rightOffset, (int)yEnd, selectedSegmentPixels);
leftOffset = (int)yOpen - leftThickness;
rightOffset = (int)yOpen + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)yOpenEnd, leftOffset, (int)xStart - leftThickness, (int)rightOffset, selectedSegmentPixels);
leftOffset = (int)yClose - leftThickness;
rightOffset = (int)yClose + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)xStart + leftThickness, leftOffset, (int)yCloseEnd, (int)rightOffset, selectedSegmentPixels);
}
else
{
leftOffset = (int)xStart - leftThickness;
rightOffset = (int)xStart + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, (int)yEnd, (int)leftOffset, (int)yStart, (int)rightOffset, selectedSegmentPixels);
leftOffset = (int)yOpen - leftThickness;
rightOffset = (int)yOpen + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, leftOffset, (int)xStart + leftThickness, (int)rightOffset, (int)yOpenEnd, selectedSegmentPixels);
leftOffset = (int)yClose - leftThickness;
rightOffset = (int)yClose + rightThickness;
selectedSegmentPixels = bmp.GetRectangle(width, height, leftOffset, (int)yCloseEnd, (int)rightOffset, (int)xStart - leftThickness, selectedSegmentPixels);
}
}
private void InsertHorizontalPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index, IList <double> values)
{
double x1Val, x2Val, openVal, closeVal, yHiVal, yHiVal1, yLoVal, yLoVal1;
double sbsCenter = sbsInfo.Median;
double sbsStart = sbsInfo.Start;
double sbsEnd = sbsInfo.End;
double highValues = highChartVals[index];
double lowValues = lowChartVals[index];
double openValues = openChartVals[index];
double closeValues = closeChartVals[index];
double tempOpenVal;
bool bullBearFlag = false;
var alignedValues = AlignHiLoSegment(openChartVals[index], closeChartVals[index], highValues,
lowValues);
highValues = alignedValues[0];
lowValues = alignedValues[1];
GetPoints(index, out x1Val, out x2Val, sbsStart, sbsEnd);
openVal = y_isInversed
? closeChartVals[index]
: openChartVals[index];
closeVal = y_isInversed
? openChartVals[index]
: closeChartVals[index];
if (index == 0 || (Series as FastCandleBitmapSeries).ComparisonMode == FinancialPrice.None)
{
bullBearFlag = openValues < closeValues;
}
else
{
bullBearFlag = values[index] >= values[index - 1];
}
isBull.Insert(0, bullBearFlag);
isHollow.Insert(0, closeValues > openValues &&
!((Series as FastCandleBitmapSeries).ComparisonMode == FinancialPrice.None));
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highValues;
yLoVal = lowValues;
if (openValues > closeValues)
{
yHiVal1 = openValues;
yLoVal1 = closeValues;
}
else
{
yHiVal1 = closeValues;
yLoVal1 = openValues;
}
Point blpoint = cartesianTransformer.TransformToVisible(x1Val, openVal);
Point trpoint = cartesianTransformer.TransformToVisible(x2Val, closeVal);
Point point1, point2, point3, point4;
if (fastCandleBitmapSeries.IsIndexed)
{
point1 = cartesianTransformer.TransformToVisible(index + sbsCenter, yHiVal);
point2 = cartesianTransformer.TransformToVisible(index + sbsCenter, yLoVal);
}
else
{
point1 = cartesianTransformer.TransformToVisible(xChartVals[index] + sbsCenter, yHiVal);
point2 = cartesianTransformer.TransformToVisible(xChartVals[index] + sbsCenter, yLoVal);
}
point3 = cartesianTransformer.TransformToVisible(index + sbsCenter, yHiVal1);
point4 = cartesianTransformer.TransformToVisible(index + sbsCenter, yLoVal1);
xValues.Insert(0, ((float)point1.X));
x1Values.Insert(0, (float)blpoint.X);
x2Values.Insert(0, (float)trpoint.X);
openValue.Insert(0, (float)blpoint.Y);
closeValue.Insert(0, (float)trpoint.Y);
highValue.Insert(0, (float)point1.Y);
lowValue.Insert(0, (float)point2.Y);
highValue1.Insert(0, (float)point3.Y);
lowValue1.Insert(0, (float)point4.Y);
}
private void InsertVerticalPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index,
IList <double> values, double xBase, double yBase)
{
double x1Val, x2Val, openVal, closeVal, yHiVal, yHiVal1, yLoVal, yLoVal1;
double sbsCenter = sbsInfo.Median;
double sbsStart = sbsInfo.Start;
double sbsEnd = sbsInfo.End;
double highValues = highChartVals[index];
double lowValues = lowChartVals[index];
double openValues = openChartVals[index];
double closeValues = closeChartVals[index];
double tempOpenVal;
bool bullBearFlag = false;
var alignedValues = AlignHiLoSegment(openChartVals[index], closeChartVals[index], highValues,
lowValues);
highValues = alignedValues[0];
lowValues = alignedValues[1];
GetPoints(index, out x1Val, out x2Val, sbsStart, sbsEnd);
openVal = y_isInversed
? closeChartVals[index]
: openChartVals[index];
closeVal = y_isInversed
? openChartVals[index]
: closeChartVals[index];
if (index == 0 || (Series as FastCandleBitmapSeries).ComparisonMode == FinancialPrice.None)
{
bullBearFlag = openValues < closeValues;
}
else
{
bullBearFlag = values[index] >= values[index - 1];
}
isBull.Insert(0, bullBearFlag);
isHollow.Insert(0, closeValues > openValues &&
!((Series as FastCandleBitmapSeries).ComparisonMode == FinancialPrice.None));
x1Val = xBase == 1 ? x1Val : Math.Log(x1Val, xBase);
x2Val = xBase == 1 ? x2Val : Math.Log(x2Val, xBase);
openVal = yBase == 1 ? openVal : Math.Log(openVal, yBase);
closeVal = yBase == 1 ? closeVal : Math.Log(closeVal, yBase);
if (y_isInversed ? openVal > closeVal : openVal < closeVal)
{
tempOpenVal = openVal;
openVal = closeVal;
closeVal = tempOpenVal;
}
yHiVal = highValues;
yLoVal = lowValues;
if (openValues > closeValues)
{
yHiVal1 = openValues;
yLoVal1 = closeValues;
}
else
{
yHiVal1 = closeValues;
yLoVal1 = openValues;
}
Point point1 = cartesianTransformer.TransformToVisible(xChartVals[index] + sbsCenter, yHiVal);
Point point2 = cartesianTransformer.TransformToVisible(xChartVals[index] + sbsCenter, yLoVal);
Point point3 = cartesianTransformer.TransformToVisible(index + sbsCenter, yHiVal1);
Point point4 = cartesianTransformer.TransformToVisible(index + sbsCenter, yLoVal1);
xValues.Insert(0, (float)point1.Y);
x1Values.Insert(0,
(float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)));
x2Values.Insert(0,
(float)(xOffset + (xSize) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)));
openValue.Insert(0,
(float)
(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(openVal))));
closeValue.Insert(0,
(float)
(yOffset + (ySize) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(closeVal))));
highValue.Insert(0, ((float)point1.X));
lowValue.Insert(0, (float)point2.X);
highValue1.Insert(0, (float)point3.X);
lowValue1.Insert(0, (float)point4.X);
}
