testCoordinateSystem.cc

Go to the documentation of this file.

#include <utl/CoordinateSystem.h>
#include <utl/Vector.h>
#include <utl/TransformationMatrix.h>
#include <utl/GeometryException.h>
#include <utl/AugerUnits.h>
#include <tst/Verify.h>

#include <cppunit/extensions/HelperMacros.h>

using utl::CoordinateSystem;
using utl::BaseCoordinateSystem;
using utl::CoordinateSystemPtr;
using utl::TransformationMatrix;

using namespace tst;


class TestCoordinateSystem : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(TestCoordinateSystem);
  CPPUNIT_TEST(TestCoordinateSystemConstructor);
  CPPUNIT_TEST(TestNewCoordinateSystemBase);
  CPPUNIT_TEST(TestTransformationChaining);
  CPPUNIT_TEST_SUITE_END();

public:
  void setUp() override { }

  void tearDown() override { }

  void
  TestCoordinateSystemConstructor()
  {
    // commented since it was understood by g++ as a function forward decl
    //const CoordinateSystem CoordDefault();
    const CoordinateSystemPtr cDefault(CoordinateSystem::GetRootCoordinateSystem());
    CoordinateSystem::RotationX(0, cDefault);
  }

  void
  TestNewCoordinateSystemBase()
  {
    const CoordinateSystemPtr cDefault(CoordinateSystem::GetRootCoordinateSystem());

    // DV: this number gets increased by the usage of geometry in the tests and can
    // not be reliably predicted; disabling the test
    //CPPUNIT_ASSERT(Verify<Equal>(CDefault.use_count(), 2L));
    CPPUNIT_ASSERT(cDefault == CoordinateSystem::GetRootCoordinateSystem());

    const CoordinateSystemPtr c1(CoordinateSystem::RotationX(0, cDefault));
    CPPUNIT_ASSERT(c1->GetReferenceSystem() == CoordinateSystem::GetRootCoordinateSystem());

    const CoordinateSystemPtr c2(BaseCoordinateSystem::RotationX(0, cDefault));
    CPPUNIT_ASSERT(c2->GetReferenceSystem() == CoordinateSystem::GetRootCoordinateSystem());

    const CoordinateSystemPtr c3(CoordinateSystem::RotationX(0, c2));
    CPPUNIT_ASSERT(c3->GetReferenceSystem() == c2);

    const CoordinateSystemPtr c4(CoordinateSystem::RotationX(0, c3));
    // same base as c3
    CPPUNIT_ASSERT(c4->GetReferenceSystem() == c2);
  }

  void
  TestTransformationChaining()
  {
    using namespace utl;

    const CoordinateSystemPtr r = CoordinateSystem::GetRootCoordinateSystem();

    const Vector v(1*m, 0, 0, r);
    const TransformationMatrix mra = TransformationMatrix::Translation(-1*m, 0, 0);
    const CoordinateSystemPtr a = BaseCoordinateSystem::Translation(v, r);
    const TransformationMatrix maa1 = TransformationMatrix::RotationZ(-33*deg);
    const CoordinateSystemPtr a1 = CoordinateSystem::RotationZ(33*deg, a);
    const TransformationMatrix maa2 = TransformationMatrix::RotationY(-33*deg);
    const CoordinateSystemPtr a2 = BaseCoordinateSystem::RotationY(33*deg, a);
    const TransformationMatrix ma2a2a = TransformationMatrix::RotationX(-33*deg);
    const CoordinateSystemPtr a2a = CoordinateSystem::RotationX(33*deg, a2);

    const TransformationMatrix mrb = TransformationMatrix::RotationX(-90*deg);
    const CoordinateSystemPtr b = BaseCoordinateSystem::RotationX(90*deg, r);
    const TransformationMatrix mbb1 = TransformationMatrix::RotationY(-90*deg);
    const CoordinateSystemPtr b1 = CoordinateSystem::RotationY(90*deg, b);
    const TransformationMatrix mbb2 = TransformationMatrix::RotationZ(-90*deg)*mbb1;
    const CoordinateSystemPtr b2 = CoordinateSystem::RotationZ(90*deg, b1);

    CPPUNIT_ASSERT(Verify<CloseTo>(mra.Distance(r->GetTransformationTo(a)), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(mra.Inverse().Distance(a->GetTransformationTo(r)), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(maa1.Distance(a->GetTransformationTo(a1)), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(r->GetTransformationTo(a1).Distance(maa1*mra), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(a1->GetTransformationTo(r).Distance(mra.Inverse()*maa1.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(r->GetTransformationTo(a2a).Distance(ma2a2a*maa2*mra), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(a2a->GetTransformationTo(r).Distance(mra.Inverse()*maa2.Inverse()*ma2a2a.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(a2a->GetTransformationTo(a1).Distance(maa1*maa2.Inverse()*ma2a2a.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(a1->GetInverseTransformationTo(a2a).Distance(maa1*maa2.Inverse()*ma2a2a.Inverse()), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(a1->GetTransformationTo(a2a).Distance(ma2a2a*maa2*maa1.Inverse()), 0.));

    CPPUNIT_ASSERT(Verify<CloseTo>(r->GetTransformationTo(b).Distance(mrb), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(b->GetTransformationTo(b1).Distance(mbb1), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(b->GetTransformationTo(b2).Distance(mbb2), 0.));

    CPPUNIT_ASSERT(Verify<CloseTo>(a1->GetTransformationTo(b2).Distance(mbb2*mrb*mra.Inverse()*maa1.Inverse()), 0.));
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(TestCoordinateSystem);