C# CurveItem.BaseAxis方法代码示例

 public DataFrameBuilder(GraphPane graphPane, CurveItem curveItem)
 {
     GraphPane = graphPane;
     CurveItem = curveItem;
     var msPointList = curveItem.Points as MSPointList;
     if (msPointList != null)
     {
         Points = msPointList.FullList;
     }
     else
     {
         Points = curveItem.Points;
     }
     XAxis = curveItem.GetXAxis(graphPane);
     YAxis = curveItem.GetYAxis(graphPane);
     BaseAxis = curveItem.BaseAxis(graphPane);
     ValueAxis = curveItem.ValueAxis(graphPane);
 }

        /// <summary>
        /// Get the user scale values associate with a particular point of a
        /// particular curve.</summary>
        /// <remarks>The main purpose of this method is to handle
        /// stacked bars, in which case the stacked values are returned rather
        /// than the individual data values.
        /// </remarks>
        /// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
        /// <param name="curve">A <see cref="CurveItem"/> object of interest.</param>
        /// <param name="iPt">The zero-based point index for the point of interest.</param>
        /// <param name="baseVal">A <see cref="Double"/> value representing the value
        /// for the independent axis.</param>
        /// <param name="lowVal">A <see cref="Double"/> value representing the lower
        /// value for the dependent axis.</param>
        /// <param name="hiVal">A <see cref="Double"/> value representing the upper
        /// value for the dependent axis.</param>
        /// <returns>true if the data point is value, false for
        /// <see cref="PointPair.Missing"/>, invalid, etc. data.</returns>
        public static bool GetBarValues( GraphPane pane, CurveItem curve, int iPt,
							out double baseVal, out double lowVal, out double hiVal )
        {
            hiVal = PointPair.Missing;
            lowVal = PointPair.Missing;
            baseVal = PointPair.Missing;

            if ( curve == null || curve.Points.Count <= iPt )
                return false;

            Axis baseAxis = curve.BaseAxis( pane );

            if ( baseAxis is XAxis )
                baseVal = curve.Points[iPt].X;
            else
                baseVal = curve.Points[iPt].Y;

            if ( curve is BarItem && ( pane.BarType == BarType.Stack ||
                        pane.BarType == BarType.PercentStack ) )
            {
                double positiveStack = 0;
                double negativeStack = 0;
                double curVal;
                foreach ( CurveItem tmpCurve in pane.CurveList )
                //for ( int iCurve=pane.CurveList.Count-1; iCurve >=0; iCurve-- )
                {
                    //CurveItem tmpCurve = pane.CurveList[iCurve];
                    if ( tmpCurve.IsBar && iPt < tmpCurve.Points.Count )
                    {
                        if ( baseAxis is XAxis )
                            curVal = tmpCurve.Points[iPt].Y;
                        else
                            curVal = tmpCurve.Points[iPt].X;

                        if ( curVal == PointPair.Missing )
                            continue;

                        if ( tmpCurve == curve )
                        {
                            if ( curVal >= 0 )
                            {
                                lowVal = positiveStack;
                                hiVal = positiveStack + curVal;
                            }
                            else
                            {
                                hiVal = negativeStack;
                                lowVal = negativeStack + curVal;
                            }
                        }

                        if ( curVal >= 0 )
                            positiveStack += curVal;
                        else
                            negativeStack += curVal;
                    }
                }

                if ( pane.BarType == BarType.PercentStack )
                {
                    positiveStack += Math.Abs( negativeStack );

                    if ( positiveStack != 0 )
                    {
                        lowVal = lowVal / positiveStack * 100.0;
                        hiVal = hiVal / positiveStack * 100.0;
                    }
                    else
                    {
                        lowVal = 0;
                        hiVal = 0;
                    }
                }

                if ( baseVal == PointPair.Missing || lowVal == PointPair.Missing ||
                        hiVal == PointPair.Missing )
                    return false;
                else
                    return true;
            }
            else
            {
//.........这里部分代码省略.........

        /// <summary>
        /// Calculate the screen pixel position of the center of the specified bar, using the
        /// <see cref="Axis"/> as specified by <see cref="GraphPane.BarBase"/>.  This method is
        /// used primarily by the
        /// <see cref="GraphPane.FindNearestPoint(PointF,out CurveItem,out int)"/> method in order to
        /// determine the bar "location," which is defined as the center of the top of the individual bar.
        /// </summary>
        /// <param name="curve">The <see cref="CurveItem"/> representing the
        /// bar of interest.</param>
        /// <param name="barWidth">The width of each individual bar. This can be calculated using
        /// the <see cref="CurveItem.GetBarWidth"/> method.</param>
        /// <param name="iCluster">The cluster number for the bar of interest.  This is the ordinal
        /// position of the current point.  That is, if a particular <see cref="CurveItem"/> has
        /// 10 points, then a value of 3 would indicate the 4th point in the data array.</param>
        /// <param name="val">The actual independent axis value for the bar of interest.</param>
        /// <param name="iOrdinal">The ordinal position of the <see cref="CurveItem"/> of interest.
        /// That is, the first bar series is 0, the second is 1, etc.  Note that this applies only
        /// to the bars.  If a graph includes both bars and lines, then count only the bars.</param>
        /// <returns>A screen pixel X position of the center of the bar of interest.</returns>
        public double BarCenterValue( CurveItem curve, float barWidth, int iCluster,
										  double val, int iOrdinal )
        {
            float clusterWidth = pane.GetClusterWidth();
            float clusterGap = pane.MinClusterGap * barWidth;
            float barGap = barWidth * pane.MinBarGap;

            if ( ( curve.IsBar && !( pane.BarType == BarType.Cluster ) ) ||
                   curve is ErrorBarItem || curve is HiLowBarItem )
                iOrdinal = 0;

            Axis baseAxis = curve.BaseAxis( pane );
            float centerPix = baseAxis.Transform( iCluster, val )
                     - clusterWidth / 2.0F + clusterGap / 2.0F +
                     iOrdinal * ( barWidth + barGap ) + 0.5F * barWidth;
            return baseAxis.ReverseTransform( centerPix );
        }

        /// <summary>
        /// Get the user scale values associate with a particular point of a
        /// particular curve.</summary>
        /// <remarks>The main purpose of this method is to handle
        /// stacked bars and lines, in which case the stacked values are returned rather
        /// than the individual data values.  However, this method works generically for any
        /// curve type.
        /// </remarks>
        /// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
        /// <param name="curve">A <see cref="CurveItem"/> object of interest.</param>
        /// <param name="iPt">The zero-based point index for the point of interest.</param>
        /// <param name="baseVal">A <see cref="Double"/> value representing the value
        /// for the independent axis.</param>
        /// <param name="lowVal">A <see cref="Double"/> value representing the lower
        /// value for the dependent axis.</param>
        /// <param name="hiVal">A <see cref="Double"/> value representing the upper
        /// value for the dependent axis.</param>
        /// <returns>true if the data point is value, false for
        /// <see cref="PointPairBase.Missing"/>, invalid, etc. data.</returns>
        public static bool GetValues( GraphPane pane, CurveItem curve, int iPt,
							out double baseVal, out double lowVal, out double hiVal )
        {
            hiVal = PointPair.Missing;
            lowVal = PointPair.Missing;
            baseVal = PointPair.Missing;

            if ( curve == null || curve.Points.Count <= iPt || !curve.IsVisible )
                return false;

            Axis baseAxis = curve.BaseAxis( pane );
            Axis valueAxis = curve.ValueAxis( pane );

            if ( baseAxis is XAxis || baseAxis is X2Axis )
                baseVal = curve.Points[iPt].X;
            else
                baseVal = curve.Points[iPt].Y;

            // is it a stacked bar type?
            if ( curve is BarItem && ( pane._barSettings.Type == BarType.Stack ||
                        pane._barSettings.Type == BarType.PercentStack ) )
            {
                double positiveStack = 0;
                double negativeStack = 0;
                double curVal;

                // loop through all the curves, summing up the values to get a total (only
                // for the current ordinal position iPt)
                foreach ( CurveItem tmpCurve in pane.CurveList )
                {
                    // Sum the value for the current curve only if it is a bar
                    if ( tmpCurve.IsBar && tmpCurve.IsVisible )
                    {
                        curVal = PointPair.Missing;
                        // For non-ordinal curves, find a matching base value (must match exactly)
                        if ( curve.IsOverrideOrdinal || !baseAxis._scale.IsAnyOrdinal )
                        {
                            IPointList points = tmpCurve.Points;

                            for ( int i=0; i<points.Count; i++ )
                            {
                                if ( ( baseAxis is XAxis || baseAxis is X2Axis ) && points[i].X == baseVal )
                                {
                                    curVal = points[i].Y;
                                    break;
                                }
                                else if ( !(baseAxis is XAxis || baseAxis is X2Axis) && points[i].Y == baseVal )
                                {
                                    curVal = points[i].X;
                                    break;
                                }
                            }
                        }
                        // otherwise, it's an ordinal type so use the value at the same ordinal position
                        else if ( iPt < tmpCurve.Points.Count )
                        {
                            // Get the value for the appropriate value axis
                            if ( baseAxis is XAxis || baseAxis is X2Axis )
                                curVal = tmpCurve.Points[iPt].Y;
                            else
                                curVal = tmpCurve.Points[iPt].X;
                        }

                        // If it's a missing value, skip it
                        if ( curVal == PointPair.Missing )
                        {
                            positiveStack = PointPair.Missing;
                            negativeStack = PointPair.Missing;
                        }

                        // the current curve is the target curve, save the summed values for later
                        if ( tmpCurve == curve )
                        {
                            // if the value is positive, use the positive stack
                            if ( curVal >= 0 )
                            {
                                lowVal = positiveStack;
                                hiVal = ( curVal == PointPair.Missing || positiveStack == PointPair.Missing ) ?
                                        PointPair.Missing : positiveStack + curVal;
                            }
                            // otherwise, use the negative stack
//.........这里部分代码省略.........

        /// <summary>
        /// Calculate the user scale position of the center of the specified bar, using the
        /// <see cref="Axis"/> as specified by <see cref="BarSettings.Base"/>.  This method is
        /// used primarily by the
        /// <see cref="GraphPane.FindNearestPoint(PointF,out CurveItem,out int)"/> method in order to
        /// determine the bar "location," which is defined as the center of the top of the individual bar.
        /// </summary>
        /// <param name="curve">The <see cref="CurveItem"/> representing the
        /// bar of interest.</param>
        /// <param name="barWidth">The width of each individual bar. This can be calculated using
        /// the <see cref="CurveItem.GetBarWidth"/> method.</param>
        /// <param name="iCluster">The cluster number for the bar of interest.  This is the ordinal
        /// position of the current point.  That is, if a particular <see cref="CurveItem"/> has
        /// 10 points, then a value of 3 would indicate the 4th point in the data array.</param>
        /// <param name="val">The actual independent axis value for the bar of interest.</param>
        /// <param name="iOrdinal">The ordinal position of the <see cref="CurveItem"/> of interest.
        /// That is, the first bar series is 0, the second is 1, etc.  Note that this applies only
        /// to the bars.  If a graph includes both bars and lines, then count only the bars.</param>
        /// <returns>A user scale value position of the center of the bar of interest.</returns>
        public double BarCenterValue( CurveItem curve, float barWidth, int iCluster,
										  double val, int iOrdinal )
        {
            Axis baseAxis = curve.BaseAxis( _pane );
            if ( curve is ErrorBarItem || curve is HiLowBarItem ||
                    curve is OHLCBarItem || curve is JapaneseCandleStickItem )
            {
                if ( baseAxis._scale.IsAnyOrdinal && iCluster >= 0 && !curve.IsOverrideOrdinal )
                    return (double) iCluster + 1.0;
                else
                    return val;
            }
            else
            {
                float clusterWidth = _pane._barSettings.GetClusterWidth();
                float clusterGap = _pane._barSettings.MinClusterGap * barWidth;
                float barGap = barWidth * _pane._barSettings.MinBarGap;

                if ( curve.IsBar && _pane._barSettings.Type != BarType.Cluster )
                    iOrdinal = 0;

                float centerPix = baseAxis.Scale.Transform( curve.IsOverrideOrdinal, iCluster, val )
                    - clusterWidth / 2.0F + clusterGap / 2.0F +
                    iOrdinal * ( barWidth + barGap ) + 0.5F * barWidth;
                return baseAxis.Scale.ReverseTransform( centerPix );
            }
        }

        /// <summary>
        /// Calculate the range for stacked bars and lines.
        /// </summary>
        /// <remarks>This method is required for the stacked
        /// types because (for bars), the negative values are a separate stack than the positive
        /// values.  If you just sum up the bars, you will get the sum of the positive plus negative,
        /// which is less than the maximum positive value and greater than the maximum negative value.
        /// </remarks>
        /// <param name="pane">
        /// A reference to the <see cref="GraphPane"/> object that is the parent or
        /// owner of this object.
        /// </param>
        /// <param name="curve">The <see cref="CurveItem"/> for which to calculate the range</param>
        /// <param name="tXMinVal">The minimum X value so far</param>
        /// <param name="tYMinVal">The minimum Y value so far</param>
        /// <param name="tXMaxVal">The maximum X value so far</param>
        /// <param name="tYMaxVal">The maximum Y value so far</param>
        /// <seealso cref="GraphPane.IsBoundedRanges"/>
        private void GetStackRange( GraphPane pane, CurveItem curve, out double tXMinVal,
									out double tYMinVal, out double tXMaxVal, out double tYMaxVal )
        {
            // initialize the values to outrageous ones to start
            tXMinVal = tYMinVal = Double.MaxValue;
            tXMaxVal = tYMaxVal = Double.MinValue;

            ValueHandler valueHandler = new ValueHandler( pane, false );
            Axis baseAxis = curve.BaseAxis( pane );
            bool isXBase = baseAxis is XAxis || baseAxis is X2Axis;

            double lowVal, baseVal, hiVal;

            for ( int i=0; i<curve.Points.Count; i++ )
            {
                valueHandler.GetValues( curve, i, out baseVal, out lowVal, out hiVal );
                double x = isXBase ? baseVal : hiVal;
                double y = isXBase ? hiVal : baseVal;

                if ( x != PointPair.Missing && y != PointPair.Missing && lowVal != PointPair.Missing )
                {
                    if ( x < tXMinVal )
                        tXMinVal = x;
                    if ( x > tXMaxVal )
                        tXMaxVal = x;
                    if ( y < tYMinVal )
                        tYMinVal = y;
                    if ( y > tYMaxVal )
                        tYMaxVal = y;

                    if ( !isXBase )
                    {
                        if ( lowVal < tXMinVal )
                            tXMinVal = lowVal;
                        if ( lowVal > tXMaxVal )
                            tXMaxVal = lowVal;
                    }
                    else
                    {
                        if ( lowVal < tYMinVal )
                            tYMinVal = lowVal;
                        if ( lowVal > tYMaxVal )
                            tYMaxVal = lowVal;
                    }
                }
            }
        }