C# Vector3D.RotateAboutAxis方法代码示例

        /// <summary>
        /// NOTE: Not general, and assumes some things we know about this problem domain, 
        /// e.g. that c1 and c2 live on the same sphere of radius 1, and have two intersection points.
        /// </summary>
        public static void IntersectionCircleCircle( Vector3D sphereCenter, Circle3D c1, Circle3D c2, out Vector3D i1, out Vector3D i2 )
        {
            // Spherical analogue of our flat circle-circle intersection.
            // Spherical pythagorean theorem for sphere where r=1: cos(hypt) = cos(A)*cos(B)

            Circle3D clone1 = c1.Clone(), clone2 = c2.Clone();
            //clone1.Center -= sphereCenter;
            //clone2.Center -= sphereCenter;

            // Great circle (denoted by normal vector), and distance between the centers.
            Vector3D gc = clone2.Normal.Cross( clone1.Normal );
            double d = clone2.Normal.AngleTo( clone1.Normal );
            double r1 = clone1.Normal.AngleTo( clone1.PointOnCircle );
            double r2 = clone2.Normal.AngleTo( clone2.PointOnCircle );

            // Calculate distances we need.  So ugly!
            // http://www.wolframalpha.com/input/?i=cos%28r1%29%2Fcos%28r2%29+%3D+cos%28x%29%2Fcos%28d-x%29%2C+solve+for+x
            double t1 = Math.Pow( Math.Tan( d / 2 ), 2 );
            double t2 = Math.Cos( r1 ) / Math.Cos( r2 );
            double t3 = Math.Sqrt( (t1 + 1) * (t1 * t2 * t2 + 2 * t1 * t2 + t1 + t2 * t2 - 2 * t2 + 1) ) - 2 * t1 * t2;
            double x = 2 * Math.Atan( t3 / (t1 * t2 + t1 - t2 + 1) );
            double y = Math.Acos( Math.Cos( r1 ) / Math.Cos( x ) );

            i1 = clone1.Normal;
            i1.RotateAboutAxis( gc, x );
            i2 = i1;

            // Perpendicular to gc through i1.
            Vector3D gc2 = i1.Cross( gc );
            i1.RotateAboutAxis( gc2, y );
            i2.RotateAboutAxis( gc2, -y );
            i1 += sphereCenter;
            i2 += sphereCenter;

            /*
            // It would be nice to do the spherical analogue of circle-circle intersections, like here:
            // http://mathworld.wolfram.com/Circle-CircleIntersection.html
            // But I don't want to jump down that rabbit hole and am going to sacrifice some speed to use
            // my existing euclidean function.

            // Stereographic projection to the plane.  XXX - Crap, circles may become lines, and this isn't being handled well.
            Circle3D c1Plane = H3Models.BallToUHS( clone1 );
            Circle3D c2Plane = H3Models.BallToUHS( clone2 );
            if( 2 != Euclidean2D.IntersectionCircleCircle( c1Plane.ToFlatCircle(), c2Plane.ToFlatCircle(), out i1, out i2 ) )
                throw new System.Exception( "Expected two intersection points" );
            i1 = H3Models.UHSToBall( i1 ); i1 += sphereCenter;
            i2 = H3Models.UHSToBall( i2 ); i2 += sphereCenter;
            */
        }

        public Vector3D Transform( Vector3D v )
        {
            v.RotateAboutAxis( new Vector3D( 1, 0 ), Math.PI / 2 );

            Mobius m = new Mobius();
            m.Isometry( Geometry.Hyperbolic, 0, new Complex( 0, 0.6 ) );
            v = H3Models.TransformHelper( v, m );

            v.RotateAboutAxis( new Vector3D( 1, 0 ), -Math.PI / 2 );
            return v;
        }

        public void AddArc( Vector3D center, double arcRadius, Vector3D v1, Vector3D normal, double angleTot, int numPoints, System.Func<Vector3D, double> sizeFunc )
        {
            if( numPoints < 2 )
                numPoints = 2;

            Vector3D[] points = CalcArcPoints( center, arcRadius, v1, normal, angleTot, numPoints );

            // Calculate all the disks.
            // XXX - duplicated code with CalcDisks, but we need to calc our own perpendicular here.
            List<Vector3D[]> disks = new List<Vector3D[]>();
            for( int i=0; i<points.Length; i++ )
            {
                Vector3D p1 = i == 0 ? points[0] : points[i - 1];
                Vector3D p2 = points[i];
                Vector3D p3 = i == points.Length - 1 ? points[points.Length - 1] : points[i + 1];
                double radius = sizeFunc( points[i] );

                // We can calculate these directly.
                Vector3D perp = p2 - center;
                perp.Normalize();
                Vector3D axis = perp;
                axis.RotateAboutAxis( normal, -Math.PI / 2 );
                perp *= radius;

                disks.Add( Disk( p2, axis, perp, this.Div, reverse: false ) );
            }

            ///////////////////////////////////////// Hack to avoid having to put spheres at verts.
            double thickness = 0.0055;	// relates to SizeFuncConst
            double thetaOffset = thickness / arcRadius;
            Vector3D start = points[0], end = points[points.Length-1];
            start -= center;
            end -= center;
            start.RotateAboutAxis( normal, -thetaOffset );
            end.RotateAboutAxis( normal, thetaOffset );
            start += center;
            end += center;
            points[0] = start;
            points[points.Length - 1] = end;
            /////////////////////////////////////////

            AddCurve( disks, points, points.First(), points.Last() );
        }

            /// <summary>
            /// Given a geodesic sphere, calculates 3 ideal points of the sphere.
            /// NOTE: s1 and s2 will be antipodal on the ideal circle.
            /// </summary>
            public static void IdealPoints( Sphere s, out Vector3D s1, out Vector3D s2, out Vector3D s3 )
            {
                // Get two points on the ball and sphere.
                // http://mathworld.wolfram.com/OrthogonalCircles.html
                // Orthogonal circles, plus some right angle stuff...
                double r = s.Radius;
                Vector3D direction = s.Center;
                Vector3D perp = direction.Perpendicular();
                direction.Normalize();
                s1 = direction;
                s2 = direction;

                double alpha = Math.Atan( r );
                s1.RotateAboutAxis( perp, alpha );
                s2.RotateAboutAxis( perp, -alpha );
                s3 = s1;
                s3.RotateAboutAxis( direction, Math.PI / 2 );
            }