Пример #1
0
        public void InverseRotationTest()
        {
            Mat4 rotX    = Mat4.RotX(E.Num("alpha"));
            Mat4 rotXNeg = Mat4.RotX(E.Negate(E.Num("alpha")));
            Mat4 r       = rotX * rotXNeg;

            r = r.Evaluate(new EvalSettings(false));
            Assert.IsTrue(r == Mat4.Identity);

            E    x          = E.Num("x");
            E    y          = E.Num("y");
            E    z          = E.Num("z");
            Vec4 v          = new Vec4(x, y, z, E.Zero);
            Mat4 rotToXY    = Mat4.RotToXY(v);
            Mat4 rotToXYInv = rotToXY.Transposed;

            r = rotToXY * rotToXYInv;
            r = r.Evaluate();
            Assert.IsTrue(r == Mat4.Identity);

            Mat4 rotToX    = Mat4.RotToX(v);
            Mat4 rotToXInv = rotToX.Transposed;

            r = rotToX * rotToXInv;
            r = r.Evaluate();
            r = r.Evaluate(new EvalSettings("x", 10, "y", 15, "z", 20));
            Assert.IsTrue(r == Mat4.Identity);
        }
Пример #2
0
        private static void EvalStepByStep()
        {
            string htmlLog;

            E e = E.Sum(E.Div(E.NumConst(1),
                              E.Num("d")),
                        E.Mul(E.Num("a"), E.Div(E.Sum(E.Num("b"), E.NumConst(14), E.Num("c")),
                                                E.Num("d"))));

            e = e.EvaluateStepByStep(out htmlLog, "a", 2, "b", 33, "c", 24);

            E    x         = E.Num("x");
            E    y         = E.Num("y");
            E    z         = E.Num("z");
            Vec4 v         = new Vec4(x, y, z, E.Zero);
            Mat4 rotToX    = Mat4.RotToX(v);
            Mat4 rotXAlpha = Mat4.RotX(E.Num("alpha"));
            Mat4 r         = rotToX * rotXAlpha;

            r.EvaluateStepByStep(out htmlLog /*, "x", 1, "y", 1, "z", 1*/);

            Mat4 rotX = Mat4.RotX(E.Num("phi"));
            Mat4 rotY = Mat4.RotY(E.Num("theta"));
            Mat4 rotZ = Mat4.RotZ(E.Num("psi"));

            r = rotX * rotY * rotZ;
            r.EvaluateStepByStep(out htmlLog);

            Mat4 rotToZ = Mat4.RotToZ(v);

            r = rotToZ.Evaluate();
        }
Пример #3
0
 public void RotToPlaneTest()
 {
     E    x       = E.Num("x");
     E    y       = E.Num("y");
     E    z       = E.Num("z");
     Vec4 v       = new Vec4(x, y, z, E.Zero);
     Mat4 rotToXY = Mat4.RotToXY(v);
     Mat4 r       = rotToXY.Evaluate(new EvalSettings(false));
 }
Пример #4
0
        private static void RotateAroundVector()
        {
            // Rotate around vector
            Mat4 rotToX    = Mat4.RotToX(new Vec4(E.Num("x"), E.Num("y"), E.Num("z"), E.Num("w")));
            Mat4 rotXAlpha = Mat4.RotX(E.Num("alpha"));
            Mat4 rotV      = rotToX * rotXAlpha * rotToX.Transposed;

            rotV = rotV.Evaluate();
        }
Пример #5
0
        public void RotToAxisTest()
        {
            E    x         = E.Num("x");
            E    y         = E.Num("y");
            E    z         = E.Num("z");
            Vec4 v         = new Vec4(x, y, z, E.Zero);
            Mat4 rotToX    = Mat4.RotToX(v);
            Mat4 rotXAlpha = Mat4.RotX(E.Num("alpha"));
            Mat4 r         = rotToX * rotXAlpha;

            r = r.Evaluate(new EvalSettings(false));
        }
Пример #6
0
        public void MatrixEvaluationTest()
        {
            EvalSettings evalSettings = new EvalSettings();

            evalSettings.EvalFuncs = false;

            Mat4 rotX30 = Mat4.RotX(30);
            Mat4 trans  = Mat4.Trans(new double3(2, 3, 4));
            Mat4 r      = rotX30 * trans;

            r = r.Evaluate(evalSettings);

            //evalSettings = new EvalSettings ( "phi", 30, "theta", 60, "psi", 90.0 );
            Mat4 rotX = Mat4.RotX(E.Num("phi"));
            Mat4 rotY = Mat4.RotY(E.Num("theta"));
            Mat4 rotZ = Mat4.RotZ(E.Num("psi"));

            r = rotX * rotY * rotZ;
            r = r.Evaluate(evalSettings);
            r = r.Transposed;
        }
Пример #7
0
        private static void TbTaEqualTab()
        {
            // Tb * Ta == T( a * b )
            Mat4 rotX  = Mat4.RotX(E.Num("alpha"));
            Mat4 rotY  = Mat4.RotY(E.Num("beta"));
            Mat4 rotXY = rotX * rotY;

            rotXY = rotXY.Evaluate();
            Mat4 rotTYTX = rotY.Transposed * rotX.Transposed;

            rotTYTX = rotTYTX.Evaluate();
            Mat4 rotTXY = (rotX * rotY).Transposed;

            rotTXY = rotTXY.Evaluate();
        }