C# Stroke.GetPoints方法代码示例

    //
    // Implementation
    private static Point[] SegmentizeStroke(Stroke stroke, double tolerance, out int[] indices)
    {
        // Grab the ink points.
        Point[] points = stroke.GetPoints();
        int n = points.Length;

        // Segmentize at desired tolerance, to produce array of vertices.
        ArrayList vertexIndices = new ArrayList();
        vertexIndices.Add(0);
        SegmentizeSquiggle(vertexIndices,points,0,n-1,tolerance);
        // populates vertexIndices list

        indices = vertexIndices.ToArray(typeof(int)) as int[];

        int nv = indices.Length;
        Point[] vertices = new Point[nv];

        for (int i=0; i < nv; ++i)
        {
            int index = indices[i];
            vertices[i] = points[index];
        }

        return vertices;
    }

    private RigidBodyBase MakeBodyFromClosedStroke(Stroke stroke, Point[] vertices)
    {
        // Form a new body -- ellipse or polygon?
        RigidBodyBase newbody = null;

        Point[] points = stroke.GetPoints();
        Ellipse elli = Ellipse.FromRegression(points);
        if (!elli.IsEmpty && elli.IsFit(points))
        {
            dbg.WriteLine("new EllipticalBody");

            newbody = new EllipticalBody();
            EllipticalBody body = newbody as EllipticalBody;

            body.CenterPoint = elli.Center;
            body.MajorAxis = elli.MajorAxis;
            body.MinorAxis = elli.MinorAxis;
            body.Orientation = elli.Orientation;

            // Close to circle? Snap to it.
            if ((float)elli.MajorAxis/(float)elli.MinorAxis < 1.25)
            {
                int r = (elli.MajorAxis+elli.MinorAxis)/2;
                body.MajorAxis = body.MinorAxis = r;
                body.Orientation = 0;
            }
        }
        else
        {
            dbg.WriteLine("new PolygonalBody");

            newbody = new PolygonalBody();
            PolygonalBody body = newbody as PolygonalBody;
            body.Vertices = vertices;
        }

        dbg.WriteLine(String.Format("Mass={0}, I={1}",newbody.Mass,newbody.I));

        newbody.strokeid = stroke.Id;
        doc.Bodies.Add(newbody);

        return newbody;
    }

 /* Returns true if the stroke resembles a circle given a tolerance.
  * Accomplishes this by taking the perimeter of a circle that
  * would be bounded in the area the stroke is bounded and
  * comparing it to the length of the stroke.
  */
 public static bool FitsCircleProperties(Stroke e, double tolerance)
 {
     if(e == null) return false;
     Rectangle r = e.GetBoundingBox();
     double radius = StrokeManager.Avg(r.Height,r.Width) / 2.0;
     if(radius < MIN_WIDTH/2) return false;
     double perimeter = 2.0*radius*Math.PI;
     Point[] points = e.GetPoints();
     double strokeLength = StrokeManager.StrokeLength(e);
     return Math.Abs(perimeter-strokeLength) <= tolerance;
 }

 //Creates a deep copy of the stroke s
 public static Stroke CopyStroke(Stroke s)
 {
     Point[] p = s.GetPoints();
     return s.Ink.CreateStroke(p);
 }

 //Gets the length of a stroke
 public static double StrokeLength(Stroke e)
 {
     double dist = 0;
     Point[] points = e.GetPoints();
     for(int i=0; i<points.Length-1; i++)
     {
         dist += StrokeManager.Distance(points[i], points[i+1]);
     }
     return dist;
 }

        /* Determines whether the following stroke could be interpreted as
         * an edge (or edges) and if so, returns all the consecutive nodes that the
         * stroke has gone through in order.
         */
        public static Nodes ifEdgeGetNodes(Stroke s, Graph g)
        {
            Point[] sPoints = s.GetPoints();
            Nodes strokeHitNodes = new Nodes();
            Node prev = null;
            for(int i=0; i<sPoints.Length; i++)
            {
                for(int j=0; j<g.Nodes.Length(); j++)
                {
                    Node n = g.Nodes[j];
                    Rectangle r = n.Stroke.GetBoundingBox();

                    if(s.HitTest(n.CenterPoint,Math.Max(r.Width/2, r.Height/2)) && r.Contains(sPoints[i]) && !n.Equals(prev))
                    {
                        strokeHitNodes.Add(n);
                        prev = n;
                        break;
                    }
                }
            }
            //If stroke hit one or less nodes, it is clearly not an edge.
            if(strokeHitNodes.Length() < 2)
            {
                return null;
            }
            return strokeHitNodes;
        }

 /* Gets all the objects, nodes and edges, from graph g
  * hit by this stroke and returns an arraylist containing them all
  */
 public static ArrayList HitObjects(Stroke s, Graph g)
 {
     ArrayList objs = new ArrayList();
     Point[] points = s.GetPoints();
     for(int j=0; j<g.Edges.Length(); j++)
     {
         for(int i=0; i<points.Length; i++)
         {
             if(g.Edges[j].Stroke.HitTest(points[i],1))
             {
                 objs.Add(g.Edges[j]);
             }
         }
     }
     for(int j=0; j<g.Nodes.Length(); j++)
     {
         for(int i=0; i<points.Length; i++)
         {
             if(g.Nodes[j].Stroke.HitTest(points[i],1))
             {
                 objs.Add(g.Nodes[j]);
             }
         }
     }
     return objs;
 }