testTransformationMatrix.cc

Go to the documentation of this file.

#include <utl/TransformationMatrix.h>
#include <cmath>

#include <tst/Verify.h>
#include <utl/Triple.h>

#include <cppunit/extensions/HelperMacros.h>

using namespace utl;
using namespace tst;
using utl::Triple;
using utl::TransformationMatrix;
using std::abs;
using std::sqrt;


class testTransformationMatrix : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testTransformationMatrix);
  CPPUNIT_TEST(testConstructor);
  CPPUNIT_TEST(testDistance);
  CPPUNIT_TEST(testTranslation);
  CPPUNIT_TEST(testRotation);
  CPPUNIT_TEST(testTransformation);
  CPPUNIT_TEST(testDreibein);
  CPPUNIT_TEST_SUITE_END();

public:
  void setUp() { }

  void tearDown() { }

  void
  testConstructor()
  {
    TransformationMatrix Id;
    [[maybe_unused]] TransformationMatrix IdCopy(Id);
  }

  void
  testDistance()
  {
    TransformationMatrix Id;
    CPPUNIT_ASSERT(Id.Distance(Id) == 0);
  }

  void
  testTranslation()
  {
    const TransformationMatrix mX(TransformationMatrix::Translation(1, 0, 0));
    const TransformationMatrix mY(TransformationMatrix::Translation(0, 1, 0));
    const TransformationMatrix mZ(TransformationMatrix::Translation(0, 0, 1));
    const TransformationMatrix mXYZInv(TransformationMatrix::Translation(-1, -1, -1));
    const TransformationMatrix mXInv(TransformationMatrix::Translation(-1, 0, 0));
    const TransformationMatrix m2XInv(TransformationMatrix::Translation(-2, 0, 0));
    const TransformationMatrix Id;

    // the next test should be CPPUNIT_ASSERT_CLOSE, but it doesn't compile.
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(mX*mXInv), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(mX*m2XInv*mX), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(mX*mY*mZ*mXYZInv), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(mXYZInv.Inverse() * mXYZInv), 0.));
  }

  void testRotation()
  {
    const TransformationMatrix Id;
    const TransformationMatrix RX(TransformationMatrix::RotationX(0.3));
    const TransformationMatrix RY(TransformationMatrix::RotationY(0.3));
    const TransformationMatrix RZ(TransformationMatrix::RotationZ(0.3));
    const TransformationMatrix RXInv(TransformationMatrix::RotationX(-0.3));
    CPPUNIT_ASSERT(Verify<CloseTo>(RX.Distance(RXInv.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RX * RXInv), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RXInv * RX), 0.));

    // should be different
    CPPUNIT_ASSERT(Verify<Not<CloseTo> >(RX.Distance(RY), 0.));
    CPPUNIT_ASSERT(Verify<Not<CloseTo> >(RX.Distance(RZ), 0.));
    CPPUNIT_ASSERT(Verify<Not<CloseTo> >(RY.Distance(RZ), 0.));

    const TransformationMatrix R(TransformationMatrix::Rotation(0.123, 1.1, 2.2, 3.3));
    const TransformationMatrix RInv(TransformationMatrix::Rotation(-0.123, 1.1, 2.2, 3.3));
    const TransformationMatrix R1(TransformationMatrix::Rotation(0.123, Triple(1.1, 2.2, 3.3)));
    CPPUNIT_ASSERT(Verify<CloseTo>(R.Distance(R1), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(RInv.Distance(R1.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RInv * R), 0.));

    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RX*RInv * R*RXInv), 0.));

    const TransformationMatrix M(RX*RInv);
    const TransformationMatrix MInv(M.Inverse());
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(MInv * M), 0.));

  }

  void testTransformation()
  {
    const TransformationMatrix Id;

    const TransformationMatrix TX(TransformationMatrix::Translation(1, 0, 0));
    const TransformationMatrix TXYZ(TransformationMatrix::Translation(1, 1, 1));
    const TransformationMatrix TXYZInv(TransformationMatrix::Translation(-1, -1, -1));
    const TransformationMatrix TXInv(TransformationMatrix::Translation(-1, 0, 0));

    const TransformationMatrix R(TransformationMatrix::Rotation(0.123, 1.1, 2.2, 3.3));
    const TransformationMatrix RInv(TransformationMatrix::Rotation(-0.123, 1.1, 2.2, 3.3));

    const TransformationMatrix RT(R*TXYZ);
    const TransformationMatrix RTInv(TXYZInv*RInv);
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RInv*TX*TXInv*R), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(Id.Distance(RT * RTInv), 0.));
  }

  void testDreibein()
  {
    const TransformationMatrix db1 =
      TransformationMatrix::TransformToBasis(1, 0,           0,
                                             0, 1/sqrt(2.), -1/sqrt(2.),
                                             0, 1/sqrt(2.),  1/sqrt(2.));
    const TransformationMatrix rx(TransformationMatrix::RotationX(M_PI/4));
    CPPUNIT_ASSERT(Verify<CloseTo>(rx.Distance(db1), 0.));

    const TransformationMatrix db2 =
      TransformationMatrix::TransformToBasis(1/sqrt(2.), 0, 1/sqrt(2.),
                                             0,          1, 0,
                                            -1/sqrt(2.), 0, 1/sqrt(2.));
    const TransformationMatrix ry(TransformationMatrix::RotationY(M_PI/4));
    CPPUNIT_ASSERT(Verify<CloseTo>(ry.Distance(db2), 0.));

    const TransformationMatrix db3 =
      TransformationMatrix::TransformToBasis(1/sqrt(2.), -1/sqrt(2.), 0,
                                             1/sqrt(2.),  1/sqrt(2.), 0,
                                             0,           0,          1);
    const TransformationMatrix rz(TransformationMatrix::RotationZ(M_PI/4));
    CPPUNIT_ASSERT(Verify<CloseTo>(rz.Distance(db3), 0.));
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(testTransformationMatrix);


// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -C .. -k run-testGeometry"
// End: