Stop() публичный статический Метод

public static Stop ( Stopwatch sw ) : void
sw System.Diagnostics.Stopwatch
Результат void
Пример #1
0
        /// <summary>
        /// Draws the line plot on a GDI+ surface against the provided x and y axes.
        /// </summary>
        /// <param name="g">The GDI+ surface on which to draw.</param>
        /// <param name="xAxis">The X-Axis to draw against.</param>
        /// <param name="yAxis">The Y-Axis to draw against.</param>
        public void Draw(Graphics g, PhysicalAxis xAxis, PhysicalAxis yAxis)
        {
            try
            {
                double xVal, yVal;

                int pointCount = m_lineData.Count;
                if (pointCount == 0)
                {
                    return;
                }

                Stopwatch sw = StepTimer.Start("Transform");

                Transform2D t = new Transform2D(xAxis, yAxis);

                // clipping is now handled assigning a clip region in the
                // graphic object before this call
                if (pointCount == 1)
                {
                    m_lineData.Get(0, out xVal, out yVal);
                    PointF physical = t.Transform(xVal, yVal);
                    g.DrawLine(Pen, physical.X - 0.5f, physical.Y, physical.X + 0.5f, physical.Y);
                }
                else
                {
                    int      index     = 0;
                    PointF[] points    = new PointF[pointCount];
                    PointF   lastPoint = new PointF(Single.NaN, Single.NaN);
                    for (int i = 0; i < pointCount; ++i)
                    {
                        // check to see if any values null. If so, then continue.
                        m_lineData.Get(i, out xVal, out yVal);

                        if (!Double.IsNaN(xVal + yVal)) //Adding a NaN with anything yeilds NaN
                        {
                            const float GDIMax = 1000000000f;
                            const float GDIMin = -1000000000f;
                            PointF      p1     = t.Transform(xVal, yVal);
                            if (p1.X > GDIMax)
                            {
                                p1.X = GDIMax;
                            }
                            if (p1.X < GDIMin)
                            {
                                p1.X = GDIMin;
                            }

                            if (p1.Y > GDIMax)
                            {
                                p1.Y = GDIMax;
                            }
                            if (p1.Y < GDIMin)
                            {
                                p1.Y = GDIMin;
                            }

                            if (!float.IsNaN(p1.X) && !float.IsNaN(p1.Y))
                            {
                                if (p1 != lastPoint)
                                {
                                    lastPoint     = p1;
                                    points[index] = p1;
                                    index++;
                                }
                            }
                        }
                    }
                    //System.Drawing.Drawing2D.GraphicsPath graphicsPath = new System.Drawing.Drawing2D.GraphicsPath();
                    //graphicsPath.AddLines(points.ToArray());
                    //g.DrawPath(Pen, graphicsPath);
                    //g.CompositingQuality = CompositingQuality.HighQuality;
                    //g.SmoothingMode = SmoothingMode.HighQuality;
                    StepTimer.Stop(sw);

                    sw = StepTimer.Start("GDI+");
                    if (index == 0)
                    {
                        return;
                    }
                    else if (index == 1)
                    {
                        PointF physical = points[0];
                        g.DrawLine(Pen, physical.X - 0.5f, physical.Y, physical.X + 0.5f, physical.Y);
                        return;
                    }
                    if (index == points.Length)
                    {
                        g.DrawLines(Pen, points);
                    }
                    else
                    {
                        PointF[] newArray = new PointF[index];
                        Array.Copy(points, 0, newArray, 0, index);
                        g.DrawLines(Pen, newArray);
                    }
                    StepTimer.Stop(sw);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
                throw;
            }
        }
Пример #2
0
        /// <summary>
        /// Draw the the PlotSurface2D and all contents [axes, drawables] on the
        /// supplied graphics surface.
        /// </summary>
        /// <param name="g">The graphics surface on which to draw.</param>
        /// <param name="bounds">A bounding box on this surface that denotes the area on the
        /// surface to confine drawing to.</param>
        public void Draw(Graphics g, Rectangle bounds)
        {
            // determine font sizes and tick scale factor.
            float scale = DetermineScaleFactor(bounds.Width, bounds.Height);

            // if there is nothing to plot, return.
            if (m_drawables.Count == 0)
            {
                // draw title
                float x_center = (bounds.Left + bounds.Right) / 2.0f;
                float y_center = (bounds.Top + bounds.Bottom) / 2.0f;
                Font  scaled_font;
                if (AutoScaleTitle)
                {
                    scaled_font = Utils.ScaleFont(m_titleFont, scale);
                }
                else
                {
                    scaled_font = m_titleFont;
                }
                g.DrawString(m_title, scaled_font, this.m_titleBrush, new PointF(x_center, y_center), m_titleDrawFormat);

                return;
            }

            Stopwatch sw = StepTimer.Start("Determine Axis");

            // determine the [non physical] axes to draw based on the axis properties set.
            Axis xAxis1, xAxis2, yAxis1, yAxis2;

            DetermineAxesToDraw(out xAxis1, out xAxis2, out yAxis1, out yAxis2);

            // apply scale factor to axes as desired.
            if (xAxis1.AutoScaleTicks)
            {
                xAxis1.TickScale = scale;
            }
            if (xAxis1.AutoScaleText)
            {
                xAxis1.FontScale = scale;
            }
            if (yAxis1.AutoScaleTicks)
            {
                yAxis1.TickScale = scale;
            }
            if (yAxis1.AutoScaleText)
            {
                yAxis1.FontScale = scale;
            }
            if (xAxis2.AutoScaleTicks)
            {
                xAxis2.TickScale = scale;
            }
            if (xAxis2.AutoScaleText)
            {
                xAxis2.FontScale = scale;
            }
            if (yAxis2.AutoScaleTicks)
            {
                yAxis2.TickScale = scale;
            }
            if (yAxis2.AutoScaleText)
            {
                yAxis2.FontScale = scale;
            }

            // determine the default physical positioning of those axes.
            PhysicalAxis pXAxis1, pYAxis1, pXAxis2, pYAxis2;

            DeterminePhysicalAxesToDraw(bounds, xAxis1, xAxis2, yAxis1, yAxis2, out pXAxis1, out pXAxis2, out pYAxis1, out pYAxis2);

            StepTimer.Stop(sw);

            float oldXAxis2Height = pXAxis2.PhysicalMin.Y;

            // Apply axes constraints
            for (int i = 0; i < m_axesConstraints.Count; ++i)
            {
                (m_axesConstraints[i]).ApplyConstraint(pXAxis1, pYAxis1, pXAxis2, pYAxis2);
            }

            float newXAxis2Height = pXAxis2.PhysicalMin.Y;

            float titleExtraOffset = oldXAxis2Height - newXAxis2Height;

            sw = StepTimer.Start("Draw Axis");

            // now we are ready to define the bounding box for the plot area (to use in clipping
            // operations.
            m_plotAreaBoundingBoxCache = new Rectangle(
                Math.Min(pXAxis1.PhysicalMin.X, pXAxis1.PhysicalMax.X),
                Math.Min(pYAxis1.PhysicalMax.Y, pYAxis1.PhysicalMin.Y),
                Math.Abs(pXAxis1.PhysicalMax.X - pXAxis1.PhysicalMin.X + 1),
                Math.Abs(pYAxis1.PhysicalMin.Y - pYAxis1.PhysicalMax.Y + 1)
                );
            m_bbXAxis1Cache = pXAxis1.GetBoundingBox();
            m_bbXAxis2Cache = pXAxis2.GetBoundingBox();
            m_bbYAxis1Cache = pYAxis1.GetBoundingBox();
            m_bbYAxis2Cache = pYAxis2.GetBoundingBox();

            // Fill in the background.
            g.FillRectangle(new SolidBrush(m_plotBackColor), m_plotAreaBoundingBoxCache);

            // draw title
            float xt = (pXAxis2.PhysicalMax.X + pXAxis2.PhysicalMin.X) / 2.0f;
            float yt = bounds.Top + m_padding - titleExtraOffset;
            Font  scaledFont;

            if (AutoScaleTitle)
            {
                scaledFont = Utils.ScaleFont(m_titleFont, scale);
            }
            else
            {
                scaledFont = m_titleFont;
            }
            g.DrawString(m_title, scaledFont, m_titleBrush, new PointF(xt, yt), m_titleDrawFormat);

            //count number of new lines in title.
            int nlCount = 0;

            for (int i = 0; i < m_title.Length; ++i)
            {
                if (m_title[i] == '\n')
                {
                    nlCount += 1;
                }
            }

            SizeF s = g.MeasureString(m_title, scaledFont);

            m_bbTitleCache = new Rectangle((int)(xt - s.Width / 2), (int)(yt), (int)(s.Width), (int)(s.Height) * (nlCount + 1));

            StepTimer.Stop(sw);

            //sw = StepTimer.Start("Draw IDrawables");

            // draw drawables..
            SmoothingMode smoothSave = g.SmoothingMode;

            g.SmoothingMode = m_smoothingMode;

            for (int i_o = 0; i_o < m_ordering.Count; ++i_o)
            {
                int i = m_ordering.Values[i_o];

                IDrawable drawable = m_drawables[i];

                PhysicalAxis drawXAxis;
                PhysicalAxis drawYAxis;

                drawXAxis = pXAxis1;
                drawYAxis = pYAxis1;

                // set the clipping region.. (necessary for zoom)
                g.Clip = new Region(m_plotAreaBoundingBoxCache);
                // plot.
                drawable.Draw(g, drawXAxis, drawYAxis);
                // reset it..
                g.ResetClip();
            }

            //StepTimer.Stop(sw);

            // cache the physical axes we used on this draw;
            m_pXAxis1Cache = pXAxis1;
            m_pYAxis1Cache = pYAxis1;
            m_pXAxis2Cache = pXAxis2;
            m_pYAxis2Cache = pYAxis2;

            g.SmoothingMode = smoothSave;

            sw = StepTimer.Start("Draw Axis Final");
            // now draw axes.
            Rectangle axisBounds;

            pXAxis1.Draw(g, out axisBounds);
            pXAxis2.Draw(g, out axisBounds);
            pYAxis1.Draw(g, out axisBounds);
            pYAxis2.Draw(g, out axisBounds);

            StepTimer.Stop(sw);
        }