CoordinateSystem.h

Go to the documentation of this file.

#ifndef _utl_CoordinateSystem_h_
#define _utl_CoordinateSystem_h_

#include <utl/CoordinateSystemPtr.h>
#include <utl/TransformationMatrix.h>
#include <utl/TransformerConstructor.h>
#include <utl/GeometryException.h>
#ifdef OFFLINE_GEOMETRY_IS_COUNTED
#  include <utl/CountedObject.h>
#endif

#include <boost/enable_shared_from_this.hpp>
#include <boost/weak_ptr.hpp>


namespace io {
  class CoordinateSystem_ROOT;
}


namespace utl {

  inline
  void
  CoordinateSystemValid(const CoordinateSystemPtr& theCoordinateSystem)
  {
    if (!theCoordinateSystem)
      throw CoordinateSystemException("nullptr coordinate system pointer;");
  }


  class CoordinateTransformer : public boost::enable_shared_from_this<CoordinateTransformer> {
  protected:
    typedef boost::weak_ptr<const CoordinateTransformer> WeakCoordinateSystemPtr;

  public:
    typedef CoordinateSystemPtr type;

    // Getters
    CoordinateSystemPtr GetReferenceSystem() const
    { return fReferenceSystem ? fReferenceSystem : GetRootCoordinateSystem(); }

    const TransformationMatrix& GetTransformation() const
    { return fTransformation; }

    const TransformationMatrix&
    GetTransformationTo(const CoordinateSystemPtr& target) const;

    const TransformationMatrix&
    GetInverseTransformationTo(const CoordinateSystemPtr& target) const;

    virtual CoordinateSystemPtr GetReferenceForNewCS() const = 0;

    virtual TransformationMatrix
    GetTransformationForNewCS(const TransformationMatrix& theTransformation) const = 0;

    static CoordinateSystemPtr GetRootCoordinateSystem();

  protected:
    // Default constructor - used only to construct the root CS
    CoordinateTransformer() { }

    CoordinateTransformer(const TransformationMatrix& theTransformation,
                          const CoordinateSystemPtr& theReferenceCS);

    virtual ~CoordinateTransformer();

    CoordinateSystemPtr GetThis() const;

  private:
    // Copy constructor private and not implemented
    CoordinateTransformer(const CoordinateTransformer& theSystem);

    // Assignement private and not implemented
    CoordinateTransformer& operator=(const CoordinateTransformer& theSystem);

    CoordinateSystemPtr
    FindCommonBase(const CoordinateSystemPtr& other) const;

    TransformationMatrix
    CollectTransformationFrom(const CoordinateSystemPtr& target) const;

    TransformationMatrix fTransformation;

    CoordinateSystemPtr fReferenceSystem;

    // for the transformation cache
    mutable WeakCoordinateSystemPtr fLastTarget;
    mutable TransformationMatrix* fLastTransformation = nullptr;
    mutable TransformationMatrix* fLastInverseTransformation = nullptr;

    static CoordinateSystemPtr RootCoordinateSystem;
  };


  class DerivedCSPolicy : public CoordinateTransformer
#ifdef OFFLINE_GEOMETRY_IS_COUNTED
    , private CountedObject<DerivedCSPolicy>
#endif
  {
  protected:
    DerivedCSPolicy() : CoordinateTransformer() { }

    DerivedCSPolicy(const TransformationMatrix& theTransformation,
                    const CoordinateSystemPtr& theReferenceCS)
      : CoordinateTransformer(theTransformation, theReferenceCS)
    { }

    virtual CoordinateSystemPtr GetReferenceForNewCS() const;

    virtual TransformationMatrix
    GetTransformationForNewCS(const TransformationMatrix& theTransformation) const;

    static type FromTransformation(const TransformationMatrix& theTrafo,
                                   const CoordinateSystemPtr& theCS);

    friend class io::CoordinateSystem_ROOT;
  };


  class BaseCSPolicy : public CoordinateTransformer
#ifdef OFFLINE_GEOMETRY_IS_COUNTED
    , private CountedObject<BaseCSPolicy>
#endif
  {
    friend class CoordinateTransformer;

  protected:
    BaseCSPolicy() : CoordinateTransformer() { }

    BaseCSPolicy(const TransformationMatrix& theTransformation,
                 const CoordinateSystemPtr&  theReferenceCS)
      : CoordinateTransformer(theTransformation, theReferenceCS)
    { }

    virtual CoordinateSystemPtr GetReferenceForNewCS() const;

    virtual TransformationMatrix
    GetTransformationForNewCS(const TransformationMatrix& theTransformation) const;

    static type FromTransformation(const TransformationMatrix& theTrafo,
                                   const CoordinateSystemPtr& theCS);
  };


  typedef TransformerConstructor<DerivedCSPolicy> CoordinateSystem;

  typedef TransformerConstructor<BaseCSPolicy> BaseCoordinateSystem;

}


#endif