private void InsertVerticalPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index, IList <double> values) { bool bullBearFlag = false; double highValues = yHiChartVals[index]; double lowValues = yLoChartVals[index]; var alignedValues = AlignHiLoSegment(yOpenChartVals[index], yCloseChartVals[index], highValues, lowValues); highValues = alignedValues[0]; lowValues = alignedValues[1]; Point hiPoint, loPoint, startopenpoint, startclosepoint, endopenpoint, endclosepoint; GetPoints(cartesianTransformer, index, out hiPoint, out loPoint, out startopenpoint, out endopenpoint, out startclosepoint, out endclosepoint, highValues, lowValues); xValues.Insert(0, ((float)hiPoint.Y)); yHiValues.Insert(0, (float)hiPoint.X); yLoValues.Insert(0, (float)loPoint.X); yOpenStartValues.Insert(0, (float)startopenpoint.X); yOpenEndValues.Insert(0, (float)endopenpoint.Y); yCloseValues.Insert(0, (float)endclosepoint.X); yCloseEndValues.Insert(0, (float)endclosepoint.Y); if (index == 0 || (Series as FastHiLoOpenCloseBitmapSeries).ComparisonMode == FinancialPrice.None) { bullBearFlag = yOpenChartVals[index] <= yCloseChartVals[index]; } else { bullBearFlag = values[index] >= values[index - 1]; } isBull.Insert(0, bullBearFlag); }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (transformer != null) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xStart = cartesianTransformer.XAxis.VisibleRange.Start; double xEnd = cartesianTransformer.XAxis.VisibleRange.End; double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double edgeValue = xIsLogarithmic ? Math.Log(xVal, xBase) : xVal; if (edgeValue >= xStart && edgeValue <= xEnd && ((!double.IsNaN(highValue) && !double.IsNaN(lowValue)) || Series.ShowEmptyPoints)) { Point hipoint = transformer.TransformToVisible(xVal, highValue); Point lopoint = transformer.TransformToVisible(xVal, lowValue); segLine.X1 = hipoint.X; segLine.Y1 = hipoint.Y; segLine.X2 = lopoint.X; segLine.Y2 = lopoint.Y; } else { segLine.ClearUIValues(); } } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastHiLoOpenCloseSeries.Area.GetFastRenderSurface(); if (transformer != null && fastHiLoOpenCloseSeries.DataCount > 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; xValues.Clear(); yHiValues.Clear(); yLoValues.Clear(); yOpenStartValues.Clear(); yOpenEndValues.Clear(); yCloseValues.Clear(); yCloseEndValues.Clear(); isBull.Clear(); x_isInversed = cartesianTransformer.XAxis.IsInversed; y_isInversed = cartesianTransformer.YAxis.IsInversed; sbsInfo = (fastHiLoOpenCloseSeries as ChartSeriesBase).GetSideBySideInfo(fastHiLoOpenCloseSeries as ChartSeriesBase); center = sbsInfo.Median; Left = sbsInfo.Start; Right = sbsInfo.End; //Removed the screen point calculation methods and added the Transform to Visible method. CalculatePoint(cartesianTransformer); UpdateVisual(true); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastCandleBitmapSeries.Area.GetFastRenderSurface(); if (transformer != null && fastCandleBitmapSeries.DataCount > 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; count = (int)(Math.Ceiling(xEnd)); count = (int)Math.Min(count, xChartVals.Count); x_isInversed = cartesianTransformer.XAxis.IsInversed; 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 (fastCandleBitmapSeries.IsActualTransposed) { ySize = cartesianTransformer.YAxis.RenderedRect.Width; xSize = cartesianTransformer.XAxis.RenderedRect.Height; yOffset = cartesianTransformer.YAxis.RenderedRect.Left - fastCandleBitmapSeries.Area.SeriesClipRect.Left; xOffset = cartesianTransformer.XAxis.RenderedRect.Top - fastCandleBitmapSeries.Area.SeriesClipRect.Top; } else { ySize = cartesianTransformer.YAxis.RenderedRect.Height; xSize = cartesianTransformer.XAxis.RenderedRect.Width; yOffset = cartesianTransformer.YAxis.RenderedRect.Top - fastCandleBitmapSeries.Area.SeriesClipRect.Top; xOffset = cartesianTransformer.XAxis.RenderedRect.Left - fastCandleBitmapSeries.Area.SeriesClipRect.Left; } if (x_isInversed) { double temp = xStart; xStart = xEnd; xEnd = temp; } if (y_isInversed) { double temp = yStart; yStart = yEnd; yEnd = temp; } isHollow.Clear(); isBull.Clear(); xValues.Clear(); x1Values.Clear(); x2Values.Clear(); openValue.Clear(); closeValue.Clear(); highValue.Clear(); highValue1.Clear(); lowValue.Clear(); lowValue1.Clear(); //Removed the screen point calculation methods and added the point to value method. CalculatePoints(cartesianTransformer); UpdateVisual(); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastBarSeries.Area.GetFastRenderSurface(); if (transformer != null && fastBarSeries.DataCount != 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic || cartesianTransformer.YAxis.IsLogarithmic; x_isInversed = cartesianTransformer.XAxis.IsInversed; 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; width = cartesianTransformer.XAxis.RenderedRect.Height; height = cartesianTransformer.YAxis.RenderedRect.Width; // WPF-14441 - Calculating Bar Position for the Series left = fastBarSeries.Area.SeriesClipRect.Right - cartesianTransformer.YAxis.RenderedRect.Right; top = fastBarSeries.Area.SeriesClipRect.Bottom - cartesianTransformer.XAxis.RenderedRect.Bottom; availableSize = new Size(width, height); if (x_isInversed) { double temp = xStart; xStart = xEnd; xEnd = temp; } if (y_isInversed) { double temp = yStart; yStart = yEnd; yEnd = temp; } x1Values.Clear(); x2Values.Clear(); y1Values.Clear(); y2Values.Clear(); //Removed the screen point calculation methods and added the point to value method. if (!isLogarithmic) { CalculatePoints(cartesianTransformer); } else { CalculateLogPoints(cartesianTransformer); } UpdateVisual(); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (transformer != null) { if (isSegmentUpdated) { Series.SeriesRootPanel.Clip = null; } ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double xStart = cartesianTransformer.XAxis.VisibleRange.Start; double xEnd = cartesianTransformer.XAxis.VisibleRange.End; double left = xIsLogarithmic ? Math.Log(Point1.X, xBase) : Point1.X; double right = xIsLogarithmic ? Math.Log(Point4.X, xBase) : Point4.X; if ((left <= xEnd && right >= xStart)) { PathFigure figure = new PathFigure(); BezierSegment bezierSeg = new BezierSegment(); PathGeometry segGeometry = new PathGeometry(); P1 = figure.StartPoint = transformer.TransformToVisible(Point1.X, Point1.Y); Q1 = bezierSeg.Point1 = transformer.TransformToVisible(Point2.X, Point2.Y); Q2 = bezierSeg.Point2 = transformer.TransformToVisible(Point3.X, Point3.Y); P2 = bezierSeg.Point3 = transformer.TransformToVisible(Point4.X, Point4.Y); figure.Segments.Add(bezierSeg); segGeometry.Figures = new PathFigureCollection() { figure }; var path = this.segPath; if (path != null) { path.Data = segGeometry; } else { Data = segGeometry; } } else { if (segPath != null) { this.segPath.Data = null; } else if (Data != null) { Data = null; } } isSegmentUpdated = true; } }
private void InsertDataPoint(ChartTransform.ChartCartesianTransformer cartesianTransformer, int index) { double x1Val = 0, x2Val = 0, y2Val = 0, y1Val = 0; GetPoints(index, out x1Val, out x2Val, out y1Val, out y2Val); x1Values.Insert(0, (float)(top + availableSize.Width * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val))); x2Values.Insert(0, (float)(top + availableSize.Width * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val))); y1Values.Insert(0, (float)(left + availableSize.Height * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val)))); y2Values.Insert(0, (float)(left + availableSize.Height * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val)))); }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastRangeAreaBitmapSeries.Area.GetFastRenderSurface(); if (transformer != null && fastRangeAreaBitmapSeries.DataCount > 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; // Removed the screen point calculation methods and added the point to value method. CalculatePoints(cartesianTransformer); UpdateVisual(); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer"></param> public override void Update(IChartTransformer transformer) { bitmap = fastSeries.Area.GetFastRenderSurface(); if (transformer != null && fastSeries.DataCount > 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; xValues.Clear(); yValues.Clear(); //WPF-14440 In seconday axis scrolling not apply for FastStepLineBitmapSeries //Removed the existing screen point calculation methods and added the TransformVisible method. CalculatePoints(cartesianTransformer); UpdateVisual(); } }
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 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); }
/// <summary> /// Transforms for non logarithmic axis /// </summary> /// <param name="cartesianTransformer"></param> void TransformToScreenCoInLog(ChartTransform.ChartCartesianTransformer cartesianTransformer) { double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1; if (!fastSeries.IsActualTransposed) { TransformToScreenCoInLogHorizontal(xBase, yBase); } else { TransformToScreenCoInLogVertical(xBase, yBase); } }
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]); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastHiloSeries.Area.GetFastRenderSurface(); if (transformer != null && fastHiloSeries.DataCount > 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; xValues.Clear(); yHiValues.Clear(); yLoValues.Clear(); x_isInversed = cartesianTransformer.XAxis.IsInversed; y_isInversed = cartesianTransformer.YAxis.IsInversed; //Removed the screen point calculation methods and added the point to value method. CalculatePoints(cartesianTransformer); UpdateVisual(true); } }
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, int index) { Point hipoint, lopoint; GetHiLoPoints(cartesianTransformer, index, out hipoint, out lopoint); if (!fastHiloSeries.IsActualTransposed) { xValues.Insert(0, (float)hipoint.X); yHiValues.Insert(0, (float)hipoint.Y); yLoValues.Insert(0, (float)lopoint.Y); } else { xValues.Insert(0, (float)hipoint.Y); yHiValues.Insert(0, (float)hipoint.X); yLoValues.Insert(0, (float)lopoint.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> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { bitmap = fastColumnSeries.Area.GetFastRenderSurface(); if (transformer != null && fastColumnSeries.DataCount != 0) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; x_isInversed = cartesianTransformer.XAxis.IsInversed; y_isInversed = cartesianTransformer.YAxis.IsInversed; x1Values.Clear(); x2Values.Clear(); y1Values.Clear(); y2Values.Clear(); actualIndexes.Clear(); //Removed the existing screen point calculation methods and added the TransformVisible method. CalculatePoints(cartesianTransformer); UpdateVisual(true); } }
private void CalculateLogPoints(ChartTransform.ChartCartesianTransformer cartesianTransformer) { double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1; float x1Value = 0, x2Value = 0, y1Value = 0, y2Value = 0; for (int i = 0; i < this.Series.DataCount; i++) { double logx1 = xBase == 1 ? x1ChartVals[i] : Math.Log(x1ChartVals[i], xBase); double logx2 = xBase == 1 ? x2ChartVals[i] : Math.Log(x2ChartVals[i], xBase); double logy1 = yBase == 1 ? y1ChartVals[i] : Math.Log(y1ChartVals[i], yBase); double logy2 = yBase == 1 ? y2ChartVals[i] : Math.Log(y2ChartVals[i], yBase); double x1Val = x_isInversed ? logx2 < xEnd ? xEnd : logx2 : logx1 < xStart ? xStart : logx1; double x2Val = x_isInversed ? logx1 > xStart ? xStart : logx1 : logx2 > xEnd ? xEnd : logx2; double y1Val = y_isInversed ? logy2 > yStart ? yStart : logy2 <yEnd?yEnd : logy2 : logy1> yEnd ? yEnd : logy1 < yStart ? yStart : logy1; double y2Val = y_isInversed ? logy1 <yEnd?yEnd : logy1> yStart ? yStart : logy1 : logy2 <yStart?yStart : logy2> yEnd ? yEnd : logy2; x1Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)); x2Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)); y1Value = (float) (left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val))); y2Value = (float) (left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val))); x1Values.Add(x1Value); x2Values.Add(x2Value); y1Values.Add(y1Value); y2Values.Add(y2Value); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (transformer != null) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double xStart = cartesianTransformer.XAxis.VisibleRange.Start; double xEnd = cartesianTransformer.XAxis.VisibleRange.End; double pos = xIsLogarithmic ? Math.Log(xPos, xBase) : xPos; if (pos >= xStart && pos <= xEnd && (!double.IsNaN(yPos) || Series.ShowEmptyPoints)) { Point point1 = transformer.TransformToVisible(xPos, yPos); if (ellipseSegment != null) { ellipseSegment.Visibility = Visibility.Visible; ellipseSegment.Height = ellipseSegment.Width = 2 * this.segmentRadius; ellipseSegment.SetValue(Canvas.LeftProperty, point1.X - this.segmentRadius); ellipseSegment.SetValue(Canvas.TopProperty, point1.Y - this.segmentRadius); } else { control.Visibility = Visibility.Visible; RectX = point1.X - this.segmentRadius; RectY = point1.Y - this.segmentRadius; Size = SegmentRadius = 2 * this.segmentRadius; } } else if (customTemplate == null) { ellipseSegment.Visibility = Visibility.Collapsed; } else { control.Visibility = Visibility.Collapsed; } } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (Length == 0) { base.Update(transformer); } else if (transformer != null && fastSeries.DataCount > 1) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic || cartesianTransformer.YAxis.IsLogarithmic; if (!isLogarithmic) { TransformToScreenCo(cartesianTransformer); } else { TransformToScreenCoInLog(cartesianTransformer); } UpdateVisual(true); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (transformer != null) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double left = xIsLogarithmic ? Math.Log(Left, xBase) : Left; double right = xIsLogarithmic ? Math.Log(Right, xBase) : Right; double xStart = Math.Floor(cartesianTransformer.XAxis.VisibleRange.Start); double xEnd = Math.Ceiling(cartesianTransformer.XAxis.VisibleRange.End); if (!double.IsNaN(Top) && !double.IsNaN(Bottom) && (left <= xEnd && right >= xStart)) { //Calculate the rect for segment rendering. rect = CalculateSegmentRect(transformer); segmentCanvas.Visibility = Visibility.Visible; if (WaterfallRectSegment != null) { WaterfallRectSegment.SetValue(Canvas.LeftProperty, rect.X); WaterfallRectSegment.SetValue(Canvas.TopProperty, rect.Y); WaterfallRectSegment.Visibility = Visibility.Visible; Width = WaterfallRectSegment.Width = rect.Width; Height = WaterfallRectSegment.Height = rect.Height; //set position for connector line. UpdateConnectorLine(transformer); } } else { segmentCanvas.Visibility = Visibility.Collapsed; } } }
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]); } }
private void CalculatePoints(ChartTransform.ChartCartesianTransformer cartesianTransformer) { ChartAxis xAxis = cartesianTransformer.XAxis; if (this.Series.IsIndexed) { var isGrouping = (Series.ActualXAxis is CategoryAxis) && (Series.ActualXAxis as CategoryAxis).IsIndexed; int start = 0, end = 0; if (!isGrouping) { start = 0; end = x1ChartVals.Count - 1; } else { start = (int)Math.Floor(xAxis.VisibleRange.Start); end = (int)Math.Ceiling(xAxis.VisibleRange.End); end = end > y1ChartVals.Count - 1 ? y1ChartVals.Count - 1 : end; } start = start < 0 ? 0 : start; for (int i = start; i <= end; i++) { AddDataPoint(cartesianTransformer, i); } startIndex = start; } else if (this.Series.isLinearData) { double start = xAxis.VisibleRange.Start; double end = xAxis.VisibleRange.End; int i = 0; int count = x1ChartVals.Count - 1; startIndex = 0; for (i = 1; i < count; i++) { double xValue = x1ChartVals[i]; if (xValue >= start && xValue <= end) { AddDataPoint(cartesianTransformer, i); } else if (xValue < start) { startIndex = i; } else if (xValue > end) { AddDataPoint(cartesianTransformer, i); break; } } InsertDataPoint(cartesianTransformer, startIndex); if (i == count) { AddDataPoint(cartesianTransformer, count); } } else { startIndex = 0; for (int i = 0; i < this.Series.DataCount; i++) { AddDataPoint(cartesianTransformer, i); } } }
/// <summary> /// Updates the box and whisker segment based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (double.IsNaN(Minimum) && double.IsNaN(LowerQuartile) && double.IsNaN(Median) && double.IsNaN(UppperQuartile) && double.IsNaN(Maximum)) { return; } ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xStart = Math.Floor(cartesianTransformer.XAxis.VisibleRange.Start); double xEnd = Math.Ceiling(cartesianTransformer.XAxis.VisibleRange.End); double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double left = xIsLogarithmic ? Math.Log(Left, xBase) : Left; double right = xIsLogarithmic ? Math.Log(Right, xBase) : Right; if ((left <= xEnd && right >= xStart)) { lowerQuartileLine.Visibility = Visibility.Visible; upperQuartileLine.Visibility = Visibility.Visible; medianLine.Visibility = Visibility.Visible; minimumLine.Visibility = Visibility.Visible; maximumLine.Visibility = Visibility.Visible; rectangle.Visibility = Visibility.Visible; Point minimumPoint = transformer.TransformToVisible(Center, Minimum); Point lowerQuartilePoint = transformer.TransformToVisible(Center, LowerQuartile); Point medianPoint = transformer.TransformToVisible(Center, Median); Point upperQuartilePoint = transformer.TransformToVisible(Center, UppperQuartile); Point maximumPoint = transformer.TransformToVisible(Center, Maximum); var tlPoint = transformer.TransformToVisible(Left, UppperQuartile); var brPoint = transformer.TransformToVisible(Right, LowerQuartile); double spacing = (Series as ISegmentSpacing).SegmentSpacing; rect = new Rect(tlPoint, brPoint); if (Series.IsActualTransposed) { if (spacing > 0 && spacing <= 1) { rect.Y = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Bottom, rect.Top); rect.Height = (1 - spacing) * rect.Height; } var percentHeight = rect.Height / 2 * WhiskerWidth; var centerLinePosition = rect.Y + rect.Height / 2; var topPercentWidth = centerLinePosition - percentHeight; var bottomPercentWidth = centerLinePosition + percentHeight; this.medianLine.X1 = medianPoint.X; this.medianLine.X2 = medianPoint.X; this.medianLine.Y1 = rect.Top; this.medianLine.Y2 = rect.Bottom; this.maximumLine.X1 = maximumPoint.X; this.maximumLine.Y1 = topPercentWidth; this.maximumLine.X2 = maximumPoint.X; this.maximumLine.Y2 = bottomPercentWidth; this.minimumLine.X1 = minimumPoint.X; this.minimumLine.Y1 = topPercentWidth; this.minimumLine.X2 = minimumPoint.X; this.minimumLine.Y2 = bottomPercentWidth; } else { if (spacing > 0 && spacing <= 1) { rect.X = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Right, rect.Left); rect.Width = (1 - spacing) * rect.Width; } var percentWidth = rect.Width / 2 * WhiskerWidth; var centerLinePosition = rect.X + rect.Width / 2; var leftPercentWidth = centerLinePosition - percentWidth; var rightPercentWidth = centerLinePosition + percentWidth; this.medianLine.X1 = rect.Left; this.medianLine.X2 = rect.Right; this.medianLine.Y1 = medianPoint.Y; this.medianLine.Y2 = medianPoint.Y; this.maximumLine.X1 = leftPercentWidth; this.maximumLine.Y1 = maximumPoint.Y; this.maximumLine.X2 = rightPercentWidth; this.maximumLine.Y2 = maximumPoint.Y; this.minimumLine.X1 = leftPercentWidth; this.minimumLine.Y1 = minimumPoint.Y; this.minimumLine.X2 = rightPercentWidth; this.minimumLine.Y2 = minimumPoint.Y; } rectangle.Width = rect.Width; rectangle.Height = rect.Height; rectangle.SetValue(Canvas.LeftProperty, rect.X); rectangle.SetValue(Canvas.TopProperty, rect.Y); this.lowerQuartileLine.X1 = minimumPoint.X; this.lowerQuartileLine.X2 = lowerQuartilePoint.X; this.lowerQuartileLine.Y1 = minimumPoint.Y; this.lowerQuartileLine.Y2 = lowerQuartilePoint.Y; this.upperQuartileLine.X1 = upperQuartilePoint.X; this.upperQuartileLine.X2 = maximumPoint.X; this.upperQuartileLine.Y1 = upperQuartilePoint.Y; this.upperQuartileLine.Y2 = maximumPoint.Y; UpdateMeanSymbol(cartesianTransformer, (Series as BoxAndWhiskerSeries).ShowMedian); } else { medianLine.Visibility = Visibility.Collapsed; minimumLine.Visibility = Visibility.Collapsed; maximumLine.Visibility = Visibility.Collapsed; lowerQuartileLine.Visibility = Visibility.Collapsed; upperQuartileLine.Visibility = Visibility.Collapsed; rectangle.Visibility = Visibility.Collapsed; averagePath.Visibility = Visibility.Collapsed; } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overridden by /// any derived class. /// </summary> /// <param name="transformer">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { if (transformer != null) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double left = xIsLogarithmic ? Math.Log(Left, xBase) : Left; double right = xIsLogarithmic ? Math.Log(Right, xBase) : Right; double xStart = Math.Floor(cartesianTransformer.XAxis.VisibleRange.Start); double xEnd = Math.Ceiling(cartesianTransformer.XAxis.VisibleRange.End); if (!double.IsNaN(Top) && !double.IsNaN(Bottom) && (left <= xEnd && right >= xStart) && (!double.IsNaN(YData) || Series.ShowEmptyPoints)) { double spacing = (Series is HistogramSeries) ? 0.0 : (Series as ISegmentSpacing).SegmentSpacing; Point tlpoint = transformer.TransformToVisible(Left, Top); Point rbpoint = transformer.TransformToVisible(Right, Bottom); rect = new Rect(tlpoint, rbpoint); if (spacing > 0.0 && spacing <= 1) { if (Series.IsActualTransposed == true) { double leftpos = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Bottom, rect.Top); rect.Y = leftpos; Height = rect.Height = (1 - spacing) * rect.Height; } else { double leftpos = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Right, rect.Left); rect.X = leftpos; Width = rect.Width = (1 - spacing) * rect.Width; } } if (RectSegment != null) { RectSegment.SetValue(Canvas.LeftProperty, rect.X); RectSegment.SetValue(Canvas.TopProperty, rect.Y); RectSegment.Visibility = Visibility.Visible; Width = RectSegment.Width = rect.Width; Height = RectSegment.Height = rect.Height; } else { control.Visibility = Visibility.Visible; RectX = rect.X; RectY = rect.Y; Width = rect.Width; Height = rect.Height; } } else if (customTemplate == null) { RectSegment.Visibility = Visibility.Collapsed; } else { control.Visibility = Visibility.Collapsed; } } }
/// <summary> /// This method used to gets the selected data point segment pixel positions /// </summary> internal void GenerateBarPixels() { WriteableBitmap bmp = Area.fastRenderSurface; ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer( new Size( Area.SeriesClipRect.Width, Area.SeriesClipRect.Height), true) as ChartTransform.ChartCartesianTransformer; DoubleRange sbsInfo = this.GetSideBySideInfo(this); float x1Value = 0, x2Value = 0, y1Value = 0, y2Value = 0; double x1 = dataPoint.XData + sbsInfo.Start; double x2 = dataPoint.XData + sbsInfo.End; double y1 = dataPoint.YData; double y2 = ActualXAxis != null ? ActualXAxis.Origin : 0; 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 width = cartesianTransformer.XAxis.RenderedRect.Height; double height = cartesianTransformer.YAxis.RenderedRect.Width; // WPF-14441 - Calculating Bar Position for the Series double left = Area.SeriesClipRect.Right - cartesianTransformer.YAxis.RenderedRect.Right; double top = Area.SeriesClipRect.Bottom - cartesianTransformer.XAxis.RenderedRect.Bottom; Size availableSize = new Size(width, height); bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic || cartesianTransformer.YAxis.IsLogarithmic; if (ActualXAxis.IsInversed) { double temp = xStart; xStart = xEnd; xEnd = temp; } if (ActualYAxis.IsInversed) { double temp = yStart; yStart = yEnd; yEnd = temp; } if (!isLogarithmic) { double x1Val = ActualXAxis.IsInversed ? x2 < xEnd ? xEnd : x2 : x1 < xStart ? xStart : x1; double x2Val = ActualXAxis.IsInversed ? x1 > xStart ? xStart : x1 : x2 > xEnd ? xEnd : x2; double y1Val = ActualYAxis.IsInversed ? y2 > yStart ? yStart : y2 <yEnd?yEnd : y2 : y1> yEnd ? yEnd : y1 < yStart ? yStart : y1; double y2Val = ActualYAxis.IsInversed ? y1 <yEnd?yEnd : y1> yStart ? yStart : y1 : y2 <yStart?yStart : y2> yEnd ? yEnd : y2; x1Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)); x2Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)); y1Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val))); y2Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val))); } else { double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1; double logx1 = xBase == 1 ? x1 : Math.Log(x1, xBase); double logx2 = xBase == 1 ? x2 : Math.Log(x2, xBase); double logy1 = yBase == 1 ? y1 : Math.Log(y1, yBase); double logy2 = yBase == 1 ? y2 : Math.Log(y2, yBase); double x1Val = ActualXAxis.IsInversed ? logx2 < xEnd ? xEnd : logx2 : logx1 < xStart ? xStart : logx1; double x2Val = ActualXAxis.IsInversed ? logx1 > xStart ? xStart : logx1 : logx2 > xEnd ? xEnd : logx2; double y1Val = ActualYAxis.IsInversed ? logy2 > yStart ? yStart : logy2 <yEnd?yEnd : logy2 : logy1> yEnd ? yEnd : logy1 < yStart ? yStart : logy1; double y2Val = ActualYAxis.IsInversed ? logy1 <yEnd?yEnd : logy1> yStart ? yStart : logy1 : logy2 <yStart?yStart : logy2> yEnd ? yEnd : logy2; x1Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)); x2Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)); y1Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val))); y2Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val))); } double _x1 = x1Value; double _x2 = x2Value; double _y1 = y1 > 0 ? y1Value : y2Value; double _y2 = y1 > 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); } } double diff = _x2 - _x1; width = (int)Area.SeriesClipRect.Width; height = (int)Area.SeriesClipRect.Height; selectedSegmentPixels.Clear(); if (_y1 < _y2) { selectedSegmentPixels = bmp.GetRectangle((int)width, (int)height, (int)(width - _y2), (int)(height - _x1 - diff), (int)(width - _y1), (int)(height - _x1), selectedSegmentPixels); } else { selectedSegmentPixels = bmp.GetRectangle((int)width, (int)height, (int)(width - y1), (int)(height - x1 - diff), (int)(width - y2), (int)(height - x1), selectedSegmentPixels); } }
/// <summary> /// Updates the segments based on its data point value. This method is not /// intended to be called explicitly outside the Chart but it can be overriden by /// any derived class. /// </summary> /// <param name="transformer">Reresents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param> public override void Update(IChartTransformer transformer) { ChartTransform.ChartCartesianTransformer cartesianTransformer = transformer as ChartTransform.ChartCartesianTransformer; double xStart = Math.Floor(cartesianTransformer.XAxis.VisibleRange.Start); double xEnd = Math.Ceiling(cartesianTransformer.XAxis.VisibleRange.End); double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; bool xIsLogarithmic = cartesianTransformer.XAxis.IsLogarithmic; double left = xIsLogarithmic ? Math.Log(cdpBottomLeft.X, xBase) : cdpBottomLeft.X; double right = xIsLogarithmic ? Math.Log(cdpRightTop.X, xBase) : cdpRightTop.X; if ((left <= xEnd && right >= xStart) || Series.ShowEmptyPoints) { double spacing = (Series as ISegmentSpacing).SegmentSpacing; columnSegment.Visibility = Visibility.Visible; hiLoLine.Visibility = Visibility.Visible; hiLoLine1.Visibility = Visibility.Visible; openCloseLine.Visibility = Visibility.Visible; Point blpoint = transformer.TransformToVisible(cdpBottomLeft.X, cdpBottomLeft.Y); Point trpoint = transformer.TransformToVisible(cdpRightTop.X, cdpRightTop.Y); rect = new Rect(blpoint, trpoint); if (spacing > 0 && spacing <= 1) { if (Series.IsActualTransposed) { rect.Y = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Bottom, rect.Top); columnSegment.Height = rect.Height = (1 - spacing) * rect.Height; } else { rect.X = (Series as ISegmentSpacing).CalculateSegmentSpacing(spacing, rect.Right, rect.Left); columnSegment.Width = rect.Width = (1 - spacing) * rect.Width; } } if (cdpBottomLeft.Y == cdpRightTop.Y) { if (!double.IsNaN(cdpBottomLeft.Y) && !double.IsNaN(cdpRightTop.Y)) { columnSegment.Visibility = Visibility.Collapsed; this.openCloseLine.X1 = rect.Left; this.openCloseLine.Y1 = rect.Top; this.openCloseLine.X2 = rect.Right; this.openCloseLine.Y2 = rect.Bottom; } else { openCloseLine.Visibility = Visibility.Collapsed; openCloseLine.ClearUIValues(); } } else if (!double.IsNaN(cdpBottomLeft.Y) && !double.IsNaN(cdpRightTop.Y)) { openCloseLine.Visibility = Visibility.Collapsed; columnSegment.SetValue(Canvas.LeftProperty, rect.X); columnSegment.SetValue(Canvas.TopProperty, rect.Y); columnSegment.Width = rect.Width; columnSegment.Height = rect.Height; } else { columnSegment.Visibility = Visibility.Collapsed; columnSegment.ClearUIValues(); } Point point1 = transformer.TransformToVisible(this.hiPoint.X, this.hiPoint.Y); Point point2 = transformer.TransformToVisible(this.hiPoint1.X, this.hiPoint1.Y); Point point3 = transformer.TransformToVisible(this.loPoint.X, this.loPoint.Y); Point point4 = transformer.TransformToVisible(this.loPoint1.X, this.loPoint1.Y); if (!double.IsNaN(point1.Y) && !double.IsNaN(point2.Y) && !double.IsNaN(point1.X) && !double.IsNaN(point2.X) && !double.IsNaN(point3.Y) && !double.IsNaN(point4.Y) && !double.IsNaN(point3.X) && !double.IsNaN(point4.X)) { this.hiLoLine.X1 = point1.X; this.hiLoLine.X2 = point2.X; this.hiLoLine.Y1 = point1.Y; this.hiLoLine.Y2 = point2.Y; this.hiLoLine1.X1 = point3.X; this.hiLoLine1.X2 = point4.X; this.hiLoLine1.Y1 = point3.Y; this.hiLoLine1.Y2 = point4.Y; if (rect.Contains(point1)) { this.hiLoLine.Visibility = Visibility.Collapsed; } if (rect.Contains(point3)) { this.hiLoLine1.Visibility = Visibility.Collapsed; } } else { hiLoLine.Visibility = Visibility.Collapsed; hiLoLine.ClearUIValues(); hiLoLine1.Visibility = Visibility.Collapsed; hiLoLine1.ClearUIValues(); } } else { columnSegment.ClearUIValues(); hiLoLine.ClearUIValues(); hiLoLine1.ClearUIValues(); openCloseLine.ClearUIValues(); columnSegment.Visibility = Visibility.Collapsed; hiLoLine.Visibility = Visibility.Collapsed; hiLoLine1.Visibility = Visibility.Collapsed; openCloseLine.Visibility = Visibility.Collapsed; } }
/// <summary> /// This method is used to gets the selected data point segment pixel positions /// </summary> internal void GenerateStackingBarPixels() { WriteableBitmap bmp = Area.fastRenderSurface; ChartTransform.ChartCartesianTransformer cartesianTransformer = CreateTransformer( new Size( Area.SeriesClipRect.Width, Area.SeriesClipRect.Height), true) as ChartTransform.ChartCartesianTransformer; bool isLogarithmic = cartesianTransformer.XAxis.IsLogarithmic || cartesianTransformer.YAxis.IsLogarithmic; bool x_isInversed = cartesianTransformer.XAxis.IsInversed; bool y_isInversed = cartesianTransformer.YAxis.IsInversed; double x1ChartVal, x2ChartVal, y1ChartVal, y2ChartVal; double xStart, xEnd, yStart, yEnd, width, height, left, top; 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]; } xStart = cartesianTransformer.XAxis.VisibleRange.Start; xEnd = cartesianTransformer.XAxis.VisibleRange.End; yStart = cartesianTransformer.YAxis.VisibleRange.Start; yEnd = cartesianTransformer.YAxis.VisibleRange.End; width = cartesianTransformer.XAxis.RenderedRect.Height; height = cartesianTransformer.YAxis.RenderedRect.Width; // WPF-14441 - Calculating Bar Position for the Series left = Area.SeriesClipRect.Right - cartesianTransformer.YAxis.RenderedRect.Right; top = Area.SeriesClipRect.Bottom - cartesianTransformer.XAxis.RenderedRect.Bottom; Size availableSize = new Size(width, height); if (x_isInversed) { double temp = xStart; xStart = xEnd; xEnd = temp; } if (y_isInversed) { double temp = yStart; yStart = yEnd; yEnd = temp; } float x1Value = 0, x2Value = 0, y1Value = 0, y2Value = 0; // Removed the screen point calculation methods and added the point to value method. if (!isLogarithmic) { double x1Val = x_isInversed ? x2ChartVal < xEnd ? xEnd : x2ChartVal : x1ChartVal < xStart ? xStart : x1ChartVal; double x2Val = x_isInversed ? x1ChartVal > xStart ? xStart : x1ChartVal : x2ChartVal > xEnd ? xEnd : x2ChartVal; double y1Val = y_isInversed ? y2ChartVal > yStart ? yStart : y2ChartVal <yEnd?yEnd : y2ChartVal : y1ChartVal> yEnd ? yEnd : y1ChartVal < yStart ? yStart : y1ChartVal; double y2Val = y_isInversed ? y1ChartVal <yEnd?yEnd : y1ChartVal> yStart ? yStart : y1ChartVal : y2ChartVal <yStart?yStart : y2ChartVal> yEnd ? yEnd : y2ChartVal; x1Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)); x2Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)); y1Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val))); y2Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val))); } else { double xBase = cartesianTransformer.XAxis.IsLogarithmic ? (cartesianTransformer.XAxis as LogarithmicAxis).LogarithmicBase : 1; double yBase = cartesianTransformer.YAxis.IsLogarithmic ? (cartesianTransformer.YAxis as LogarithmicAxis).LogarithmicBase : 1; double logx1 = xBase == 1 ? x1ChartVal : Math.Log(x1ChartVal, xBase); double logx2 = xBase == 1 ? x2ChartVal : Math.Log(x2ChartVal, xBase); double logy1 = yBase == 1 ? y1ChartVal : Math.Log(y1ChartVal, yBase); double logy2 = yBase == 1 ? y2ChartVal : Math.Log(y2ChartVal, yBase); double x1Val = x_isInversed ? logx2 < xEnd ? xEnd : logx2 : logx1 < xStart ? xStart : logx1; double x2Val = x_isInversed ? logx1 > xStart ? xStart : logx1 : logx2 > xEnd ? xEnd : logx2; double y1Val = y_isInversed ? logy2 > yStart ? yStart : logy2 <yEnd?yEnd : logy2 : logy1> yEnd ? yEnd : logy1 < yStart ? yStart : logy1; double y2Val = y_isInversed ? logy1 <yEnd?yEnd : logy1> yStart ? yStart : logy1 : logy2 <yStart?yStart : logy2> yEnd ? yEnd : logy2; x1Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x1Val)); x2Value = (float)(top + (availableSize.Width) * cartesianTransformer.XAxis.ValueToCoefficientCalc(x2Val)); y1Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y1Val))); y2Value = (float)(left + (availableSize.Height) * (1 - cartesianTransformer.YAxis.ValueToCoefficientCalc(y2Val))); } float x1 = 0, x2, y1, y2, diff = 0; width = (int)Area.SeriesClipRect.Width; height = (int)Area.SeriesClipRect.Height; 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, x1, x2); double rightpos = spacingSegment.CalculateSegmentSpacing(spacing, x2, x1); x2 = (float)leftpos; x1 = (float)rightpos; } } diff = x2 - x1; selectedSegmentPixels.Clear(); if (y1 < y2) { selectedSegmentPixels = bmp.GetRectangle( (int)width, (int)height, (int)(width - y2), (int)(height - x1 - diff), (int)(width - y1), (int)(height - x1), selectedSegmentPixels); } else { selectedSegmentPixels = bmp.GetRectangle( (int)width, (int)height, (int)(width - y1), (int)(height - x1 - diff), (int)(width - y2), (int)(height - x1), selectedSegmentPixels); } }
/// <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); } }