Example #1
0
        /// <summary>
        /// Set up axis manager and calculate axis values
        /// </summary>
        private void SetUpAxisManager()
        {
            // Get the minimum and maximum value dependeing on the axis representation value
            Minimum = AxisRepresentation == AxisRepresentations.AxisX ? PlotDetails.GetAxisXMinimumDataValue(this) : PlotDetails.GetAxisYMinimumDataValue(this);
            Maximum = AxisRepresentation == AxisRepresentations.AxisX ? PlotDetails.GetAxisXMaximumDataValue(this) : PlotDetails.GetAxisYMaximumDataValue(this);

            Boolean overflowValidity = (AxisRepresentation == AxisRepresentations.AxisX);
            Boolean stackingOverride = PlotDetails.GetStacked100OverrideState();

            // Create and initialize the AxisManagers
            AxisManager = new AxisManager(Maximum, Minimum, (Boolean)StartFromZero, overflowValidity, stackingOverride, AxisRepresentation);

            // Set the include zero state
            AxisManager.IncludeZero = IncludeZero;

            // settings specific to axis X
            if (AxisRepresentation == AxisRepresentations.AxisX)
            {
                Double interval = GenerateDefaultInterval();

                if (IsDateTimeAxis)
                {
                    if (interval > 0 || !Double.IsNaN(interval))
                    {
                        AxisManager.Interval = interval;
                        InternalInterval = interval;
                    }
                    else
                    {
                        // if interval is greater than zero then set the interval of the axis manager
                        if (Interval > 0 || !Double.IsNaN((Double)Interval))
                        {
                            AxisManager.Interval = (Double)Interval;
                            InternalInterval = (Double)Interval;
                        }
                    }
                }
                else if (interval > 0 || !Double.IsNaN(interval))
                {
                    AxisManager.Interval = interval;
                    InternalInterval = interval;
                }
            }
            else
            {
                // if interval is greater than zero then set the interval of the axis manager
                if (Interval > 0 || !Double.IsNaN((Double)Interval))
                {
                    AxisManager.Interval = (Double)Interval;
                    InternalInterval = (Double)Interval;
                }
            }

            // set the axis maximum value if user has provided it
            if (!Double.IsNaN((Double)AxisMaximumNumeric))
            {
                AxisManager.AxisMaximumValue = (Double)AxisMaximumNumeric;
                InternalAxisMaximum = (Double)AxisMaximumNumeric;
            }

            // set the axis minimum value if the user has provided it
            if (!Double.IsNaN((Double)AxisMinimumNumeric))
            {
                AxisManager.AxisMinimumValue = (Double)AxisMinimumNumeric;
                InternalAxisMinimum = (Double)AxisMinimumNumeric;
            }

            // Calculate the various parameters for creating the axis
            AxisManager.Calculate();

            // Set axis specific limits based on axis limits.
            // if (AxisRepresentation == AxisRepresentations.AxisX && !(Boolean)StartFromZero)
            //      if (!SetAxesXLimits())
            //          return;

            if (AxisRepresentation == AxisRepresentations.AxisX)
                if (!SetAxesXLimits())
                    return;

            // Settings specific to axis y
            if (this.AxisRepresentation == AxisRepresentations.AxisY && this.AxisType == AxisTypes.Primary)
            {
                // Set the internal axis limits the one obtained from axis manager
                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;

            }
            else if (this.AxisRepresentation == AxisRepresentations.AxisY && this.AxisType == AxisTypes.Secondary)
            {
                var axisYPrimary = (from axis in (Chart as Chart).InternalAxesY where axis.AxisRepresentation == AxisRepresentations.AxisY && axis.AxisType == AxisTypes.Primary select axis);

                Axis primaryAxisY = null;
                if (axisYPrimary.Count() > 0)
                    primaryAxisY = axisYPrimary.First();

                if (Double.IsNaN((double)Interval) && primaryAxisY != null)
                {
                    // number of interval in the primary axis
                    Double primaryAxisIntervalCount = ((double)primaryAxisY.InternalAxisMaximum - (double)primaryAxisY.InternalAxisMinimum) / (double)primaryAxisY.InternalInterval;

                    if (!Double.IsNaN(primaryAxisIntervalCount))
                    {   
                        // This will set the internal overriding flag
                        AxisManager.AxisMinimumValue = AxisManager.AxisMinimumValue;
                        AxisManager.AxisMaximumValue = AxisManager.AxisMaximumValue;

                        // This interval will reflect the interval in primary axis it is not same as that of primary axis
                        AxisManager.Interval = (AxisManager.AxisMaximumValue - AxisManager.AxisMinimumValue) / primaryAxisIntervalCount;

                        AxisManager.Calculate();
                    }
                }

                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;
            }
            else
            {
                // Set the internal axis limits the one obtained from axis manager
                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;
            }

            InternalInterval = AxisManager.Interval;
        }
Example #2
0
        /// <summary>
        /// Set up axis manager and calculate axis values
        /// </summary>
        private void SetUpAxisManager()
        {
            // Get the minimum and maximum value dependeing on the axis representation value
            Minimum = AxisRepresentation == AxisRepresentations.AxisX ? PlotDetails.GetAxisXMinimumDataValue(this) : PlotDetails.GetAxisYMinimumDataValue(this);
            Maximum = AxisRepresentation == AxisRepresentations.AxisX ? PlotDetails.GetAxisXMaximumDataValue(this) : PlotDetails.GetAxisYMaximumDataValue(this);

            if(Logarithmic)
            {
                Double minimum = PlotDetails.GetAxisYMinimumDataValueFromAllDataSeries(this);
                if (!PlotDetails.CheckIfAnyDataPointVisualExistsInChart())
                {
                    minimum = 1;
                    Maximum = Math.Pow(LogarithmBase, 1);
                }

                if (minimum <= 0 || Maximum <= 0)
                    throw new Exception("Negative or zero values cannot be plotted correctly on logarithmic charts.");
            }
                
            Boolean overflowValidity = (AxisRepresentation == AxisRepresentations.AxisX);
            Boolean stackingOverride = PlotDetails.GetStacked100OverrideState();


            // Check if ViewportRangeEnabled property is set in Logarithmic Axis.
            // If set then the minimum value of Log scale should be generated depending upon the new AxisMinimum.
            Boolean startFromMinimumValue4LogScale = false;
            if (AxisRepresentation == AxisRepresentations.AxisY && ViewportRangeEnabled && Logarithmic)
                startFromMinimumValue4LogScale = true;

            Boolean isCircularAxis = (AxisOrientation == AxisOrientation.Circular) ? true : false;

            // Create and initialize the AxisManagers
            AxisManager = new AxisManager(Maximum, Minimum, (Boolean)StartFromZero, overflowValidity, stackingOverride, isCircularAxis, AxisRepresentation, Logarithmic, LogarithmBase, startFromMinimumValue4LogScale);

            // Set the include zero state
            AxisManager.IncludeZero = IncludeZero;

            // settings specific to axis X
            if (AxisRepresentation == AxisRepresentations.AxisX && AxisOrientation != AxisOrientation.Circular)
            {
                Double interval = GenerateDefaultInterval();

                if (IsDateTimeAxis)
                {
                    if (interval > 0 || !Double.IsNaN(interval))
                    {
                        AxisManager.Interval = interval;
                        InternalInterval = interval;
                    }
                    else
                    {
                        // if interval is greater than zero then set the interval of the axis manager
                        if (Interval > 0 || !Double.IsNaN((Double)Interval))
                        {
                            AxisManager.Interval = (Double)Interval;
                            InternalInterval = (Double)Interval;
                        }
                    }
                }
                else if (interval > 0 || !Double.IsNaN(interval))
                {
                    AxisManager.Interval = interval;
                    InternalInterval = interval;
                }
            }
            else
            {
                // if interval is greater than zero then set the interval of the axis manager
                if (Interval > 0 || !Double.IsNaN((Double)Interval))
                {
                    AxisManager.Interval = (Double)Interval;
                    InternalInterval = (Double)Interval;
                }
            }

            // set the axis maximum value if user has provided it
            if (!Double.IsNaN((Double)AxisMaximumNumeric))
            {
                AxisManager.AxisMaximumValue = (Double)AxisMaximumNumeric;
                InternalAxisMaximum = (Double)AxisMaximumNumeric;
            }
            else
            {
                if (AxisOrientation == AxisOrientation.Circular)
                {
                    if (IsDateTimeAxis && AxisMaximum != null)
                    {
                        Double axisMaxNumeric;
                        if (XValueType != ChartValueTypes.Time)
                        {
                            axisMaxNumeric = DateTimeHelper.DateDiff(AxisMaximumDateTime, MinDate, MinDateRange, MaxDateRange, InternalIntervalType, XValueType);
                        }
                        else
                        {
                            axisMaxNumeric = DateTimeHelper.DateDiff(Convert.ToDateTime(AxisMaximum), MinDate, MinDateRange, MaxDateRange, InternalIntervalType, XValueType);
                        }

                        AxisManager.AxisMaximumValue = axisMaxNumeric;
                        InternalAxisMaximum = axisMaxNumeric;
                    }
                }
            }

            // set the axis minimum value if the user has provided it
            if (!Double.IsNaN((Double)AxisMinimumNumeric))
            {
                AxisManager.AxisMinimumValue = (Double)AxisMinimumNumeric;
                InternalAxisMinimum = (Double)AxisMinimumNumeric;
            }
            else
            {
                if (AxisOrientation == AxisOrientation.Circular)
                {
                    if (IsDateTimeAxis && AxisMinimum != null)
                    {
                        Double axisMinNumeric;
                        if (XValueType != ChartValueTypes.Time)
                        {
                            axisMinNumeric = DateTimeHelper.DateDiff(AxisMinimumDateTime, MinDate, MinDateRange, MaxDateRange, InternalIntervalType, XValueType);
                        }
                        else
                        {
                            axisMinNumeric = DateTimeHelper.DateDiff(Convert.ToDateTime(AxisMinimum), MinDate, MinDateRange, MaxDateRange, InternalIntervalType, XValueType);
                        }

                        AxisManager.AxisMinimumValue = axisMinNumeric;
                        InternalAxisMinimum = axisMinNumeric;
                    }
                }
            }

            // Calculate the various parameters for creating the axis
            AxisManager.Calculate();

            // Set axis specific limits based on axis limits.
            // if (AxisRepresentation == AxisRepresentations.AxisX && !(Boolean)StartFromZero)
            //      if (!SetAxesXLimits())
            //          return;

            if (AxisRepresentation == AxisRepresentations.AxisX && AxisOrientation != AxisOrientation.Circular)
            {
                if (!SetAxesXLimits())
                    return;
                
                if (!Double.IsNaN((Double)Interval) && IsDateTimeAxis)
                {
                    AxisManager.Interval = (Double)Interval;
                }
            }

            // Settings specific to axis y
            if (this.AxisRepresentation == AxisRepresentations.AxisY && this.AxisType == AxisTypes.Primary)
            {
                // Set the internal axis limits the one obtained from axis manager
                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;
            }
            else if (this.AxisRepresentation == AxisRepresentations.AxisY && this.AxisType == AxisTypes.Secondary)
            {
                var axisYPrimary = (from axis in (Chart as Chart).InternalAxesY where axis.AxisRepresentation == AxisRepresentations.AxisY && axis.AxisType == AxisTypes.Primary select axis);

                Axis primaryAxisY = null;
                if (axisYPrimary.Count() > 0)
                    primaryAxisY = axisYPrimary.First();

                if (Double.IsNaN((double)Interval) && primaryAxisY != null)
                {
                    // number of interval in the primary axis
                    Double primaryAxisIntervalCount = ((double)primaryAxisY.InternalAxisMaximum - (double)primaryAxisY.InternalAxisMinimum) / (double)primaryAxisY.InternalInterval;

                    if (!Double.IsNaN(primaryAxisIntervalCount))
                    {   
                        // This will set the internal overriding flag
                        AxisManager.AxisMinimumValue = AxisManager.AxisMinimumValue;
                        if ((Boolean)StartFromZero)
                        {
                            if (AxisManager.AxisMinimumValue == 0)
                            {
                                if (Logarithmic)
                                    AxisManager.AxisMinimumValue = Math.Pow(LogarithmBase, 0);
                            }
                        }

                        if (Logarithmic)
                        {
                            AxisManager.AxisMaximumValue = Math.Pow(LogarithmBase, AxisManager.AxisMaximumValue);

                            // This interval will reflect the interval in primary axis it is not same as that of primary axis
                            AxisManager.Interval = (Math.Log(AxisManager.AxisMaximumValue, LogarithmBase) - Math.Log(AxisManager.AxisMinimumValue, LogarithmBase)) / primaryAxisIntervalCount;

                        }
                        else
                        {
                            AxisManager.AxisMaximumValue = AxisManager.AxisMaximumValue;

                            // This interval will reflect the interval in primary axis it is not same as that of primary axis
                            AxisManager.Interval = (AxisManager.AxisMaximumValue - AxisManager.AxisMinimumValue) / primaryAxisIntervalCount;

                        }

                        // This interval will reflect the interval in primary axis it is not same as that of primary axis
                        //AxisManager.Interval = (AxisManager.AxisMaximumValue - AxisManager.AxisMinimumValue) / primaryAxisIntervalCount;

                        AxisManager.Calculate();
                    }
                }

                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;
            }
            else
            {
                InternalAxisMaximum = AxisManager.AxisMaximumValue;
                InternalAxisMinimum = AxisManager.AxisMinimumValue;
            }

            InternalInterval = AxisManager.Interval;
        }