Ejemplo n.º 1
0
        private static void OnPieCoefficientPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var series = d as PieSeries;

            series.InternalPieCoefficient = ChartMath.MinMax((double)e.NewValue, 0, 1);
            series.UpdateArea();
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Updates the series when doughnut coefficient changed.
        /// </summary>
        /// <param name="d">The Dependency Object</param>
        /// <param name="e">The Event Arguments</param>
        private static void OnDoughnutCoefficientChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var doughnutSeries3D = d as DoughnutSeries3D;

            doughnutSeries3D.InternlDoughnutCoefficient = ChartMath.MinMax((double)e.NewValue, 0, 1);
            doughnutSeries3D.UpdateArea();
        }
Ejemplo n.º 3
0
        protected internal DoubleRange GetYRange(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
        {
            DoubleRange range = DoubleRange.Union(new double[] { y1, y2, y3, y4 });

            double cy = 3 * (y2 - y1);

            double by = 3 * (y3 - y3) - cy;

            double ay = y4 - y1 - by - cy;

            double r1, r2;

            if (ChartMath.SolveQuadraticEquation(3 * ay, 2 * by, cy, out r1, out r2))
            {
                if (r1 >= 0 && r1 <= 1)
                {
                    double y = ay * r1 * r1 * r1 + by * r1 * r1 + cy * r1 + y1;
                    range = DoubleRange.Union(range, y);
                }

                if (r2 >= 0 && r2 <= 1)
                {
                    double y = ay * r2 * r2 * r2 + by * r2 * r2 + cy * r2 + y1;
                    range = DoubleRange.Union(range, y);
                }
            }

            return(range);
        }
Ejemplo n.º 4
0
        private static void OnDoughnutSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var series = d as DoughnutSeries;

            series.InternalDoughnutSize = ChartMath.MinMax((double)e.NewValue, 0, 1);
            series.UpdateArea();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Gets the normal.
        /// </summary>
        /// <param name="transform">The transform.</param>
        /// <returns>Returns Vector3D instance.</returns>
        internal virtual Vector3D GetNormal(Matrix3D transform)
        {
            Vector3D norm;

            if (VectorPoints != null)
            {
                norm = ChartMath.GetNormal(
                    transform * VectorPoints[0],
                    transform * VectorPoints[1],
                    transform * VectorPoints[2]);

                for (var i = 3; (i < VectorPoints.Length) && !norm.IsValid; i++)
                {
                    var v1 = transform * VectorPoints[i];
                    var v2 = transform * VectorPoints[0];
                    var v3 = transform * VectorPoints[i / 2];

                    norm = ChartMath.GetNormal(v1, v2, v3);
                }
            }
            else
            {
                norm = transform & normal;
                norm.Normalize();
            }

            return(norm);
        }
Ejemplo n.º 6
0
        public override void SetData(Point hlpoint, Point hrpoint, Point vtpoint, Point vbpoint)
        {
            _horLeftpoint   = new ChartPoint(hlpoint.X, hlpoint.Y);
            _horRightpoint  = new ChartPoint(hrpoint.X, hrpoint.Y);
            _verToppoint    = new ChartPoint(vtpoint.X, vtpoint.Y);
            _verBottompoint = new ChartPoint(vbpoint.X, vbpoint.Y);

            switch (_parentSeries.Mode)
            {
            case ErrorBarMode.Horizontal:
                XRange = new DoubleRange(ChartMath.Min(hlpoint.X, hrpoint.X), ChartMath.Max(hlpoint.X, hrpoint.X));
                YRange = DoubleRange.Empty;
                break;

            case ErrorBarMode.Vertical:
                YRange = new DoubleRange(vbpoint.Y, vtpoint.Y);
                XRange = DoubleRange.Empty;
                break;

            default:
                XRange = new DoubleRange(ChartMath.Min(hlpoint.X, hrpoint.X), ChartMath.Max(hlpoint.X, hrpoint.X));
                YRange = new DoubleRange(vbpoint.Y, vtpoint.Y);
                break;
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Updates the series when the circle coefficient changes.
        /// </summary>
        /// <param name="sender">The Sender</param>
        /// <param name="e">The Dependency Object</param>
        private static void OnCircleCoefficientChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var circularSeriesBase3D = sender as CircularSeriesBase3D;

            if (circularSeriesBase3D != null)
            {
                circularSeriesBase3D.InternalCircleCoefficient = ChartMath.MinMax((double)e.NewValue, 0, 1);
                circularSeriesBase3D.UpdateArea();
            }
        }
Ejemplo n.º 8
0
        private static void OnDoughnutHoleSizeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var chartArea = sender as SfChart;

            if (chartArea != null)
            {
                chartArea.InternalDoughnutHoleSize = ChartMath.MinMax((double)e.NewValue, 0, 1);
                chartArea.ScheduleUpdate();
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// To get the SurfaceHeight for PyramidSeries.
        /// </summary>
        public static double GetSurfaceHeight(double y, double surface)
        {
            double r1, r2;

            if (ChartMath.SolveQuadraticEquation(1, 2 * y, -surface, out r1, out r2))
            {
                return(Math.Max(r1, r2));
            }

            return(double.NaN);
        }
Ejemplo n.º 10
0
        private Point[] GetHitRectPoints(Point point1, Point point2)
        {
            var extendedPoints = new Point[4];

            extendedPoints[0] = ChartMath.CalculatePerpendicularDistantPoint(point1, point2, -GrabExtent);
            extendedPoints[1] = ChartMath.CalculatePerpendicularDistantPoint(point2, point1, GrabExtent);
            extendedPoints[2] = ChartMath.CalculatePerpendicularDistantPoint(point2, point1, -GrabExtent);
            extendedPoints[3] = ChartMath.CalculatePerpendicularDistantPoint(point1, point2, GrabExtent);

            return(extendedPoints);
        }
Ejemplo n.º 11
0
 internal virtual bool IsPointInsideRectangle(Point point)
 {
     if (hitRectPoints != null)
     {
         return(ChartMath.IsPointInsideRectangle(point, hitRectPoints));
     }
     else
     {
         return(false);
     }
 }
Ejemplo n.º 12
0
        private void DrawMultipleDoughnut(IChartTransformer transformer)
        {
            if (IsSegmentVisible)
            {
                var segmentStartAngle = ActualStartAngle;
                var segmentEndAngle   = ActualEndAngle;
                var center            = parentSeries.Center;

                double actualRadius   = parentSeries.InternalDoughnutSize * Math.Min(transformer.Viewport.Width, transformer.Viewport.Height) / 2;
                double remainingWidth = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
                double equalParts     = (remainingWidth / doughnutSegmentsCount) * parentSeries.InternalDoughnutCoefficient;
                double radius         = actualRadius - (equalParts * (doughnutSegmentsCount - (DoughnutSegmentIndex + 1)));
                parentSeries.Radius = actualRadius - equalParts;
                double innerRadius = radius - equalParts;
                double outerRadius = radius - equalParts * parentSeries.SegmentSpacing;
                innerRadius = ChartMath.MaxZero(innerRadius);

                if (parentSeries.Segments.IndexOf(this) == 0)
                {
                    parentSeries.InnerRadius = innerRadius;
                }

                this.pathGeometry     = GetDoughnutGeometry(center, outerRadius, innerRadius, segmentStartAngle, segmentEndAngle, false);
                this.segmentPath.Data = pathGeometry;

                //Rendering the back segments.
                var seriesStartAngle = parentSeries.DegreeToRadianConverter(parentSeries.StartAngle);
                var seriesEndAngle   = parentSeries.DegreeToRadianConverter(parentSeries.EndAngle);

                var totalArcLength = Math.PI * 2;
                var arcLength      = seriesEndAngle - seriesStartAngle;
                if (Math.Abs(Math.Round(arcLength, 2)) > totalArcLength)
                {
                    arcLength = arcLength % totalArcLength;
                }

                seriesEndAngle = arcLength + seriesStartAngle;

                this.circularPathGeometry      = GetDoughnutGeometry(center, outerRadius, innerRadius, seriesStartAngle, seriesEndAngle, true);
                this.CircularDoughnutPath.Data = circularPathGeometry;
            }
            else
            {
                this.pathGeometry     = null;
                this.segmentPath.Data = null;

                this.circularPathGeometry      = null;
                this.CircularDoughnutPath.Data = null;
            }
        }
Ejemplo n.º 13
0
        public override void SetData(ChartPoint hipoint, ChartPoint lopoint, ChartPoint sopoint, ChartPoint eopoint, ChartPoint scpoint, ChartPoint ecpoint, bool isbull)
        {
            this.hipoint  = hipoint;
            this.lowpoint = lopoint;
            this.sopoint  = sopoint;
            this.eopoint  = eopoint;
            this.scpoint  = scpoint;
            this.ecpoint  = ecpoint;
            this.IsBull   = isbull;
            var alignedValues = AlignHiLoSegment(sopoint.Y, scpoint.Y, hipoint.Y, lopoint.Y);

            this.hipoint.Y  = alignedValues[0];
            this.lowpoint.Y = alignedValues[1];
            XRange          = new DoubleRange(ChartMath.Min(scpoint.X, ecpoint.X, sopoint.X, eopoint.X), ChartMath.Max(scpoint.X, ecpoint.X, sopoint.X, eopoint.X));
            YRange          = new DoubleRange(lopoint.Y, hipoint.Y);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Updates the <see cref="ZoomOut"/> icon.
        /// </summary>
        /// <param name="e">The Event Arguments</param>
        protected override void OnPointerPressed(PointerRoutedEventArgs e)
        {
            if (this.Source.ChartArea.AreaType != ChartAreaType.CartesianAxes)
            {
                return;
            }
            bool canZoom     = false;
            int  updatedAxes = 0;

            foreach (ChartAxisBase2D axis in this.Source.ChartArea.Axes)
            {
                if (axis.RegisteredSeries.Count > 0 && (axis.RegisteredSeries[0] as CartesianSeries) != null && (axis.RegisteredSeries[0] as CartesianSeries).IsActualTransposed)
                {
                    if ((axis.Orientation == Orientation.Horizontal && (Source.ZoomMode == ZoomMode.Y || Source.ZoomMode == ZoomMode.XY)) ||
                        (axis.Orientation == Orientation.Vertical && (Source.ZoomMode == ZoomMode.X || Source.ZoomMode == ZoomMode.XY)))
                    {
                        canZoom = true;
                    }
                }
                else
                {
                    if ((axis.Orientation == Orientation.Vertical && (Source.ZoomMode == ZoomMode.Y || Source.ZoomMode == ZoomMode.XY)) ||
                        (axis.Orientation == Orientation.Horizontal && (Source.ZoomMode == ZoomMode.X || Source.ZoomMode == ZoomMode.XY)))
                    {
                        canZoom = true;
                    }
                }

                if (canZoom)
                {
                    var    origin          = 0.5;
                    double currentScale    = Math.Max(1 / ChartMath.MinMax(axis.ZoomFactor, 0, 1), 1);
                    double cumulativeScale = Math.Max(currentScale + (0.25 * -1), 1);
                    Source.Zoom(cumulativeScale, origin > 1d ? 1d : origin < 0d ? 0d : origin, axis);
                }

                canZoom = false;
                if (axis.ZoomFactor == 1 || axis.ZoomPosition == 0)
                {
                    updatedAxes++;
                }
            }

            e.Handled = true;
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Calculates actual range
        /// </summary>
        /// <param name="axis">The axis.</param>
        /// <param name="range">The range.</param>
        /// <param name="logarithmicBase">The logarithmic base.</param>
        /// <returns></returns>
        internal static DoubleRange CalculateActualRange(ChartAxis axis, DoubleRange range, double logarithmicBase)
        {
            if (range.IsEmpty)
            {
                return(range);
            }
            double logStart = Math.Log(range.Start, logarithmicBase);

            logStart = double.IsInfinity(logStart) || double.IsNaN(logStart) ? range.Start : logStart;
            double logEnd = Math.Log(range.End, logarithmicBase);

            logEnd = double.IsInfinity(logEnd) || double.IsNaN(logEnd) ? logarithmicBase : logEnd;

            double mulS = ChartMath.Round(logStart, 1, false);
            double mulE = ChartMath.Round(logEnd, 1, true);

            range = new DoubleRange(mulS, mulE);

            return(range);
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Creates the point.
        /// </summary>
        protected override void CreatePoints()
        {
            if (Area.RootPanelDesiredSize != null)
            {
                this.actualWidth  = Area.RootPanelDesiredSize.Value.Width;
                this.actualHeight = Area.RootPanelDesiredSize.Value.Height;
            }

            var doughnutIndex = GetPieSeriesIndex();
            var doughnutCount = GetCircularSeriesCount();

            double actualRadius   = InternalCircleCoefficient * Math.Min(actualWidth, actualHeight) / 2;
            double remainingWidth = actualRadius - (actualRadius * Area.InternalDoughnutHoleSize);
            double equalParts     = remainingWidth / doughnutCount;

            this.Radius      = actualRadius - (equalParts * (doughnutCount - (doughnutIndex + 1)));
            this.InnerRadius = this.Radius - (equalParts * this.InternlDoughnutCoefficient);
            this.InnerRadius = ChartMath.MaxZero(this.InnerRadius);

            base.CreatePoints();
        }
Ejemplo n.º 17
0
        private void DrawSingleDoughnut(IChartTransformer transformer)
        {
            var   segmentStartAngle = ActualStartAngle;
            var   segmentEndAngle   = ActualEndAngle;
            Point center;

            if (doughnutSeriesCount > 1)
            {
                center = new Point(0.5 * transformer.Viewport.Width, 0.5 * transformer.Viewport.Height);
            }
            else
            {
                center = parentSeries.Center;
            }

            CalculateGapRatioAngle(ref segmentEndAngle, ref segmentStartAngle);

            double actualRadius   = parentSeries.InternalDoughnutSize * Math.Min(transformer.Viewport.Width, transformer.Viewport.Height) / 2;
            double remainingWidth = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
            double equalParts     = remainingWidth / doughnutSeriesCount;
            double radius         = parentSeries.Radius = actualRadius - (equalParts * (doughnutSeriesCount - (doughnutSeriesIndex + 1)));
            double innerRadius    = radius - (equalParts * parentSeries.InternalDoughnutCoefficient);

            innerRadius = ChartMath.MaxZero(innerRadius);

            if (parentSeries.Segments.IndexOf(this) == 0)
            {
                parentSeries.InnerRadius = innerRadius;
            }

            this.pathGeometry     = GetDoughnutGeometry(center, radius, innerRadius, segmentStartAngle, segmentEndAngle, false);
            this.segmentPath.Data = pathGeometry;

            this.circularPathGeometry      = null;
            this.CircularDoughnutPath.Data = null;
        }
Ejemplo n.º 18
0
        private void TransformToScreenCoVertical()
        {
            Points = new PointCollection();
            double prevXValue    = 0;
            double prevYValue    = 0;
            int    i             = 0;
            double yCoefficient  = 0;
            var    numericalAxis = fastSeries.ActualYAxis as NumericalAxis;
            bool   isScaleBreak  = numericalAxis != null && numericalAxis.AxisRanges != null && numericalAxis.AxisRanges.Count > 0;

            xValues = (Series.ActualXValues is List <double> && !Series.IsIndexed) ? Series.ActualXValues as List <double> : Series.GetXValues();
            var isGrouping = (fastSeries.ActualXAxis is CategoryAxis) ? (fastSeries.ActualXAxis as CategoryAxis).IsIndexed : true;

            int startIndex = 0;

            prevXValue = fastSeries.IsIndexed ? 1 : xChartVals[0];
            prevYValue = yChartVals[0];
            int cnt = xChartVals.Count - 1;

            if (fastSeries.isLinearData)
            {
                for (i = 1; i < cnt; i++)
                {
                    double xVal = xChartVals[i];
                    double yVal = yChartVals[i];

                    if ((xVal <= xEnd) && (xVal >= xStart))
                    {
                        if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                        {
                            yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
                            Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
                            prevXValue = xVal;
                            prevYValue = yVal;
                        }
                    }
                    else if (xVal < xStart)
                    {
                        if (x_isInversed)
                        {
                            yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
                            Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
                        }
                        else
                        {
                            startIndex = i;
                        }
                    }
                    else if (xVal > xEnd)
                    {
                        double yValue = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yChartVals[i], xEnd);
                        yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yValue) : 1 - ((yEnd - yValue) / yDelta));
                        Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset)));
                        break;
                    }
                }
            }
            else
            {
                for (i = 1; i < cnt; i++)
                {
                    double xVal = xChartVals[i];
                    double yVal = yChartVals[i];
                    if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                    {
                        yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yVal) : 1 - ((yEnd - yVal) / yDelta));
                        Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xVal) / xDelta))));
                        prevXValue = xVal;
                        prevYValue = yVal;
                    }
                }
            }

            if (startIndex > 0)
            {
                double yValue = ChartMath.GetInterpolarationPoint(xChartVals[startIndex], xChartVals[startIndex + 1], yChartVals[startIndex], yChartVals[startIndex + 1], xStart);
                yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yValue) : 1 - ((yEnd - yValue) / yDelta));
                Points.Insert(0, new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xStart) / xDelta))));
            }
            else
            {
                yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yChartVals[startIndex]) : 1 - ((yEnd - yChartVals[startIndex]) / yDelta));
                Points.Insert(0, new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xChartVals[startIndex]) / xDelta))));
            }

            if (i == cnt)
            {
                yCoefficient = (isScaleBreak ? numericalAxis.CalculateValueToCoefficient(yChartVals[cnt]) : 1 - ((yEnd - yChartVals[cnt]) / yDelta));
                Points.Add(new Point((yOffset + ySize * yCoefficient), (xOffset + xSize * ((xEnd - xChartVals[cnt]) / xDelta))));
            }
        }
Ejemplo n.º 19
0
        /// <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">Represents the view port of chart control.(refer <see cref="IChartTransformer"/>)</param>

        public override void Update(IChartTransformer transformer)
        {
            double radius       = Radius;
            double actualRadius = Math.Min(transformer.Viewport.Width, transformer.Viewport.Height) / 2;

            if (Series is DoughnutSeries3D)
            {
                var    hostSeries          = Series as DoughnutSeries3D;
                double doughnutSeriesCount = hostSeries.GetCircularSeriesCount();
                actualRadius *= hostSeries.InternalCircleCoefficient;
                Point center = hostSeries.Center;
                if (doughnutSeriesCount > 1)
                {
                    center = new Point(transformer.Viewport.Width / 2, transformer.Viewport.Height / 2);
                }
                double remainingWidth = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
                double equalParts     = remainingWidth / doughnutSeriesCount;
                double innerRadius    = radius - (equalParts * hostSeries.InternlDoughnutCoefficient);
                innerRadius = ChartMath.MaxZero(innerRadius);

                if (hostSeries.ExplodeIndex == hostSeries.Segments.Count - 1 || hostSeries.ExplodeAll)
                {
                    var rect = new Rect(0, 0, transformer.Viewport.Width, transformer.Viewport.Height);
                    center = hostSeries.GetActualCenter(new Point(rect.X + rect.Width / 2, rect.Y + rect.Height / 2), Radius);
                }
                if (hostSeries != null && hostSeries.LabelPosition == CircularSeriesLabelPosition.Inside)
                {
                    double difference = (radius - innerRadius) / 2;
                    radius -= difference;
                }

                this.X = center.X + radius * Math.Cos(Angle);
                this.Y = center.Y + radius * Math.Sin(Angle);
            }

            else if (Series is PieSeries3D)
            {
                var    hostSeries     = Series as PieSeries3D;
                Point  center         = hostSeries.Center;
                double pieSeriesCount = hostSeries.GetCircularSeriesCount();
                double equalParts     = actualRadius / pieSeriesCount;
                double innerRadius    = equalParts * pieIndex;

                if (hostSeries.ExplodeIndex == hostSeries.Segments.Count - 1 || hostSeries.ExplodeAll)
                {
                    var rect = new Rect(0, 0, transformer.Viewport.Width, transformer.Viewport.Height);
                    center = hostSeries.GetActualCenter(new Point(rect.X + rect.Width / 2, rect.Y + rect.Height / 2), Radius);
                }
                if (hostSeries != null && hostSeries.LabelPosition == CircularSeriesLabelPosition.Inside)
                {
                    if (pieIndex == 0)
                    {
                        radius = radius / 2;
                    }
                    else
                    {
                        double difference = (radius - innerRadius) / 2;
                        radius -= difference;
                    }
                }
                this.X = center.X + radius * Math.Cos(Angle);
                this.Y = center.Y + radius * Math.Sin(Angle);
            }
            this.ActualStartDepth = this.StartDepth;
        }
        void TransformToScreenCo(ChartTransform.ChartCartesianTransformer cartesianTransformer)
        {
            int    i            = 0;
            bool   x_isInversed = cartesianTransformer.XAxis.IsInversed;
            bool   y_isInversed = cartesianTransformer.YAxis.IsInversed;
            double xStart       = cartesianTransformer.XAxis.VisibleRange.Start;
            double xEnd         = cartesianTransformer.XAxis.VisibleRange.End;
            double yStart       = cartesianTransformer.YAxis.VisibleRange.Start;
            double yEnd         = cartesianTransformer.YAxis.VisibleRange.End;
            double xDelta       = x_isInversed ? xStart - xEnd : xEnd - xStart;
            double yDelta       = y_isInversed ? yStart - yEnd : yEnd - yStart;

            double width  = cartesianTransformer.XAxis.RenderedRect.Width;
            double height = cartesianTransformer.YAxis.RenderedRect.Height;

            availableSize = new Size(width, height);

            double xTolerance = Math.Abs((xDelta * 1) / availableSize.Width);
            double yTolerance = Math.Abs((yDelta * 1) / availableSize.Height);
            double left       = cartesianTransformer.XAxis.RenderedRect.Left - fastSeries.Area.SeriesClipRect.Left;
            double top        = cartesianTransformer.YAxis.RenderedRect.Top - fastSeries.Area.SeriesClipRect.Top;
            int    count      = (int)(Math.Ceiling(xEnd));
            int    start      = (int)(Math.Floor(xStart));

            if (x_isInversed)
            {
                double temp = xStart;
                xStart = xEnd;
                xEnd   = temp;
            }

            if (y_isInversed)
            {
                double temp = yStart;
                yStart = yEnd;
                yEnd   = temp;
            }
            if (RenderingMode == RenderingMode.Default)
            {
                Points = new PointCollection();
                double xValue     = 0;
                double yValue     = 0;
                double prevXValue = 0;
                double prevYValue = 0;

                if (fastSeries.IsIndexed)
                {
                    int length = Length - 1;
                    start = start > length ? start : length;
                    start = start < 0 ? 0 : start;
                    count = count > yChartVals.Count ? yChartVals.Count : count;
                    for (i = start; i <= count; i++)
                    {
                        double xVal = 0;
                        double yVal = 0;
                        if (i >= 0 && i < yChartVals.Count)
                        {
                            xVal = xChartVals[i];
                            yVal = yChartVals[i];
                        }
                        else
                        {
                            continue;
                        }
                        if (Math.Abs(prevXValue - i) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                        {
                            if (xVal <= xEnd && xVal >= xStart)
                            {
                                xValue = left + (availableSize.Width * ((i - xStart) / xDelta));
                                yValue = top + (availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                                Points.Add(new Point(xValue, yValue));
                            }

                            else if (xVal < xStart && i + 1 < yChartVals.Count)
                            {
                                double y = ChartMath.GetInterpolarationPoint(xChartVals[i], xChartVals[i + 1], yVal, yChartVals[i + 1], xStart);

                                xValue = left;
                                yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
                                Points.Add(new Point(xValue, yValue));
                            }
                            else if (xVal > xEnd && i - 1 > 0)
                            {
                                double y = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yVal, xEnd);

                                xValue = left + availableSize.Width;
                                yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
                                Points.Add(new Point(xValue, yValue));
                            }

                            prevXValue = i;
                            prevYValue = yVal;
                        }
                    }
                }
                else
                {
                    int startIndex = 0;
                    for (i = Length - 1; i < xChartVals.Count; i++)
                    {
                        double xVal = xChartVals[i];
                        double yVal = yChartVals[i];

                        if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                        {
                            if ((xVal <= xEnd) && (xVal >= xStart))
                            {
                                xValue = left + (availableSize.Width * ((xVal - xStart) / xDelta));
                                yValue = top + (availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                                Points.Add(new Point(xValue, yValue));
                            }

                            else if (xVal < xStart)
                            {
                                startIndex = i;
                            }
                            else if (xVal > xEnd)
                            {
                                if (i - 1 > -1)
                                {
                                    double y = ChartMath.GetInterpolarationPoint(xChartVals[i - 1], xChartVals[i], yChartVals[i - 1], yVal, xEnd);

                                    xValue = left + availableSize.Width;
                                    yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
                                    Points.Add(new Point(xValue, yValue));
                                    break;
                                }
                            }
                        }
                        prevXValue = xVal;
                        prevYValue = yVal;
                    }

                    if (startIndex > 0)
                    {
                        if (startIndex + 1 < xChartVals.Count)
                        {
                            double y = ChartMath.GetInterpolarationPoint(xChartVals[startIndex], xChartVals[startIndex + 1], yChartVals[startIndex], yChartVals[startIndex + 1], xStart);

                            xValue = left;
                            yValue = top + (availableSize.Height * (1 - ((y - yStart) / yDelta)));
                            Points.Insert(0, new Point(xValue, yValue));
                        }
                    }
                }
            }
            else
            {
                xValues.Clear();
                yValues.Clear();
                double prevXValue = 0;
                double prevYValue = 0;
                float  xValue     = 0;
                float  yValue     = 0;
                if (fastSeries.IsIndexed)
                {
                    prevXValue = 1;
                    for (i = start; i <= count; i++)
                    {
                        double yVal = yChartVals[i];

                        if (Math.Abs(prevXValue - i) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                        {
                            xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
                            yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                            xValues.Add(xValue);
                            yValues.Add(yValue);
                            prevXValue = i;
                            prevYValue = yVal;
                        }
                    }

                    if (start > 0)
                    {
                        i = start - 1;
                        double yVal = yChartVals[i];
                        xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
                        yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                        xValues.Insert(0, xValue);
                        yValues.Insert(0, yValue);
                    }

                    if (count < yChartVals.Count - 1)
                    {
                        i = count + 1;
                        double yVal = yChartVals[i];
                        xValue = (float)(left + availableSize.Width * ((i - xStart) / xDelta));
                        yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                        xValues.Add(xValue);
                        yValues.Add(yValue);
                    }
                }
                else
                {
                    int startIndex = 0;
                    for (i = Length - 1; i < xChartVals.Count; i++)
                    {
                        double xVal = xChartVals[i];
                        double yVal = yChartVals[i];

                        if ((xVal <= count) && (xVal >= start))
                        {
                            if (Math.Abs(prevXValue - xVal) >= xTolerance || Math.Abs(prevYValue - yVal) >= yTolerance)
                            {
                                xValue = (float)(left + availableSize.Width * ((xVal - xStart) / xDelta));
                                yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                                xValues.Add(xValue);
                                yValues.Add(yValue);
                                prevXValue = xVal;
                                prevYValue = yVal;
                            }
                        }
                        else if (xVal < start)
                        {
                            startIndex = i;
                        }
                        else if (xVal > count)
                        {
                            xValue = (float)(left + availableSize.Width * ((xVal - xStart) / xDelta));
                            yValue = (float)(top + availableSize.Height * (1 - ((yVal - yStart) / yDelta)));
                            xValues.Add(xValue);
                            yValues.Add(yValue);
                            break;
                        }
                    }

                    if (startIndex > 0)
                    {
                        xValue = (float)(left + availableSize.Width * ((xChartVals[startIndex] - xStart) / xDelta));
                        yValue = (float)(top + availableSize.Height * (1 - ((yChartVals[startIndex] - yStart) / yDelta)));
                        xValues.Insert(0, xValue);
                        yValues.Insert(0, yValue);
                    }
                }
            }
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Creates the segments of <see cref="FastRangeAreaBitmapSeries"/>.
        /// </summary>
        public override void CreateSegments()
        {
            ChartPoint point1;
            ChartPoint point2;
            ChartPoint point3;
            ChartPoint point4;

            ChartPoint?       crossPoint = null;
            List <ChartPoint> segPoints  = new List <ChartPoint>();

            List <double> xValues = null;

            if (ActualXAxis is CategoryAxis && !(ActualXAxis as CategoryAxis).IsIndexed)
            {
                xValues = GroupedXValuesIndexes;
            }
            else
            {
                xValues = GetXValues();
            }

            if (xValues != null)
            {
                bool isGrouping = this.ActualXAxis is CategoryAxis ? (this.ActualXAxis as CategoryAxis).IsIndexed : true;
                if (!isGrouping)
                {
                    Segments.Clear();
                    Adornments.Clear();
                    if (double.IsNaN(GroupedSeriesYValues[1][0]) || !double.IsNaN(GroupedSeriesYValues[0][0]))
                    {
                        segPoints.Add(new ChartPoint(xValues[0], GroupedSeriesYValues[1][0]));
                        segPoints.Add(new ChartPoint(xValues[0], GroupedSeriesYValues[0][0]));
                        var segment = new FastRangeAreaSegment(segPoints, false, this)
                        {
                            High = GroupedSeriesYValues[0][0],
                            Low  = GroupedSeriesYValues[1][0],
                            Item = ActualData[0]
                        };

                        AddSegment(segment, segPoints);
                    }

                    segPoints = new List <ChartPoint>();
                    int i;

                    for (i = 0; i < xValues.Count - 1; i++)
                    {
                        if (!double.IsNaN(GroupedSeriesYValues[1][i]) && !double.IsNaN(GroupedSeriesYValues[0][i]))
                        {
                            point1 = new ChartPoint(xValues[i], GroupedSeriesYValues[1][i]);
                            point3 = new ChartPoint(xValues[i], GroupedSeriesYValues[0][i]);

                            if (i == 0 || (i < xValues.Count - 1 && (double.IsNaN(GroupedSeriesYValues[1][i - 1]) || double.IsNaN(GroupedSeriesYValues[0][i - 1]))))
                            {
                                segPoints.Add(point1);
                                segPoints.Add(point3);
                            }

                            if (!double.IsNaN(GroupedSeriesYValues[1][i + 1]) && !double.IsNaN(GroupedSeriesYValues[0][i + 1]))
                            {
                                point2 = new ChartPoint(xValues[i + 1], GroupedSeriesYValues[1][i + 1]);
                                point4 = new ChartPoint(xValues[i + 1], GroupedSeriesYValues[0][i + 1]);

                                // UWP-8718 Use ChartMath.GetCrossPoint since it returns the ChartDataPoint withou rounding the values.
                                crossPoint = ChartMath.GetCrossPoint(point1, point2, point3, point4);

                                if (crossPoint != null)
                                {
                                    var crossPointValue = new ChartPoint(crossPoint.Value.X, crossPoint.Value.Y);
                                    segPoints.Add(crossPointValue);
                                    segPoints.Add(crossPointValue);
                                    var segment = new FastRangeAreaSegment(segPoints, (GroupedSeriesYValues[1][i] > GroupedSeriesYValues[0][i]), this)
                                    {
                                        High = GroupedSeriesYValues[0][i],
                                        Low  = GroupedSeriesYValues[1][i],
                                        Item = ActualData[i]
                                    };

                                    AddSegment(segment, segPoints);
                                    segPoints = new List <ChartPoint>();
                                    segPoints.Add(crossPointValue);
                                    segPoints.Add(crossPointValue);
                                }

                                segPoints.Add(point2);
                                segPoints.Add(point4);
                            }
                            else if (i != 0 && !double.IsNaN(GroupedSeriesYValues[1][i - 1]) && !double.IsNaN(GroupedSeriesYValues[0][i - 1]))
                            {
                                segPoints.Add(point1);
                                segPoints.Add(point3);
                            }
                        }
                        else
                        {
                            if (segPoints.Count > 0)
                            {
                                if (!double.IsNaN(GroupedSeriesYValues[1][i - 1]) && !double.IsNaN(GroupedSeriesYValues[0][i - 1]))
                                {
                                    var segment = new FastRangeAreaSegment(segPoints, false, this)
                                    {
                                        High = GroupedSeriesYValues[0][i - 1],
                                        Low  = GroupedSeriesYValues[1][i - 1],
                                        Item = ActualData[i - 1]
                                    };

                                    AddSegment(segment, segPoints);
                                }
                            }

                            segPoints = new List <ChartPoint>();
                        }
                    }

                    if (segPoints.Count > 0)
                    {
                        var segment = new FastRangeAreaSegment(segPoints, (GroupedSeriesYValues[1][i] > GroupedSeriesYValues[0][i]), this)
                        {
                            High = GroupedSeriesYValues[0][i],
                            Low  = GroupedSeriesYValues[1][i],
                            Item = ActualData[i]
                        };

                        AddSegment(segment, segPoints);
                    }
                    else if (i == xValues.Count - 1 && (double.IsNaN(GroupedSeriesYValues[1][i]) || double.IsNaN(GroupedSeriesYValues[0][i])))
                    {
                        segPoints.Add(new ChartPoint(xValues[i], GroupedSeriesYValues[1][i]));
                        segPoints.Add(new ChartPoint(xValues[i], GroupedSeriesYValues[0][i]));
                        var segment = new FastRangeAreaSegment(segPoints, false, this)
                        {
                            High = GroupedSeriesYValues[0][i],
                            Low  = GroupedSeriesYValues[1][i],
                            Item = ActualData[i]
                        };

                        AddSegment(segment, segPoints);
                    }

                    for (int j = 0; j < xValues.Count; j++)
                    {
                        if (AdornmentsInfo != null)
                        {
                            AddAdornments(xValues[j], 0, GroupedSeriesYValues[0][j], GroupedSeriesYValues[1][j], j);
                        }
                    }
                }
                else
                {
                    Segments.Clear();
                    if (AdornmentsInfo != null)
                    {
                        if (AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.TopAndBottom)
                        {
                            ClearUnUsedAdornments(this.DataCount * 2);
                        }
                        else
                        {
                            ClearUnUsedAdornments(this.DataCount);
                        }
                    }

                    if (xValues != null)
                    {
                        if (double.IsNaN(LowValues[0]) || double.IsNaN(HighValues[0]))
                        {
                            segPoints.Add(new ChartPoint(xValues[0], LowValues[0]));
                            segPoints.Add(new ChartPoint(xValues[0], HighValues[0]));
                            var segment = new FastRangeAreaSegment(segPoints, false, this)
                            {
                                High = HighValues[0],
                                Low  = LowValues[0],
                                Item = ActualData[0]
                            };

                            AddSegment(segment, segPoints);
                        }

                        segPoints = new List <ChartPoint>();
                        int i;
                        for (i = 0; i < DataCount - 1; i++)
                        {
                            if (!double.IsNaN(LowValues[i]) && !double.IsNaN(HighValues[i]))
                            {
                                point1 = new ChartPoint(xValues[i], LowValues[i]);
                                point3 = new ChartPoint(xValues[i], HighValues[i]);

                                if (i == 0 || (i < DataCount - 1 && (double.IsNaN(LowValues[i - 1]) || double.IsNaN(HighValues[i - 1]))))
                                {
                                    segPoints.Add(point1);
                                    segPoints.Add(point3);
                                }

                                if (!double.IsNaN(LowValues[i + 1]) && !double.IsNaN(HighValues[i + 1]))
                                {
                                    point2 = new ChartPoint(xValues[i + 1], LowValues[i + 1]);
                                    point4 = new ChartPoint(xValues[i + 1], HighValues[i + 1]);

                                    // UWP-8718 Use ChartMath.GetCrossPoint since it returns the ChartDataPoint withou rounding the values.
                                    crossPoint = ChartMath.GetCrossPoint(point1, point2, point3, point4);

                                    if (crossPoint != null)
                                    {
                                        var crossPointValue = new ChartPoint(crossPoint.Value.X, crossPoint.Value.Y);
                                        segPoints.Add(crossPointValue);
                                        segPoints.Add(crossPointValue);
                                        var segment = new FastRangeAreaSegment(segPoints, (LowValues[i] > HighValues[i]), this)
                                        {
                                            High = HighValues[i],
                                            Low  = LowValues[i],
                                            Item = ActualData[i]
                                        };

                                        AddSegment(segment, segPoints);
                                        segPoints = new List <ChartPoint>();
                                        segPoints.Add(crossPointValue);
                                        segPoints.Add(crossPointValue);
                                    }

                                    segPoints.Add(point2);
                                    segPoints.Add(point4);
                                }
                            }
                            else
                            {
                                if (segPoints.Count > 0)
                                {
                                    if (!double.IsNaN(LowValues[i - 1]) && !double.IsNaN(HighValues[i - 1]))
                                    {
                                        var segment = new FastRangeAreaSegment(segPoints, false, this)
                                        {
                                            High = HighValues[i - 1],
                                            Low  = LowValues[i - 1],
                                            Item = ActualData[i - 1]
                                        };

                                        AddSegment(segment, segPoints);
                                    }
                                }

                                segPoints = new List <ChartPoint>();
                            }
                        }

                        if (segPoints.Count > 0)
                        {
                            var segment = new FastRangeAreaSegment(segPoints, (LowValues[i] > HighValues[i]), this)
                            {
                                High = HighValues[i],
                                Low  = LowValues[i],
                                Item = ActualData[i]
                            };

                            AddSegment(segment, segPoints);
                        }
                        else if (i == DataCount - 1 && (double.IsNaN(LowValues[i]) || double.IsNaN(HighValues[i])))
                        {
                            segPoints.Add(new ChartPoint(xValues[i], LowValues[i]));
                            segPoints.Add(new ChartPoint(xValues[i], HighValues[i]));
                            var segment = new FastRangeAreaSegment(segPoints, false, this)
                            {
                                High = HighValues[i],
                                Low  = LowValues[i],
                                Item = ActualData[i]
                            };

                            AddSegment(segment, segPoints);
                        }
                    }

                    for (int i = 0; i < xValues.Count; i++)
                    {
                        if (AdornmentsInfo != null)
                        {
                            AddAdornments(xValues[i], 0, HighValues[i], LowValues[i], i);
                        }
                    }
                }
            }

            // Updates the stroke rendering for empty points.
            if (Segments.Count > 1)
            {
                UpdateEmptyPointSegments();
            }
        }
Ejemplo n.º 22
0
        /// <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)
        {
            double radius       = Radius;
            double actualRadius = Math.Min(transformer.Viewport.Width, transformer.Viewport.Height) / 2;

            if (Series is PieSeries)
            {
                var    hostSeries     = Series as PieSeries;
                double pieSeriesCount = hostSeries.GetPieSeriesCount();
                double equalParts     = actualRadius / pieSeriesCount;
                double innerRadius    = equalParts * pieIndex;

                Point center;
                if (pieSeriesCount == 1)
                {
                    center = hostSeries.Center;
                }
                else
                {
                    center = ChartLayoutUtils.GetCenter(transformer.Viewport);
                }

                if (hostSeries != null && hostSeries.LabelPosition == CircularSeriesLabelPosition.Inside)
                {
                    if (pieIndex > 0)
                    {
                        double difference = (radius - innerRadius) / 2;
                        radius = radius - difference;
                    }
                    else
                    {
                        radius = radius / 2;
                    }
                }

                this.X = center.X + radius * Math.Cos(Angle);
                this.Y = center.Y + radius * Math.Sin(Angle);
            }
            else if (Series is DoughnutSeries)
            {
                var hostSeries = Series as DoughnutSeries;

                actualRadius *= hostSeries.InternalDoughnutSize;

                Point  center;
                double remainingWidth = 0d, equalParts = 0d, innerRadius = 0d;
                var    adornmentAngle = Angle;

                if (hostSeries.IsStackedDoughnut)
                {
                    var adornmentIndex        = Series.Adornments.IndexOf(this);
                    var doughnutSegment       = hostSeries.Segments[adornmentIndex] as DoughnutSegment;
                    int doughnutSegmentsCount = hostSeries.Segments.Count;
                    center              = hostSeries.Center;
                    remainingWidth      = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
                    equalParts          = (remainingWidth / doughnutSegmentsCount) * hostSeries.InternalDoughnutCoefficient;
                    radius              = actualRadius - (equalParts * (doughnutSegmentsCount - (doughnutSegment.DoughnutSegmentIndex + 1)));
                    InnerDoughnutRadius = innerRadius = radius - equalParts;
                    radius              = radius - equalParts * hostSeries.SegmentSpacing;
                    Radius              = radius;
                    innerRadius         = ChartMath.MaxZero(innerRadius);

                    double difference = (radius - innerRadius) / 2;
                    radius = radius - difference;

                    adornmentAngle = hostSeries.LabelPosition == CircularSeriesLabelPosition.Outside ? doughnutSegment.StartAngle : hostSeries.LabelPosition == CircularSeriesLabelPosition.OutsideExtended ? doughnutSegment.EndAngle : Angle;
                }
                else
                {
                    int doughnutSeriesCount = hostSeries.GetDoughnutSeriesCount();
                    center              = doughnutSeriesCount == 1 ? hostSeries.Center : ChartLayoutUtils.GetCenter(transformer.Viewport);
                    remainingWidth      = actualRadius - (actualRadius * Series.ActualArea.InternalDoughnutHoleSize);
                    equalParts          = remainingWidth / doughnutSeriesCount;
                    InnerDoughnutRadius = innerRadius = radius - (equalParts * hostSeries.InternalDoughnutCoefficient);
                    innerRadius         = ChartMath.MaxZero(innerRadius);

                    if (hostSeries != null && hostSeries.LabelPosition == CircularSeriesLabelPosition.Inside)
                    {
                        double difference = (radius - innerRadius) / 2;
                        radius = radius - difference;
                    }
                }

                this.X = center.X + radius * Math.Cos(adornmentAngle);
                this.Y = center.Y + radius * Math.Sin(adornmentAngle);
            }
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Creates the segments of HistogramSeries.
        /// </summary>
        public override void CreateSegments()
        {
            List <double> xValues = GetXValues();
            int           index = 0;
            double        x1, y1, y2;
            float         median;

            double origin = ActualXAxis != null ? ActualXAxis.Origin : 0;

            if (ActualXAxis != null && ActualXAxis.Origin == 0 && ActualYAxis is LogarithmicAxis &&
                (ActualYAxis as LogarithmicAxis).Minimum != null)
            {
                origin = (double)(ActualYAxis as LogarithmicAxis).Minimum;
            }

            if (xValues != null)
            {
                Segments.Clear();
                ClearUnUsedAdornments(Segments.Count);
                ActualYValues.Clear();

                List <Point> dataPoints = new List <Point>();

                List <ChartSegment> segmentsCollection = new List <ChartSegment>();

                for (int i = 0; i < DataCount; i++)
                {
                    dataPoints.Add(new Point(xValues[i], yValues[i]));
                }

                Array.Sort(dataPoints.ToArray(), new PointsSortByXComparer());

                double interval = HistogramInterval;
                double start    = 0;

                if (dataPoints.Count > 0)
                {
                    start = ChartMath.Round(dataPoints[0].X, interval, false);
                }

                int              pointsCount;
                double           position       = start;
                int              intervalsCount = 0;
                List <Point>     points         = new List <Point>();
                List <object>    data           = new List <object>();
                HistogramSegment histogramSegment;

                for (int i = 0, ci = dataPoints.Count; i < ci; i++)
                {
                    Point cdpt = dataPoints[i];

                    while (cdpt.X > position + interval)
                    {
                        pointsCount = points.Count;
                        if (pointsCount > 0)
                        {
                            histogramSegment       = new HistogramSegment(position, pointsCount, position + interval, 0, this);
                            histogramSegment.XData = index;
                            histogramSegment.YData = pointsCount;
                            histogramSegment.Data  = data;
                            data = new List <object>();
                            segmentsCollection.Add(histogramSegment);
                            ActualYValues.Add(pointsCount);
                            points.Clear();
                            index++;
                        }

                        position += interval;
                        intervalsCount++;
                    }

                    points.Add(dataPoints[i]);
                    data.Add(ActualData[i]);
                }

                pointsCount = points.Count;
                if (pointsCount > 0)
                {
                    intervalsCount++;
                    histogramSegment       = new HistogramSegment(position, pointsCount, position + interval, 0, this);
                    histogramSegment.XData = index;
                    histogramSegment.YData = pointsCount;
                    histogramSegment.Data  = data;
                    data = new List <object>();
                    segmentsCollection.Add(histogramSegment);
                    ActualYValues.Add(pointsCount);
                    points.Clear();
                }

                median = (float)interval / 2;

                if (AdornmentsInfo != null)
                {
                    for (int i = 0; i < segmentsCollection.Count; i++)
                    {
                        x1 = (segmentsCollection[i] as HistogramSegment).XRange.Start;
                        y1 = (segmentsCollection[i] as HistogramSegment).YData;
                        y2 = origin;

                        if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.Top)
                        {
                            AddColumnAdornments(
                                (segmentsCollection[i] as HistogramSegment).XData,
                                (segmentsCollection[i] as HistogramSegment).YData,
                                x1,
                                y1,
                                i,
                                median);
                        }
                        else if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.Bottom)
                        {
                            AddColumnAdornments(
                                (segmentsCollection[i] as HistogramSegment).XData,
                                (segmentsCollection[i] as HistogramSegment).YData,
                                x1,
                                y2,
                                i,
                                median);
                        }
                        else
                        {
                            AddColumnAdornments(
                                (segmentsCollection[i] as HistogramSegment).XData,
                                (segmentsCollection[i] as HistogramSegment).YData,
                                x1,
                                y1 + (y2 - y1) / 2,
                                i,
                                median);
                        }
                    }
                }

                #region Normal Distribution

                if (ShowNormalDistributionCurve)
                {
                    double m, dev;
                    GetHistogramMeanAndDeviation(dataPoints, out m, out dev);

                    PointCollection distributionPoints = new PointCollection();

                    double min = start;
                    double max = start + intervalsCount * interval;
                    double del = (max - min) / (C_distributionPointsCount - 1);

                    for (int i = 0; i < C_distributionPointsCount; i++)
                    {
                        double tx = min + i * del;
                        double ty = NormalDistribution(tx, m, dev) * dataPoints.Count * interval;
                        distributionPoints.Add(new Point(tx, ty));
                    }

                    segmentsCollection.Add(new HistogramDistributionSegment(distributionPoints, this));
                }

                foreach (var item in segmentsCollection)
                {
                    Segments.Add(item);
                }

                #endregion
            }
        }