C# CurveItem.GetXAxis方法代码示例

 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>
		/// Create a URL for a <see cref="CurveItem" /> that includes the index of the
		/// point that was selected.
		/// </summary>
		/// <remarks>
		/// An "index" parameter is added to the <see cref="Url" /> property for this
		/// link to indicate which point was selected.  Further, if the 
		/// X or Y axes that correspond to this <see cref="CurveItem" /> are of
		/// <see cref="AxisType.Text" />, then an
		/// additional parameter will be added containing the text value that
		/// corresponds to the <paramref name="index" /> of the selected point.
		/// The <see cref="XAxis" /> text parameter will be labeled "xtext", and
		/// the <see cref="YAxis" /> text parameter will be labeled "ytext".
		/// </remarks>
		/// <param name="index">The zero-based index of the selected point</param>
		/// <param name="pane">The <see cref="GraphPane" /> of interest</param>
		/// <param name="curve">The <see cref="CurveItem" /> for which to
		/// make the url string.</param>
		/// <returns>A string containing the url with an index parameter added.</returns>
		public virtual string MakeCurveItemUrl( GraphPane pane, CurveItem curve, int index )
		{
			string url = _url;

			if ( url.IndexOf( '?' ) >= 0 )
				url += "&index=" + index.ToString();
			else
				url += "?index=" + index.ToString();

			Axis xAxis = curve.GetXAxis( pane );
			if (	xAxis.Type == AxisType.Text && index >= 0 &&
					xAxis.Scale.TextLabels != null &&
					index <= xAxis.Scale.TextLabels.Length )
				url += "&xtext=" + xAxis.Scale.TextLabels[index];

			Axis yAxis = curve.GetYAxis( pane );
			if (	yAxis != null && yAxis.Type == AxisType.Text && index >= 0 &&
					yAxis.Scale.TextLabels != null &&
					index <= yAxis.Scale.TextLabels.Length )
				url += "&ytext=" + yAxis.Scale.TextLabels[index];

			return url;
		}

        /// <summary>
        /// Render the <see cref="Line"/>'s as vertical sticks (from a <see cref="StickItem" />) to
        /// the specified <see cref="Graphics"/> device.
        /// </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="curve">A <see cref="CurveItem"/> representing this
        /// 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="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 void DrawSticks( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor )
        {
            Line source = this;
            if ( curve.IsSelected )
                source = Selection.Line;

            Axis yAxis = curve.GetYAxis( pane );
            Axis xAxis = curve.GetXAxis( pane );

            float basePix = yAxis.Scale.Transform( 0.0 );
            using ( Pen pen = source.GetPen( pane, scaleFactor ) )
            {
                for ( int i = 0; i < curve.Points.Count; i++ )
                {
                    PointPair pt = curve.Points[i];

                    if ( pt.X != PointPair.Missing &&
                            pt.Y != PointPair.Missing &&
                            !System.Double.IsNaN( pt.X ) &&
                            !System.Double.IsNaN( pt.Y ) &&
                            !System.Double.IsInfinity( pt.X ) &&
                            !System.Double.IsInfinity( pt.Y ) &&
                            ( !xAxis._scale.IsLog || pt.X > 0.0 ) &&
                            ( !yAxis._scale.IsLog || pt.Y > 0.0 ) )
                    {
                        float pixY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.Y );
                        float pixX = xAxis.Scale.Transform( curve.IsOverrideOrdinal, i, pt.X );

                        if ( pixX >= pane.Chart._rect.Left && pixX <= pane.Chart._rect.Right )
                        {
                            if ( pixY > pane.Chart._rect.Bottom )
                                pixY = pane.Chart._rect.Bottom;
                            if ( pixY < pane.Chart._rect.Top )
                                pixY = pane.Chart._rect.Top;

                            if ( !curve.IsSelected && this._gradientFill.IsGradientValueType )
                            {
                                using ( Pen tPen = GetPen( pane, scaleFactor, pt ) )
                                    g.DrawLine( tPen, pixX, pixY, pixX, basePix );
                            }
                            else
                                g.DrawLine( pen, pixX, pixY, pixX, basePix );

                        }
                    }
                }
            }
        }

        /// <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 DrawCurve( 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;

            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 );
                            tmpY = yAxis.Scale.Transform( curve.IsOverrideOrdinal, i, curY );
                            isOut = (tmpX < minX || tmpX > maxX);
//.........这里部分代码省略.........

        /// <summary>
        /// Build an array of <see cref="PointF"/> values (pixel coordinates) that represents
        /// the current curve.  Note that this drawing routine ignores <see cref="PointPairBase.Missing"/>
        /// values, but it does not "break" the line to indicate values are missing.
        /// </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 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 BuildPointsArray( 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, lowVal;
                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 ) *
                                            points.Count + 1];

                // Loop over all points in the curve
                for ( int i = 0; i < points.Count; i++ )
                {
                    // make sure that the current point is valid
                    if ( !points[i].IsInvalid )
                    {
                        // Get the user scale values for the current point
                        // use the valueHandler only for stacked types
                        if ( pane.LineType == LineType.Stack )
                        {
                            valueHandler.GetValues( curve, i, out x, out lowVal, out y );
                        }
                        // otherwise, just access the values directly.  Avoiding the valueHandler for
                        // non-stacked types is an optimization to minimize overhead in case there are
                        // a large number of points.
                        else
                        {
                            x = points[i].X;
                            y = points[i].Y;
                        }

                        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 );

                        if ( curX < -1000000 || curY < -1000000 || curX > 1000000 || curY > 1000000 )
                            continue;

                        // 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++;

                    }

                }
//.........这里部分代码省略.........

        /// <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>
        /// 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 DrawCurve( Graphics g, GraphPane pane,
            CurveItem curve, float scaleFactor)
        {
            Line source = this;
            if ( curve.IsSelected )
                source = Selection.Line;

            // switch to int to optimize drawing speed (per Dale-a-b)
            int	tmpX, tmpY,
                    lastX = int.MaxValue,
                    lastY = int.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;

            // switch to int to optimize drawing speed (per Dale-a-b)
            int minX = (int)pane.Chart.Rect.Left;
            int maxX = (int)pane.Chart.Rect.Right;
            int minY = (int)pane.Chart.Rect.Top;
            int maxY = (int)pane.Chart.Rect.Bottom;

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

                    bool isOptDraw = _isOptimizedDraw && points.Count > 1000;

                    // (Dale-a-b) we'll set an element to true when it has been drawn
                    bool[,] isPixelDrawn = null;

                    if ( isOptDraw )
                        isPixelDrawn = new bool[maxX + 1, maxY + 1];

                    // 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 ) )
//.........这里部分代码省略.........