C# PointD类代码示例

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="position">The position the arrow points to.</param>
 /// <param name="angle">angle of arrow with respect to x axis.</param>
 /// <param name="text">The text associated with the arrow.</param>
 public ArrowItem( PointD position, double angle, string text )
 {
     to_ = position;
     angle_ = -angle;
     text_ = text;
     Init();
 }

 public static void DrawTemplates(List<Tools.IToolFilter> templates, System.Drawing.Graphics gc, Tools.Render.RenderParameter rp, Tools.Render.RenderHint state, Tools.Render.IDrawVisitor drawMethods, PointD mousePosition)
 {
     foreach (Tools.IToolFilter filter in templates)
     {
         filter.Draw(gc, rp, state, drawMethods, mousePosition);
     }
 }

 static void ProduceIMAGE()
 {
     BitmapData data_bac = IMAGE.GetBitmapData();
     PointD p = data_bac.Half();
     PointD vector;
     double angle;
     for (int i = 0; i < 50; i++)
     {
         angle = i * 0.04 * Math.PI;
         vector = new PointD(Math.Sin(angle), -Math.Cos(angle));
         data_bac.DrawLine(Color.FromArgb(255, 255, 0), p.Add(vector, i % 5 == 0 ? 35 : 45), p.Add(vector, i % 5 == 0 ? 25 : 40));
     }
     for (int i = 0; i < 10; i++)
     {
         angle = i * 0.2 * Math.PI;
         vector = new PointD(Math.Sin(angle), -Math.Cos(angle));
         data_bac.Paste(i.ToString(),
             p.Add(vector, 40.0),
             Color.FromArgb(255, 255, 255),
             FONT_FOR_INITIALIZE,
             StringAlign.Middle,
             StringRowAlign.Middle);
     }
     data_bac.Multiply_A(0.5);
     IMAGE.UnlockBits(data_bac);
 }

 public MoveHandleAction(Handle handle, Session session, PointD oldLocation)
 {
     this.handle = handle;
       this.session = session;
       this.oldLocation = oldLocation;
       this.newLocation = handle.Location;
 }

 public Map(PointU16 mapSize, Orientation orientation, PointD cellSize, PointD origin, MapShapes mapShape = MapShapes.Rectangle)
 {
     _mapSize = mapSize;
     _shape = mapShape;
     mapLayout = new Layout(orientation, cellSize, origin);
     hexes = new List<Hex>();
 }

 public static double distance(PointD a, PointD b)
 {
     double xCuadrado = (a.X - b.X) * (a.X - b.X);
     double yCuadrado = (a.Y - b.Y) * (a.Y - b.Y);
     double distancia = Math.Sqrt(xCuadrado + yCuadrado);
     return distancia;
 }

        /// <summary>
        /// Returns a list of regular polygon's vertices, which has a 
        /// specified amount of sides and is inscribed into
        /// a circle of certain radius and center point.
        /// 
        /// The first vertice will be located at specified angle (counting counterclockwise)
        /// from the circle's rightmost point.
        /// </summary>
        /// <param name="sideCount">The total amount of polygon's sides. May be equal to 2 (then the resulting vertices will make up a line).</param>
        /// <param name="circleCenter">The center of the surrounding circle.</param>
        /// <param name="circleRadius">The radius of the surrounding circle.</param>
        /// <param name="initialAngle">The angle (in radians, counting counterclockwise from the circle's rightmost point) at which the first vertice will be located.</param>
        /// <returns>The list of regular polygon's vertices.</returns>
        public static List<PointD> RegularPolygonInscribedIntoCircle(int sideCount, PointD circleCenter, double circleRadius, double initialAngle = 0)
        {
            // Вектор в ноль градусов.
            VectorD initialVector = new VectorD(circleCenter, new PointD(circleCenter.X + circleRadius, circleCenter.Y));

            List<PointD> points = new List<PointD>(sideCount);

            // Вектор установлен на начальный угол.
            
            if(initialAngle != 0)
                initialVector = initialVector.VectorRotatedNewStartPoint(initialAngle, initialVector.StartPoint);
    
            points.Add(initialVector.EndPoint);

            double rotationAngle = 2 * Math.PI / sideCount;

            VectorD currentVector;

            for(int i=1; i<sideCount; i++)
            {
                currentVector = initialVector.VectorRotatedNewStartPoint(i * rotationAngle, initialVector.StartPoint);
                points.Add(currentVector.EndPoint);
            }

            return points;
        }

        private PointLatLng getLatLong(PointD i_location)
        {
            PointLatLng coordinates;
            coordinates = new PointLatLng(i_location.X, i_location.Y);

            return coordinates;
        }

        /// <summary>
        /// Draws the point 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 virtual void Draw( Graphics g, PhysicalAxis xAxis, PhysicalAxis yAxis )
        {
            SequenceAdapter data_ =
                new SequenceAdapter( this.DataSource, this.DataMember, this.OrdinateData, this.AbscissaData );

            float leftCutoff_ = xAxis.PhysicalMin.X - marker_.Size;
            float rightCutoff_ = xAxis.PhysicalMax.X + marker_.Size;

            for (int i=0; i<data_.Count; ++i)
            {
                if ( !Double.IsNaN(data_[i].X) && !Double.IsNaN(data_[i].Y) )
                {
                    PointF xPos = xAxis.WorldToPhysical( data_[i].X, false);
                    if (xPos.X < leftCutoff_ || rightCutoff_ < xPos.X)
                        continue;

                    PointF yPos = yAxis.WorldToPhysical( data_[i].Y, false);
                    marker_.Draw( g, (int)xPos.X, (int)yPos.Y );
                    if (marker_.DropLine)
                    {
                        PointD yMin = new PointD( data_[i].X, Math.Max( 0.0f, yAxis.Axis.WorldMin ) );
                        PointF yStart = yAxis.WorldToPhysical( yMin.Y, false );
                        g.DrawLine( marker_.Pen, (int)xPos.X,(int)yStart.Y, (int)xPos.X,(int)yPos.Y );
                    }
                }
            }
        }

        private void MainForm_MouseDown(object sender, MouseEventArgs e)
        {
            if (checkBoxAddPoint.Checked)
            {
                scene.DataPoints.Add(new PointD(e.X, e.Y));
                this.Invalidate();
                return;
            }

            mouse_start = e.Location;
            this.Text = mouse_start.ToString();
            capture = scene.HitTest(e.X, e.Y);
            switch (capture)
            {
                case 1:
                    point_start = scene.CurrentBezier.Point1;
                    break;

                case 2:
                    point_start = scene.CurrentBezier.Point2;
                    break;

                case 3:
                    point_start = scene.CurrentBezier.Point3;
                    break;

                case 4:
                    point_start = scene.CurrentBezier.Point4;
                    break;

                default:
                    break;
            }
        }

 public override void DrawRegionRepresentation(System.Drawing.Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
 {
     if (m_Param.Path.IsVisible((System.Drawing.Point)mousePosition))
     {
         gc.DrawString(ToString(), r.FontType, new System.Drawing.SolidBrush(r.RegionGuides.Color), new System.Drawing.PointF((float)mousePosition.X, (float)mousePosition.Y - 15));
     }
 }

 public void AddPoint(PointD p)
 {
     lock (tempRoute)
     {
         tempRoute.Add(p);
     }
 }

        public override bool DoMouseWheel(MouseEventArgs e, Control ctr, KeyEventArgs lastKeyEventArgs)
        {
            NPlot.PlotSurface2D ps = ((NPlot.Windows.PlotSurface2D)ctr).Inner;

            ((NPlot.Windows.PlotSurface2D)ctr).CacheAxes();

            double delta = e.Delta / (double)SystemInformation.MouseWheelScrollDelta;

            double zoomFactor = Math.Pow(sensitivity_, delta);

            PointD pMin = new PointD((double)ps.PhysicalXAxis1Cache.PhysicalMin.X, (double)ps.PhysicalYAxis1Cache.PhysicalMin.Y);
            PointD pMax = new PointD((double)ps.PhysicalXAxis1Cache.PhysicalMax.X, (double)ps.PhysicalYAxis1Cache.PhysicalMax.Y);

            PointD pMinRelative = new PointD(pMin.X - e.X, pMin.Y - e.Y);
            PointD pMaxRelative = new PointD(pMax.X - e.X, pMax.Y - e.Y);

            Point pMinZoomed = new Point((int)Math.Round((pMinRelative.X * zoomFactor) + e.X, 0), (int)Math.Round((pMinRelative.Y * zoomFactor) + e.Y, 0));
            Point pMaxZoomed = new Point((int)Math.Round((pMaxRelative.X * zoomFactor) + e.X, 0), (int)Math.Round((pMaxRelative.Y * zoomFactor) + e.Y, 0));

            ps.XAxis1.WorldMin = ps.PhysicalXAxis1Cache.PhysicalToWorld(pMinZoomed, false);
            ps.XAxis1.WorldMax = ps.PhysicalXAxis1Cache.PhysicalToWorld(pMaxZoomed, false);
            ps.YAxis1.WorldMin = ps.PhysicalYAxis1Cache.PhysicalToWorld(pMinZoomed, false);
            ps.YAxis1.WorldMax = ps.PhysicalYAxis1Cache.PhysicalToWorld(pMaxZoomed, false);

            return true;
        }

 public Effect(Bitmap image, PointD worldorpod, ImagePasteMode imagepastemode, EffectDock effectdock, Rectangle region = default(Rectangle))
     : base(null, image, default(Point), imagepastemode, region)
 {
     if (effectdock == EffectDock.Screen) throw new ArgumentException("Can't handle this parameter : effectdock");
     LOC = worldorpod;
     EFFECT_DOCK = effectdock;
 }

 public static PointD normalized2Pixels(PointD normalized)
 {
     double posX = normalized.X * (double)(Screen.PrimaryScreen.Bounds.Size.Width + Screen.PrimaryScreen.Bounds.X);
     double posY = normalized.Y * (double)(Screen.PrimaryScreen.Bounds.Size.Height + Screen.PrimaryScreen.Bounds.Y);
     PointD posicionMousePx = new PointD(posX, posY);
     return posicionMousePx;
 }