コード例 #1
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D operator *( Matrix4D m, double s )
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
     for( int j=0; j<4; j++ )
         result[i, j] = m[i, j] * s;
     return result;
 }
コード例 #2
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D operator *( Matrix4D m1, Matrix4D m2 )
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
     for( int j=0; j<4; j++ )
     for( int k=0; k<4; k++ )
         result[i, j] += m1[i, k] * m2[k, j];
     return result;
 }
コード例 #3
0
        /// <summary>
        /// Handles updating our rotation matrices based on mouse dragging.
        /// </summary>
        public void MouseDragged( double dx, double dy,
			bool xz_yz, bool xw_yw, bool xy_zw )
        {
            Matrix4D spinDelta = new Matrix4D();

            // Sensitivity.
            dx *= 0.012;
            dy *= 0.012;

            if( xz_yz )
            {
                spinDelta[0,2] += dx;
                spinDelta[2,0] -= dx;

                spinDelta[1,2] += dy;
                spinDelta[2,1] -= dy;
            }

            if( xw_yw )
            {
                spinDelta[0,3] -= dx;
                spinDelta[3,0] += dx;

                spinDelta[1,3] -= dy;
                spinDelta[3,1] += dy;
            }

            if( xy_zw )
            {
                spinDelta[0,1] += dx;
                spinDelta[1,0] -= dx;

                spinDelta[3,2] -= dy;
                spinDelta[2,3] += dy;
            }

            ApplySpinDelta( spinDelta );
        }
コード例 #4
0
 public RotationHandler4D( Matrix4D initialMatrix )
 {
     Current4dView = initialMatrix;
 }
コード例 #5
0
 private void ApplySpinDelta( Matrix4D spinDelta )
 {
     Matrix4D delta = Matrix4D.Identity() + spinDelta;
     delta = Matrix4D.GramSchmidt( delta );			// Orthonormalize
     ViewMat4d = delta * ViewMat4d;
     ViewMat4d = Matrix4D.GramSchmidt( ViewMat4d );	// Orthonormalize
 }
コード例 #6
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D operator +( Matrix4D m1, Matrix4D m2 )
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
     for( int j=0; j<4; j++ )
         result[i, j] = m1[i, j] + m2[i, j];
     return result;
 }
コード例 #7
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public Matrix4D Clone()
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
     for( int j=0; j<4; j++ )
         result.Data[i][j] = this.Data[i][j];
     return result;
 }
コード例 #8
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D Identity()
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
         result[i,i] = 1;
     return result;
 }
コード例 #9
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D Transpose( Matrix4D m )
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
     for( int j=0; j<4; j++ )
         result[i, j] = m[j, i];
     return result;
 }
コード例 #10
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
        /// <summary>
        /// Gram-Schmidt orthonormalize
        /// </summary>
        public static Matrix4D GramSchmidt( Matrix4D input,
			Func<VectorND, VectorND, double> innerProduct, Func<VectorND, VectorND> normalize )
        {
            Matrix4D result = input;
            for( int i=0; i<4; i++ )
            {
                for( int j=i+1; j<4; j++ )
                {
                    VectorND iVec = result[i];
                    VectorND jVec = result[j];
                    iVec -= innerProduct( iVec, jVec ) * jVec;
                    result[i] = iVec;
                }
                result[i] = normalize( result[i] );
            }

            return result;
        }
コード例 #11
0
ファイル: Matrix4D.cs プロジェクト: roice3/Honeycombs
        /// <summary>
        /// Gram-Schmidt orthonormalize
        /// </summary>
        public static Matrix4D GramSchmidt( Matrix4D input )
        {
            Matrix4D result = input;
            for( int i=0; i<4; i++ )
            {
                for( int j=0; j<i; j++ )
                {
                    // result[j] is already unit length...
                    // result[i] -= (result[i] dot result[j])*result[j]
                    VectorND iVec = result[i];
                    VectorND jVec = result[j];
                    iVec -= ( iVec.Dot( jVec ) ) * jVec;
                    result[i] = iVec;
                }
                result[i].Normalize();
            }

            return result;
        }
コード例 #12
0
ファイル: Simplex.cs プロジェクト: roice3/Honeycombs
 public static Matrix4D ReverseRows( Matrix4D m )
 {
     Matrix4D result = new Matrix4D();
     for( int i=0; i<4; i++ )
         result[i] = m[3-i];
     return result;
 }
コード例 #13
0
ファイル: Simplex.cs プロジェクト: roice3/Honeycombs
        public static Matrix4D GramSchmidt( Matrix4D input, Matrix4D innerProductValues )
        {
            Matrix4D result = input.Clone();
            for( int i = 0; i < 4; i++ )
            {
                for( int j = 0; j < i; j++ )
                {
                    VectorND iVec = result[i];
                    VectorND jVec = result[j];
                    double inner = innerProductValues[i].Dot( jVec );
                    iVec -= inner * jVec;
                    result[i] = iVec;
                }

                // Normalize.  We don't use VectorND normalize because we might have timelike vectors.
                double mag2 = innerProductValues[i].Dot( result[i] );
                double abs = mag2 < 0 ? -Math.Sqrt( -mag2 ) : Math.Sqrt( mag2 );
                result[i].Divide( abs );
            }

            return result;
        }
コード例 #14
0
ファイル: Simplex.cs プロジェクト: roice3/Honeycombs
        /// <summary>
        /// This calculates the 4 vertices of a general (but finite) Goursat Tetrahedron.  Result is in the ball model.
        /// 
        /// The method comes from the dissertation "Hyperbolic polyhedra: volume and scissors congruence", 
        /// by Yana Zilberberg Mohanty, section 2.4, steps 1-5.
        /// 
        /// A,B,C are the three dihedral angles surrounding a vertex.
        /// A_,B_,C_ are the three oppoite dihedral angles.
        /// </summary>
        public static Vector3D[] GoursatTetrahedron( double A, double B, double C, double A_, double B_, double C_ )
        {
            // Step 1: Construct Gram matrix with reversed rows/columns.
            // NOTE: The sign of the diagonal in the paper was incorrect.
            double pi = Math.PI;
            double[,] gramMatrixData = new double[,]
            {
                { -1,				Math.Cos(pi/A_),	Math.Cos(pi/B_),	Math.Cos(pi/C) },
                { Math.Cos(pi/A_),	-1,					Math.Cos(pi/C_),	Math.Cos(pi/B) },
                { Math.Cos(pi/B_),	Math.Cos(pi/C_),	-1,					Math.Cos(pi/A) },
                { Math.Cos(pi/C),	Math.Cos(pi/B),		Math.Cos(pi/A),		-1 },
            };
            Matrix4D gramMatrix = new Matrix4D( gramMatrixData );
            gramMatrix *= -1;
            Matrix4D identity = Matrix4D.Identity();

            // Step 2: Gram-Schmidt.
            Matrix4D W = GramSchmidt( identity, gramMatrix );

            // Step 3: Divide 4th row by i (already effectively done in our Gram-Schmidt routine below), and reverse order of rows.
            Matrix4D W_ = ReverseRows( W );

            // Step 4
            Matrix4D D = identity.Clone();
            D[0, 0] = -1;
            Matrix4D U = Matrix4D.Transpose( D * W_ );

            // Step 5
            Matrix4D U_ = ReverseRows( U );
            for( int i=0; i<4; i++ )
                MinkowskiNormalize( U_[i] );

            // Now move from the hyperboloid model to the ball.
            List<Vector3D> result = new List<Vector3D>();
            for( int i=0; i<4; i++ )
                result.Add( HyperboloidToBall( U_[i] ) );
            return result.ToArray();
        }