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); }