C# ZedGraph.GraphPane类代码示例

 /// <summary>
 /// Construct a <see cref="ZoomState"/> object from the scale ranges settings contained
 /// in the specified <see cref="GraphPane"/>.
 /// </summary>
 /// <param name="pane">The <see cref="GraphPane"/> from which to obtain the scale
 /// range values.
 /// </param>
 /// <param name="type">A <see cref="StateType"/> enumeration that indicates whether
 /// this saved state is from a pan or zoom.</param>
 public ZoomState( GraphPane pane, StateType type )
 {
     _xAxis = new ScaleState( pane.XAxis );
     _x2Axis = new ScaleState( pane.X2Axis );
     _yAxis = new ScaleStateList( pane.YAxisList );
     _y2Axis = new ScaleStateList( pane.Y2AxisList );
     _type = type;
 }

 /// <summary>
 /// Basic constructor that saves a reference to the parent
 /// <see cref="GraphPane"/> object.
 /// </summary>
 /// <param name="pane">The parent <see cref="GraphPane"/> object.</param>
 /// <param name="initialize">A <see cref="bool"/> flag to indicate whether or
 /// not the drawing variables should be initialized.  Initialization is not
 /// required if this is part of a ZedGraph internal draw operation (i.e., its in
 /// the middle of a call to <see cref="GraphPane.Draw"/>).  Otherwise, you should
 /// initialize to make sure the drawing variables are configured.  true to do
 /// an initialization, false otherwise.</param>
 public ValueHandler( GraphPane pane, bool initialize )
 {
     _pane = pane;
     if ( initialize )
     {
         // just create a dummy image, which results in a full draw operation
         using ( Image image = pane.GetImage() )
         {
         }
     }
 }

 /// <summary>
 /// Gets a flag indicating if the X axis is the independent axis for this <see cref="CurveItem" />
 /// </summary>
 /// <param name="pane">The parent <see cref="GraphPane" /> of this <see cref="CurveItem" />.
 /// </param>
 /// <value>true if the X axis is independent, false otherwise</value>
 internal override bool IsXIndependent( GraphPane pane )
 {
     return pane._barSettings.Base == BarBase.X || pane._barSettings.Base == BarBase.X2;
 }

 /// <summary>
 /// Draw a legend key entry for this <see cref="BarItem"/> at the specified location
 /// </summary>
 /// <param name="g">
 /// A graphic device object to be drawn into.  This is normally e.Graphics from the
 /// PaintEventArgs argument to the Paint() method.
 /// </param>
 /// <param name="pane">
 /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
 /// owner of this object.
 /// </param>
 /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
 /// location for the legend key</param>
 /// <param name="scaleFactor">
 /// The scaling factor to be used for rendering objects.  This is calculated and
 /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
 /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
 /// font sizes, etc. according to the actual size of the graph.
 /// </param>
 public override void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor )
 {
     _bar.Draw( g, pane, rect, scaleFactor, true, false, null );
 }

 /// <summary>
 /// Draw a legend key entry for this <see cref="CurveItem"/> at the specified location.
 /// This abstract base method passes through to <see cref="BarItem.DrawLegendKey"/> or
 /// <see cref="LineItem.DrawLegendKey"/> to do the rendering.
 /// </summary>
 /// <param name="g">
 /// A graphic device object to be drawn into.  This is normally e.Graphics from the
 /// PaintEventArgs argument to the Paint() method.
 /// </param>
 /// <param name="pane">
 /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
 /// owner of this object.
 /// </param>
 /// <param name="rect">The <see cref="RectangleF"/> struct that specifies the
 /// location for the legend key</param>
 /// <param name="scaleFactor">
 /// The scaling factor to be used for rendering objects.  This is calculated and
 /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
 /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
 /// font sizes, etc. according to the actual size of the graph.
 /// </param>
 public abstract void DrawLegendKey( Graphics g, GraphPane pane, RectangleF rect, float scaleFactor );

 /// <summary>
 /// Do all rendering associated with this <see cref="CurveItem"/> to the specified
 /// <see cref="Graphics"/> device.  This method is normally only
 /// called by the Draw method of the parent <see cref="ZedGraph.CurveList"/>
 /// collection object.
 /// </summary>
 /// <param name="g">
 /// A graphic device object to be drawn into.  This is normally e.Graphics from the
 /// PaintEventArgs argument to the Paint() method.
 /// </param>
 /// <param name="pane">
 /// A reference to the <see cref="ZedGraph.GraphPane"/> object that is the parent or
 /// owner of this object.
 /// </param>
 /// <param name="pos">The ordinal position of the current <see cref="Bar"/>
 /// curve.</param>
 /// <param name="scaleFactor">
 /// The scaling factor to be used for rendering objects.  This is calculated and
 /// passed down by the parent <see cref="ZedGraph.GraphPane"/> object using the
 /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
 /// font sizes, etc. according to the actual size of the graph.
 /// </param>
 public abstract void Draw( Graphics g, GraphPane pane, int pos, float scaleFactor  );

        /// <summary>
        /// Create a <see cref="TextObj" /> for each bar in the <see cref="GraphPane" />.
        /// </summary>
        /// <remarks>
        /// This method will go through the bars, create a label that corresponds to the bar value,
        /// and place it on the graph depending on user preferences.  This works for horizontal or
        /// vertical bars in clusters or stacks, but only for <see cref="BarItem" /> types.  This method
        /// does not apply to <see cref="ErrorBarItem" /> or <see cref="HiLowBarItem" /> objects.
        /// Call this method only after calling <see cref="GraphPane.AxisChange()" />.
        /// </remarks>
        /// <param name="pane">The GraphPane in which to place the text labels.</param>
        /// <param name="isBarCenter">true to center the labels inside the bars, false to
        /// place the labels just above the top of the bar.</param>
        /// <param name="valueFormat">The double.ToString string format to use for creating
        /// the labels.
        /// </param>
        /// <param name="fontColor">The color in which to draw the labels</param>
        /// <param name="fontFamily">The string name of the font family to use for the labels</param>
        /// <param name="fontSize">The floating point size of the font, in scaled points</param>
        /// <param name="isBold">true for a bold font type, false otherwise</param>
        /// <param name="isItalic">true for an italic font type, false otherwise</param>
        /// <param name="isUnderline">true for an underline font type, false otherwise</param>
        public static void CreateBarLabels( GraphPane pane, bool isBarCenter, string valueFormat,
			string fontFamily, float fontSize, Color fontColor, bool isBold, bool isItalic,
			bool isUnderline )
        {
            bool isVertical = pane.BarSettings.Base == BarBase.X;

            // keep a count of the number of BarItems
            int curveIndex = 0;

            // Get a valuehandler to do some calculations for us
            ValueHandler valueHandler = new ValueHandler( pane, true );

            // Loop through each curve in the list
            foreach ( CurveItem curve in pane.CurveList )
            {
                // work with BarItems only
                BarItem bar = curve as BarItem;
                if ( bar != null )
                {
                    IPointList points = curve.Points;

                    // ADD JKB 9/21/07
                    // The labelOffset should depend on whether the curve is YAxis or Y2Axis.
                    // JHC - Generalize to any value axis
                    // Make the gap between the bars and the labels = 1.5% of the axis range
                    float labelOffset;

                    Scale scale = curve.ValueAxis( pane ).Scale;
                    labelOffset = (float)( scale._max - scale._min ) * 0.015f;

                    // Loop through each point in the BarItem
                    for ( int i = 0; i < points.Count; i++ )
                    {
                        // Get the high, low and base values for the current bar
                        // note that this method will automatically calculate the "effective"
                        // values if the bar is stacked
                        double baseVal, lowVal, hiVal;
                        valueHandler.GetValues( curve, i, out baseVal, out lowVal, out hiVal );

                        // Get the value that corresponds to the center of the bar base
                        // This method figures out how the bars are positioned within a cluster
                        float centerVal = (float)valueHandler.BarCenterValue( bar,
                            bar.GetBarWidth( pane ), i, baseVal, curveIndex );

                        // Create a text label -- note that we have to go back to the original point
                        // data for this, since hiVal and lowVal could be "effective" values from a bar stack
                        string barLabelText = ( isVertical ? points[i].Y : points[i].X ).ToString( valueFormat );

                        // Calculate the position of the label -- this is either the X or the Y coordinate
                        // depending on whether they are horizontal or vertical bars, respectively
                        float position;
                        if ( isBarCenter )
                            position = (float)( hiVal + lowVal ) / 2.0f;
                        else if ( hiVal >= 0 )
                            position = (float)hiVal + labelOffset;
                        else
                            position = (float)hiVal - labelOffset;

                        // Create the new TextObj
                        TextObj label;
                        if ( isVertical )
                            label = new TextObj( barLabelText, centerVal, position );
                        else
                            label = new TextObj( barLabelText, position, centerVal );

                        label.FontSpec.Family = fontFamily;

                        // Configure the TextObj

                  // CHANGE JKB 9/21/07
                  // CoordinateFrame should depend on whether curve is YAxis or Y2Axis.
                        label.Location.CoordinateFrame =
                            (isVertical && curve.IsY2Axis) ? CoordType.AxisXY2Scale : CoordType.AxisXYScale;

                        label.FontSpec.Size = fontSize;
                        label.FontSpec.FontColor = fontColor;
                        label.FontSpec.IsItalic = isItalic;
                        label.FontSpec.IsBold = isBold;
//.........这里部分代码省略.........

        /// <summary>
        /// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/>
        /// device.  The format (stair-step or line) of the curve is
        /// defined by the <see cref="StepType"/> property.  The routine
        /// only draws the line segments; the symbols are drawn by the
        /// <see cref="Symbol.Draw"/> method.  This method
        /// is normally only called by the Draw method of the
        /// <see cref="CurveItem"/> object
        /// </summary>
        /// <param name="g">
        /// A graphic device object to be drawn into.  This is normally e.Graphics from the
        /// PaintEventArgs argument to the Paint() method.
        /// </param>
        /// <param name="scaleFactor">
        /// The scaling factor to be used for rendering objects.  This is calculated and
        /// passed down by the parent <see cref="GraphPane"/> object using the
        /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
        /// font sizes, etc. according to the actual size of the graph.
        /// </param>
        /// <param name="pane">
        /// A reference to the <see cref="GraphPane"/> object that is the parent or
        /// owner of this object.
        /// </param>
        /// <param name="curve">A <see cref="LineItem"/> representing this
        /// curve.</param>
        public void DrawCurveOriginal( Graphics g, GraphPane pane,
										  CurveItem curve, float scaleFactor )
        {
            Line source = this;
            if ( curve.IsSelected )
                source = Selection.Line;

            float tmpX, tmpY,
                    lastX = float.MaxValue,
                    lastY = float.MaxValue;
            double curX, curY, lowVal;
            PointPair curPt, lastPt = new PointPair();

            bool lastBad = true;
            IPointList points = curve.Points;
            ValueHandler valueHandler = new ValueHandler( pane, false );
            Axis yAxis = curve.GetYAxis( pane );
            Axis xAxis = curve.GetXAxis( pane );

            bool xIsLog = xAxis._scale.IsLog;
            bool yIsLog = yAxis._scale.IsLog;

            float minX = pane.Chart.Rect.Left;
            float maxX = pane.Chart.Rect.Right;
            float minY = pane.Chart.Rect.Top;
            float maxY = pane.Chart.Rect.Bottom;

            using ( Pen pen = source.GetPen( pane, scaleFactor ) )
            {
                if ( points != null && !_color.IsEmpty && this.IsVisible )
                {
                    //bool lastOut = false;
                    bool isOut;

                    // Loop over each point in the curve
                    for ( int i = 0; i < points.Count; i++ )
                    {
                        curPt = points[i];
                        if ( pane.LineType == LineType.Stack )
                        {
                            if ( !valueHandler.GetValues( curve, i, out curX, out lowVal, out curY ) )
                            {
                                curX = PointPair.Missing;
                                curY = PointPair.Missing;
                            }
                        }
                        else
                        {
                            curX = curPt.X;
                            curY = curPt.Y;
                        }

                        // Any value set to double max is invalid and should be skipped
                        // This is used for calculated values that are out of range, divide
                        //   by zero, etc.
                        // Also, any value <= zero on a log scale is invalid
                        if ( curX == PointPair.Missing ||
                                curY == PointPair.Missing ||
                                System.Double.IsNaN( curX ) ||
                                System.Double.IsNaN( curY ) ||
                                System.Double.IsInfinity( curX ) ||
                                System.Double.IsInfinity( curY ) ||
                                ( xIsLog && curX <= 0.0 ) ||
                                ( yIsLog && curY <= 0.0 ) )
                        {
                            // If the point is invalid, then make a linebreak only if IsIgnoreMissing is false
                            // LastX and LastY are always the last valid point, so this works out
                            lastBad = lastBad || !pane.IsIgnoreMissing;
                            isOut = true;
                        }
                        else
                        {
                            // Transform the current point from user scale units to
                            // screen coordinates
                            tmpX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curX );
//.........这里部分代码省略.........

        /// <summary>
        /// Close off a <see cref="GraphicsPath"/> that defines a curve
        /// </summary>
        /// <param name="pane">A reference to the <see cref="GraphPane"/> object that is the parent or
        /// owner of this object.</param>
        /// <param name="curve">A <see cref="LineItem"/> representing this
        /// curve.</param>
        /// <param name="arrPoints">An array of <see cref="PointF"/> values in screen pixel
        /// coordinates representing the current curve.</param>
        /// <param name="count">The number of points contained in the "arrPoints"
        /// parameter.</param>
        /// <param name="yMin">The Y axis value location where the X axis crosses.</param>
        /// <param name="path">The <see cref="GraphicsPath"/> class that represents the curve.</param>
        public void CloseCurve( GraphPane pane, CurveItem curve, PointF[] arrPoints,
									int count, double yMin, GraphicsPath path )
        {
            // For non-stacked lines, the fill area is just the area between the curve and the X axis
            if ( pane.LineType != LineType.Stack )
            {
                // Determine the current value for the bottom of the curve (usually the Y value where
                // the X axis crosses)
                float yBase;
                Axis yAxis = curve.GetYAxis( pane );
                yBase = yAxis.Scale.Transform( yMin );

                // Add three points to the path to move from the end of the curve (as defined by
                // arrPoints) to the X axis, from there to the start of the curve at the X axis,
                // and from there back up to the beginning of the curve.
                path.AddLine( arrPoints[count - 1].X, arrPoints[count - 1].Y, arrPoints[count - 1].X, yBase );
                path.AddLine( arrPoints[count - 1].X, yBase, arrPoints[0].X, yBase );
                path.AddLine( arrPoints[0].X, yBase, arrPoints[0].X, arrPoints[0].Y );
            }
            // For stacked line types, the fill area is the area between this curve and the curve below it
            else
            {
                PointF[] arrPoints2;
                int count2;

                float tension = _isSmooth ? _smoothTension : 0f;

                // Find the next lower curve in the curveList that is also a LineItem type, and use
                // its smoothing properties for the lower side of the filled area.
                int index = pane.CurveList.IndexOf( curve );
                if ( index > 0 )
                {
                    CurveItem tmpCurve;
                    for ( int i = index - 1; i >= 0; i-- )
                    {
                        tmpCurve = pane.CurveList[i];
                        if ( tmpCurve is LineItem )
                        {
                            tension = ( (LineItem)tmpCurve ).Line.IsSmooth ? ( (LineItem)tmpCurve ).Line.SmoothTension : 0f;
                            break;
                        }
                    }
                }

                // Build another points array consisting of the low points (which are actually the points for
                // the curve below the current curve)
                BuildLowPointsArray( pane, curve, out arrPoints2, out count2 );

                // Add the new points to the GraphicsPath
                path.AddCurve( arrPoints2, 0, count2 - 2, tension );
            }
        }

        /// <summary>
        /// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents
        /// the low values for the current curve.
        /// </summary>
        /// <remarks>Note that this drawing routine ignores <see cref="PointPairBase.Missing"/>
        /// values, but it does not "break" the line to indicate values are missing.
        /// </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">A <see cref="LineItem"/> representing this
        /// curve.</param>
        /// <param name="arrPoints">An array of <see cref="PointF"/> values in pixel
        /// coordinates representing the current curve.</param>
        /// <param name="count">The number of points contained in the "arrPoints"
        /// parameter.</param>
        /// <returns>true for a successful points array build, false for data problems</returns>
        public bool BuildLowPointsArray( GraphPane pane, CurveItem curve,
						out PointF[] arrPoints, out int count )
        {
            arrPoints = null;
            count = 0;
            IPointList points = curve.Points;

            if ( this.IsVisible && !this.Color.IsEmpty && points != null )
            {
                int index = 0;
                float curX, curY,
                        lastX = 0,
                        lastY = 0;
                double x, y, hiVal;
                ValueHandler valueHandler = new ValueHandler( pane, false );

                // Step type plots get twice as many points.  Always add three points so there is
                // room to close out the curve for area fills.
                arrPoints = new PointF[( _stepType == ZedGraph.StepType.NonStep ? 1 : 2 ) *
                    ( pane.LineType == LineType.Stack ? 2 : 1 ) *
                    points.Count + 1];

                // Loop backwards over all points in the curve
                // In this case an array of points was already built forward by BuildPointsArray().
                // This time we build backwards to complete a loop around the area between two curves.
                for ( int i = points.Count - 1; i >= 0; i-- )
                {
                    // Make sure the current point is valid
                    if ( !points[i].IsInvalid )
                    {
                        // Get the user scale values for the current point
                        valueHandler.GetValues( curve, i, out x, out y, out hiVal );

                        if ( x == PointPair.Missing || y == PointPair.Missing )
                            continue;

                        // Transform the user scale values to pixel locations
                        Axis xAxis = curve.GetXAxis( pane );
                        curX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, x );
                        Axis yAxis = curve.GetYAxis( pane );
                        curY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, y );

                        // Add the pixel value pair into the points array
                        // Two points are added for step type curves
                        // ignore step-type setting for smooth curves
                        if ( _isSmooth || index == 0 || this.StepType == StepType.NonStep )
                        {
                            arrPoints[index].X = curX;
                            arrPoints[index].Y = curY;
                        }
                        else if ( this.StepType == StepType.ForwardStep )
                        {
                            arrPoints[index].X = curX;
                            arrPoints[index].Y = lastY;
                            index++;
                            arrPoints[index].X = curX;
                            arrPoints[index].Y = curY;
                        }
                        else if ( this.StepType == StepType.RearwardStep )
                        {
                            arrPoints[index].X = lastX;
                            arrPoints[index].Y = curY;
                            index++;
                            arrPoints[index].X = curX;
                            arrPoints[index].Y = curY;
                        }

                        lastX = curX;
                        lastY = curY;
                        index++;

                    }

                }

                // Make sure there is at least one valid point
                if ( index == 0 )
                    return false;

                // Add an extra point at the end, since the smoothing algorithm requires it
                arrPoints[index] = arrPoints[index - 1];
                index++;

                count = index;
//.........这里部分代码省略.........

 /// <summary>
 /// Get the Y Axis instance (either <see cref="YAxis" /> or <see cref="Y2Axis" />) to
 /// which this <see cref="CurveItem" /> belongs.
 /// </summary>
 /// <remarks>
 /// This method safely retrieves a Y Axis instance from either the <see cref="GraphPane.YAxisList" />
 /// or the <see cref="GraphPane.Y2AxisList" /> using the values of <see cref="YAxisIndex" /> and
 /// <see cref="IsY2Axis" />.  If the value of <see cref="YAxisIndex" /> is out of bounds, the
 /// default <see cref="YAxis" /> or <see cref="Y2Axis" /> is used.
 /// </remarks>
 /// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param>
 /// <returns>Either a <see cref="YAxis" /> or <see cref="Y2Axis" /> to which this
 /// <see cref="CurveItem" /> belongs.
 /// </returns>
 public Axis GetYAxis( GraphPane pane )
 {
     if ( _isY2Axis )
     {
         if ( _yAxisIndex < pane.Y2AxisList.Count )
             return pane.Y2AxisList[_yAxisIndex];
         else
             return pane.Y2AxisList[0];
     }
     else
     {
         if ( _yAxisIndex < pane.YAxisList.Count )
             return pane.YAxisList[_yAxisIndex];
         else
             return pane.YAxisList[0];
     }
 }

 /// <summary>
 /// Get the X Axis instance (either <see cref="XAxis" /> or <see cref="X2Axis" />) to
 /// which this <see cref="CurveItem" /> belongs.
 /// </summary>
 /// <param name="pane">The <see cref="GraphPane" /> object to which this curve belongs.</param>
 /// <returns>Either a <see cref="XAxis" /> or <see cref="X2Axis" /> to which this
 /// <see cref="CurveItem" /> belongs.
 /// </returns>
 public Axis GetXAxis( GraphPane pane )
 {
     if ( _isX2Axis )
         return pane.X2Axis;
     else
         return pane.XAxis;
 }

        /// <summary>
        /// Go through the list of <see cref="PointPair"/> data values for this <see cref="CurveItem"/>
        /// and determine the minimum and maximum values in the data.
        /// </summary>
        /// <param name="xMin">The minimum X value in the range of data</param>
        /// <param name="xMax">The maximum X value in the range of data</param>
        /// <param name="yMin">The minimum Y value in the range of data</param>
        /// <param name="yMax">The maximum Y value in the range of data</param>
        /// <param name="ignoreInitial">ignoreInitial is a boolean value that
        /// affects the data range that is considered for the automatic scale
        /// ranging (see <see cref="GraphPane.IsIgnoreInitial"/>).  If true, then initial
        /// data points where the Y value is zero are not included when
        /// automatically determining the scale <see cref="Scale.Min"/>,
        /// <see cref="Scale.Max"/>, and <see cref="Scale.MajorStep"/> size.  All data after
        /// the first non-zero Y value are included.
        /// </param>
        /// <param name="isBoundedRanges">
        /// Determines if the auto-scaled axis ranges will subset the
        /// data points based on any manually set scale range values.
        /// </param>
        /// <param name="pane">
        /// A reference to the <see cref="GraphPane"/> object that is the parent or
        /// owner of this object.
        /// </param>
        /// <seealso cref="GraphPane.IsBoundedRanges"/>
        public virtual void GetRange( 	out double xMin, out double xMax,
										out double yMin, out double yMax,
										bool ignoreInitial,
										bool isBoundedRanges,
										GraphPane pane )
        {
            // The lower and upper bounds of allowable data for the X values.  These
            // values allow you to subset the data values.  If the X range is bounded, then
            // the resulting range for Y will reflect the Y values for the points within the X
            // bounds.
            double xLBound = double.MinValue;
            double xUBound = double.MaxValue;
            double yLBound = double.MinValue;
            double yUBound = double.MaxValue;

            // initialize the values to outrageous ones to start
            xMin = yMin = Double.MaxValue;
            xMax = yMax = Double.MinValue;

            Axis yAxis = this.GetYAxis( pane );
            Axis xAxis = this.GetXAxis( pane );
            if ( yAxis == null || xAxis == null )
                return;

            if ( isBoundedRanges )
            {
                xLBound = xAxis._scale._lBound;
                xUBound = xAxis._scale._uBound;
                yLBound = yAxis._scale._lBound;
                yUBound = yAxis._scale._uBound;
            }

            bool isZIncluded = this.IsZIncluded( pane );
            bool isXIndependent = this.IsXIndependent( pane );
            bool isXLog = xAxis.Scale.IsLog;
            bool isYLog = yAxis.Scale.IsLog;
            bool isXOrdinal = xAxis.Scale.IsAnyOrdinal;
            bool isYOrdinal = yAxis.Scale.IsAnyOrdinal;
            bool isZOrdinal = ( isXIndependent ? yAxis : xAxis ).Scale.IsAnyOrdinal;

            // Loop over each point in the arrays
            //foreach ( PointPair point in this.Points )
            for ( int i=0; i<this.Points.Count; i++ )
            {
                PointPair point = this.Points[i];

                double curX = isXOrdinal ? i + 1 : point.X;
                double curY = isYOrdinal ? i + 1 : point.Y;
                double curZ = isZOrdinal ? i + 1 : point.Z;

                bool outOfBounds = curX < xLBound || curX > xUBound ||
                    curY < yLBound || curY > yUBound ||
                    ( isZIncluded && isXIndependent && ( curZ < yLBound || curZ > yUBound ) ) ||
                    ( isZIncluded && !isXIndependent && ( curZ < xLBound || curZ > xUBound ) ) ||
                    ( curX <= 0 && isXLog ) || ( curY <= 0 && isYLog );

                // ignoreInitial becomes false at the first non-zero
                // Y value
                if (	ignoreInitial && curY != 0 &&
                        curY != PointPair.Missing )
                    ignoreInitial = false;

                if ( 	!ignoreInitial &&
                        !outOfBounds &&
                        curX != PointPair.Missing &&
                        curY != PointPair.Missing )
                {
                    if ( curX < xMin )
                        xMin = curX;
                    if ( curX > xMax )
                        xMax = curX;
                    if ( curY < yMin )
                        yMin = curY;
                    if ( curY > yMax )
                        yMax = curY;
//.........这里部分代码省略.........

 /// <summary>
 /// Determine the coords for the rectangle associated with a specified point for 
 /// this <see cref="CurveItem" />
 /// </summary>
 /// <param name="pane">The <see cref="GraphPane" /> to which this curve belongs</param>
 /// <param name="i">The index of the point of interest</param>
 /// <param name="coords">A list of coordinates that represents the "rect" for
 /// this point (used in an html AREA tag)</param>
 /// <returns>true if it's a valid point, false otherwise</returns>
 public abstract bool GetCoords( GraphPane pane, int i, out string coords );

        /// <summary>
        /// Calculate the width of each bar, depending on the actual bar type
        /// </summary>
        /// <returns>The width for an individual bar, in pixel units</returns>
        public float GetBarWidth( GraphPane pane )
        {
            // Total axis width =
            // npts * ( nbars * ( bar + bargap ) - bargap + clustgap )
            // cg * bar = cluster gap
            // npts = max number of points in any curve
            // nbars = total number of curves that are of type IsBar
            // bar = bar width
            // bg * bar = bar gap
            // therefore:
            // totwidth = npts * ( nbars * (bar + bg*bar) - bg*bar + cg*bar )
            // totwidth = bar * ( npts * ( nbars * ( 1 + bg ) - bg + cg ) )
            // solve for bar

            float barWidth;

            if ( this is ErrorBarItem )
                barWidth = (float) ( ((ErrorBarItem)this).Bar.Symbol.Size *
                        pane.CalcScaleFactor() );
            //			else if ( this is HiLowBarItem && pane._barSettings.Type != BarType.ClusterHiLow )
            //				barWidth = (float) ( ((HiLowBarItem)this).Bar.GetBarWidth( pane,
            //						((HiLowBarItem)this).BaseAxis(pane), pane.CalcScaleFactor() ) );
            //				barWidth = (float) ( ((HiLowBarItem)this).Bar.Size *
            //						pane.CalcScaleFactor() );
            else // BarItem or LineItem
            {
                // For stacked bar types, the bar width will be based on a single bar
                float numBars = 1.0F;
                if ( pane._barSettings.Type == BarType.Cluster )
                    numBars = pane.CurveList.NumClusterableBars;

                float denom = numBars * ( 1.0F + pane._barSettings.MinBarGap ) -
                            pane._barSettings.MinBarGap + pane._barSettings.MinClusterGap;
                if ( denom <= 0 )
                    denom = 1;
                barWidth = pane.BarSettings.GetClusterWidth() / denom;
            }

            if ( barWidth <= 0 )
                return 1;

            return barWidth;
        }