C# GraphPane.ReverseTransform方法代码示例

        /// <summary>
        /// Zoom a specified pane in or out according to the specified zoom fraction.
        /// </summary>
        /// <remarks>
        /// The zoom will occur on the <see cref="XAxis" />, <see cref="YAxis" />, and
        /// <see cref="Y2Axis" /> only if the corresponding flag, <see cref="IsEnableHZoom" /> or
        /// <see cref="IsEnableVZoom" />, is true.  Note that if there are multiple Y or Y2 axes, all of
        /// them will be zoomed.
        /// </remarks>
        /// <param name="pane">The <see cref="GraphPane" /> instance to be zoomed.</param>
        /// <param name="zoomFraction">The fraction by which to zoom, less than 1 to zoom in, greater than
        /// 1 to zoom out.  For example, 0.9 will zoom in such that the scale is 90% of what it was
        /// originally.</param>
        /// <param name="centerPt">The screen position about which the zoom will be centered.  This
        /// value is only used if <see paramref="isZoomOnCenter" /> is true.
        /// </param>
        /// <param name="isZoomOnCenter">true to cause the zoom to be centered on the point
        /// <see paramref="centerPt" />, false to center on the <see cref="Chart.Rect" />.
        /// </param>
        /// <param name="isRefresh">true to force a refresh of the control, false to leave it unrefreshed</param>
        protected void ZoomPane(GraphPane pane, double zoomFraction, PointF centerPt,
            bool isZoomOnCenter, bool isRefresh)
        {
            double x;
            double x2;
            double[] y;
            double[] y2;

            pane.ReverseTransform(centerPt, out x, out x2, out y, out y2);

            if (_isEnableHZoom) {
                ZoomScale(pane.XAxis, zoomFraction, x, isZoomOnCenter);
                ZoomScale(pane.X2Axis, zoomFraction, x2, isZoomOnCenter);
            }
            if (_isEnableVZoom) {
                for (int i = 0; i < pane.YAxisList.Count; i++)
                    ZoomScale(pane.YAxisList[i], zoomFraction, y[i], isZoomOnCenter);
                for (int i = 0; i < pane.Y2AxisList.Count; i++)
                    ZoomScale(pane.Y2AxisList[i], zoomFraction, y2[i], isZoomOnCenter);
            }

            using (Graphics g = this.CreateGraphics()) {
                pane.AxisChange(g);
                //g.Dispose();
            }

            this.SetScroll(this.hScrollBar1, pane.XAxis, _xScrollRange.Min, _xScrollRange.Max);
            this.SetScroll(this.vScrollBar1, pane.YAxis, _yScrollRangeList[0].Min,
                           _yScrollRangeList[0].Max);

            if (isRefresh)
                Refresh();
        }

 private string z1_CursorValueEvent( ZedGraphControl z1, GraphPane pane, Point mousePt )
 {
     double x, y;
     pane.ReverseTransform( mousePt, out x, out y );
     return "( " + x.ToString( "f2" ) + ", " + y.ToString( "f2" ) + " )";
 }

        public bool DoDrag(GraphPane graphPane, PointF pt)
        {
            // Calculate new location of boundary from mouse position
            double time, yTemp;
            graphPane.ReverseTransform(pt, out time, out yTemp);

            bool changed = false;
            foreach (var dragInfo in _peakBoundDragInfos)
            {
                if (dragInfo.MoveTo(pt, time, IsMultiGroup,
                    (startTime, endTime) => FindMaxPeakItem(graphPane, startTime, endTime)))
                    changed = true;
            }
            return changed;
        }

        private ScaledRetentionTime FindBestPeakTime(GraphPane graphPane, CurveItem curve, PointF pt, out ChromGraphItem graphItem)
        {
            graphItem = FindBestPeakItem(curve);
            if (graphItem != null)
            {
                double displayTime, yTemp;
                graphPane.ReverseTransform(pt, out displayTime, out yTemp);
                return graphItem.GetNearestDisplayTime(displayTime);
            }

            return ScaledRetentionTime.ZERO;
        }

        private ScaledRetentionTime FindBestPeakBoundary(PointF pt, out GraphPane graphPane, out ChromGraphItem graphItem)
        {
            double deltaBest = double.MaxValue;
            ScaledRetentionTime timeBest = ScaledRetentionTime.ZERO;
            graphItem = null;
            ChromGraphItem graphItemBest = null;
            graphPane = GraphPaneFromPoint(pt);
            if (null != graphPane)
            {
                double time, yTemp;
                graphPane.ReverseTransform(pt, out time, out yTemp);

                foreach (var graphItemNext in GetGraphItems(graphPane))
                {
                    var transitionChromInfo = graphItemNext.TransitionChromInfo;
                    if (transitionChromInfo == null)
                    {
                        continue;
                    }
                    var timeMatch = graphItemNext.GetNearestBestPeakBoundary(time);
                    if (!timeMatch.IsZero)
                    {
                        double delta = Math.Abs(time - timeMatch.DisplayTime);
                        if (delta < deltaBest)
                        {
                            deltaBest = delta;
                            timeBest = timeMatch;
                            graphItemBest = graphItemNext;
                        }
                    }
                }

                // Only match if the best time is close enough in absolute pixels
                if (graphItemBest != null && Math.Abs(pt.X - graphPane.XAxis.Scale.Transform(timeBest.DisplayTime)) > 3)
                    graphItemBest = null;

                graphItem = graphItemBest;
            }
            if (graphItem == null)
            {
                return ScaledRetentionTime.ZERO;
            }
            return timeBest;
        }

 private string zGraph_CursorValueEvent(ZedGraphControl sender, GraphPane pane, Point mousePt)
 {
     double x, y;
     pane.ReverseTransform(mousePt, out x, out y);
     return string.Format("X={0} Y={1}", ((XDate)x).ToString("mm:ss"), y);
 }