C# Point.Rotate方法代码示例

 internal static void Sweep(IEnumerable<Polyline> obstacles,
                            Point direction, double coneAngle, VisibilityGraph visibilityGraph,
                            IEnumerable<Point> portLocations) {
     var cs = new LineSweeperForPortLocations(obstacles, direction, direction.Rotate(-coneAngle/2),
                                              direction.Rotate(coneAngle/2), visibilityGraph, portLocations);
     cs.Calculate();
 }

        void Rotate(double x, double y, double x1, double y1, double r1,
										double x2, double y2, double r2,
										double x3, double y3, double r3)
        {
            Point p1 = new Point(x1, y1), p2 = new Point(x2, y2), p3 = new Point(x3, y3);
            Point p = new Point(x, y);
            // 1 2 3
            Expect(p, p1, r1, p2, r2, p3, r3);
            // 2 1 3
            Expect(p, p2, r2, p1, r1, p3, r3);
            // 3 2 1
            Expect(p, p3, r3, p2, r2, p1, r1);

            // Heavy random translation + rotations
            for (int i = 0; i < 50; i++)
            {
                double O = random.NextDouble() * 2 * Math.PI;
                Point T = new Point(random.NextDouble() * 1000 - 500, random.NextDouble() * 2000 - 1000);
                Expect((p+T).Rotate(O), (p1+T).Rotate(O), r1, (p2+T).Rotate(O), r2, (p3+T).Rotate(O), r3);
                Expect(p.Rotate(O), p1.Rotate(O), r1, p2.Rotate(O), r2, p3.Rotate(O), r3);
            }
        }

        public Point IntersectCircles(Point c1, double r1, Point c2, double r2, Point c3, double r3)
        {
            // To compute the intersection of the 3 circle, we intersect two of them, get 2
            // solutions, and see which one is on the third circle.

            // Step 1: Translate all circle centers so that c1 = (0, 0).
            c2 = c2 - c1;
            c3 = c3 - c1;

            // Step 2: Rotate all around (0, 0) so that c2 is now on Ox axis.
            double O = Math.Atan2(c2.Y, c2.X);
            c2 = c2.Rotate(-O);
            c3 = c3.Rotate(-O);

            // Step 3: Intersect circles (0, 0, r1) with (c2.X, 0, r2)
            Point p1 = new Point(), p2 = new Point(), sol;
            p1.X = p2.X = (r1 * r1 - r2 * r2 + c2.X * c2.X) / (2 * c2.X);
            // sqrt( negative zero ) = NaN
            if (r1 > p1.X) p1.Y = Math.Sqrt(r1 * r1 - p1.X * p1.X);
            else p1.Y = 0;
            p2.Y = - p1.Y;

            if (Util.IsEqual(p2.DistanceTo(c3), r3))
                sol = p2;
            else
                sol = p1;

            // Unapply step 2
            sol = sol.Rotate(O);

            // Unapply step 1
            sol = sol + c1;

            return sol;
        }

        private static Point GetSearchDirection(Point derivative, double side)
        {
            Point direction = derivative.Rotate(Math.PI / 2).Normalize() * side;

            // Rotating can cause tiny drift in the X/Y values.  Round so that 0 actually equals 0
            direction = new Point(Math.Round(direction.X, 5), Math.Round(direction.Y, 5));

            return direction;
        }

        /// <summary>
        /// Creates a spline between two nodes big enough to draw arrowheads
        /// </summary>
        /// <param name="edge"></param>
        public static void CreateBigEnoughSpline(Edge edge)
        {
            ValidateArg.IsNotNull(edge, "edge");
            Point a = edge.Source.Center;
            Point b = edge.Target.Center;
            Point bMinA = b - a;

            double l = bMinA.Length;
            Point perp;
            if (l < 0.001)
            {
                perp = new Point(1, 0);
                b = a + perp.Rotate(Math.PI / 2);
            }
            else
            {
                perp = bMinA.Rotate(Math.PI / 2);
            }

            double maxArrowLength = 1;
            if (edge.EdgeGeometry.SourceArrowhead != null)
            {
                maxArrowLength += edge.EdgeGeometry.SourceArrowhead.Length;
            }
            if (edge.EdgeGeometry.TargetArrowhead != null)
            {
                maxArrowLength += edge.EdgeGeometry.TargetArrowhead.Length;
            }
            perp = perp.Normalize() * 1.5 * maxArrowLength;

            int i = 1;
            do
            {
                CubicBezierSegment seg = Curve.CreateBezierSeg(a, b, perp, i);
                if (TrimSplineAndCalculateArrowheads(edge.EdgeGeometry, edge.Source.BoundaryCurve,
                                                     edge.Target.BoundaryCurve,
                                                     seg, false, false))
                {
                    break;
                }

                i *= 2;
                const int stop = 10000;
                if (i >= stop)
                {
                    CreateEdgeCurveWithNoTrimming(edge, a, b);
                    return;
                }
            } while (true);
        }

        void ExtendPolyline(Point tangentAtIntersection, IntersectionInfo x, Point polylineTangent, HookUpAnywhereFromInsidePort port) {

            var normal=tangentAtIntersection.Rotate(Math.PI/2);
            if(normal*polylineTangent<0)
                normal=-normal;

            var pointBeforeLast = x.IntersectionPoint + normal * port.HookSize;
            Point pointAfterX;
            if (!Point.LineLineIntersection(pointBeforeLast, pointBeforeLast+tangentAtIntersection, _polyline.End, _polyline.End+polylineTangent, out pointAfterX))
                return;

            _polyline.AddPoint(pointAfterX);
            _polyline.AddPoint(pointBeforeLast);
            _polyline.AddPoint(x.IntersectionPoint);
        }

        /// <summary>
        /// p1 and p2 represent the closest feature. Two cases are possible p1=p2, or p1 and p2 share an edge going from p1 to p2
        /// Remind that the polygons are oriented clockwise
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <param name="bisectorPivot"></param>
        /// <param name="bisectorRay"></param>
        /// <returns></returns>
        internal int FindTheFurthestVertexFromBisector(int p1, int p2, Point bisectorPivot, Point bisectorRay) {
            Point directionToTheHill = bisectorRay.Rotate(Math.PI / 2);
            if ((polyline.StartPoint.Point - bisectorPivot) * directionToTheHill < 0)
                directionToTheHill = -directionToTheHill;
            if (p1 == p2)
                p2 = Next(p1);
            //binary search
            do {
                int m = Median(p2, p1); //now the chunk goes clockwise from p2 to p1
                Point mp = Pnt(m);

                if ((Pnt(Next(m)) - mp) * directionToTheHill >= 0)
                    p2 = Next(m);
                else if ((Pnt(Prev(m)) - mp) * directionToTheHill >= 0)
                    p1 = Prev(m);
                else
                    p1 = p2 = m;
            }
            while (p1 != p2);

            return p1;
        }

 public void RotateTest1()
 {
     var p1 = new Point (1, 0);
     var p2 = new Point (0, 0);
     p1.Rotate (p2, Math.PI / 2);
     TestHelper.AlmostEqual (p1.X, 0);
     TestHelper.AlmostEqual (p1.Y, 1);
 }