/**
   \file
   Constructors for Transformer classes

   \author Lukas Nellen
   \version $Id: TransformerConstructor.h 14717 2009-09-17 20:24:36Z lukas $
   \date 19 Oct 2003
*/

#ifndef _utl_TransformerConstructor_h_
#define _utl_TransformerConstructor_h_


#include <utl/CoordinateSystemPtr.h>
#include <utl/TransformationMatrix.h>
#include <utl/Transformation-fwd.h>

namespace utl {

  class Vector;
  class Point;

  /**
     \class TransformerConstructor TransformerConstructor.h utl/TransformerConstructor.h

     \brief Constructors for Transformer classes

     This class provides factory methods for coordinate systems
     (passive transformations) and for active transformations.

     \author Lukas Nellen
     \date 19 Oct 2003
     \ingroup geometry
  */

  template<typename Policy>
  class TransformerConstructor
    : public Policy
  {
  public:
    /// Destructor - should be virtual for base classes
    ~TransformerConstructor();

    // Factory functions

    /// Construct from translation by vector
    static typename Policy::type
    Translation(const Vector& theTranslation,
                const CoordinateSystemPtr& theCS);

    /// Construct from general rotation about axis
    static typename Policy::type
    Rotation(const double angle,
             const Vector& theAxis,
             const CoordinateSystemPtr& theCS);

    /// Construct from rotation about X axis
    static typename Policy::type
    RotationX(const double angle, const CoordinateSystemPtr& theCS);

    /// Construct from rotation about Y axis
    static typename Policy::type
    RotationY(const double angle, const CoordinateSystemPtr& theCS);

    /// Construct from rotation about Z axis
    static typename Policy::type
    RotationZ(const double angle, const CoordinateSystemPtr& theCS);

  private:
    /**
       \brief Construct from transformation matrix

       \deprecated Use one of the other factory methods and chain the
       constructed objects instead.
    */
    static typename Policy::type
    FromTransformation(const TransformationMatrix& theTrafo,
                       const CoordinateSystemPtr& theCS);

    TransformerConstructor(const TransformationMatrix& theTransformation,
                           const CoordinateSystemPtr& theCS);

    // some Policies need access to the constructor of this class
    friend typename Policy::type
    Policy::FromTransformation(const TransformationMatrix&,
                                   const CoordinateSystemPtr&);
  };


} // utl


#endif // _utl_TransformerConstructor_h_

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