transform3D.h

Go to the documentation of this file.

#ifndef _DLR_TRANSFORM3D_H_
#define _DLR_TRANSFORM3D_H_

#include <dlrNumeric/array2D.h>
#include <dlrNumeric/vector3D.h>

namespace dlr {

  namespace numeric {
    
    // Forward declaration.
    class Transform3DFunctor;

  
    class Transform3D {
    public:

      inline
      Transform3D()
        : m_00(1.0), m_01(0.0), m_02(0.0), m_03(0.0),
          m_10(0.0), m_11(1.0), m_12(0.0), m_13(0.0),
          m_20(0.0), m_21(0.0), m_22(1.0), m_23(0.0),
          m_30(0.0), m_31(0.0), m_32(0.0) {}

      inline
      Transform3D(double a00, double a01, double a02, double a03,
                  double a10, double a11, double a12, double a13,
                  double a20, double a21, double a22, double a23,
                  double a30, double a31, double a32, double a33)
        : m_00(a00), m_01(a01), m_02(a02), m_03(a03),
          m_10(a10), m_11(a11), m_12(a12), m_13(a13),
          m_20(a20), m_21(a21), m_22(a22), m_23(a23),
          m_30(a30), m_31(a31), m_32(a32) {
        this->normalize(a33);
      }

      Transform3D(const Array2D<double>& source);

      inline
      Transform3D(const Transform3D& src)
        : m_00(src.m_00), m_01(src.m_01), m_02(src.m_02), m_03(src.m_03),
          m_10(src.m_10), m_11(src.m_11), m_12(src.m_12), m_13(src.m_13),
          m_20(src.m_20), m_21(src.m_21), m_22(src.m_22), m_23(src.m_23),
          m_30(src.m_30), m_31(src.m_31), m_32(src.m_32) {}

      ~Transform3D() {}


      Transform3DFunctor
      getFunctor() const;
    

      template <size_t row, size_t column>
      double
      getValue() const {return this->value<row, column>();}


      Transform3D
      invert() const;

    
      void
      setTransform(double a00, double a01, double a02, double a03,
                   double a10, double a11, double a12, double a13,
                   double a20, double a21, double a22, double a23,
                   double a30, double a31, double a32, double a33);



      void
      setValue(size_t row, size_t column, double value);


      template <size_t row, size_t column>
      void
      setValue(double value);


      void
      setValue(double a00, double a01, double a02, double a03,
               double a10, double a11, double a12, double a13,
               double a20, double a21, double a22, double a23,
               double a30, double a31, double a32, double a33) {
        this->setTransform(a00, a01, a02, a03, a10, a11, a12, a13,
                           a20, a21, a22, a23, a30, a31, a32, a33);
      }

      
      template <size_t row, size_t column>
      double
      value() const;


      double
      operator()(size_t row, size_t column) const;

    
      Vector3D
      operator*(const Vector3D& vector0) const;

    
      Transform3D&
      operator=(const Transform3D& source);

    
    private:
      void normalize(double scaleFactor);
      
      double m_00, m_01, m_02, m_03;
      double m_10, m_11, m_12, m_13;
      double m_20, m_21, m_22, m_23;
      double m_30, m_31, m_32;

    }; // class Transform3D


    /* ============== Helper classes ============== */


    class Transform3DFunctor
      : public std::unary_function<Vector3D, Vector3D> {

    public:

      Transform3DFunctor(const Transform3D& transform)
        : m_transform(transform) {}

    
      inline Vector3D
      operator()(const Vector3D& vec) const {return m_transform * vec;}
    
    private:
      Transform3D m_transform;
    };
  
  
    /* ============== Non-member functions ============== */
  
    Transform3D
    operator*(const Transform3D& transform0, const Transform3D& transform1);

  
    std::ostream&
    operator<<(std::ostream& stream, const Transform3D& transform0);

  
    std::istream&
    operator>>(std::istream& stream, Transform3D& transform0);
  
  } // namespace numeric

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using numeric::Transform3D;
  using numeric::Transform3DFunctor;

} // namespace dlr


/*******************************************************************
 * Member function definitions follow.  This would be a .C file
 * if it weren't templated.
 *******************************************************************/

namespace dlr {

  namespace numeric {
    
    // This operator sets one element of the matrix representation of
    // the coordinate transform.  The case statements should optimize
    // away, since row and column are both known at compile time.
    template <size_t ROW, size_t COLUMN>
    void
    Transform3D::
    setValue(double inValue)
    {
      switch(ROW) {
      case 0:
        switch(COLUMN) {
        case 0: m_00 = inValue; return; break;
        case 1: m_01 = inValue; return; break;
        case 2: m_02 = inValue; return; break;
        case 3: m_03 = inValue; return; break;
        default: break;
        }
        break;
      case 1:
        switch(COLUMN) {
        case 0: m_10 = inValue; return; break;
        case 1: m_11 = inValue; return; break;
        case 2: m_12 = inValue; return; break;
        case 3: m_13 = inValue; return; break;
        default: break;
        }
        break;
      case 2:
        switch(COLUMN) {
        case 0: m_20 = inValue; return; break;
        case 1: m_21 = inValue; return; break;
        case 2: m_22 = inValue; return; break;
        case 3: m_23 = inValue; return; break;
        default: break;
        }
        break;
      case 3:
        switch(COLUMN) {
        case 0: m_30 = inValue; return; break;
        case 1: m_31 = inValue; return; break;
        case 2: m_32 = inValue; return; break;
        default: break;
        }
        break;
      default:
        break;
      }
      std::ostringstream message;
      message << "Indices (" << ROW << ", " << COLUMN << ") are out of bounds.";
      DLR_THROW(IndexException, "Transform3D::setValue<size_t, size_t>(double)",
                message.str().c_str());
    }

  
    // This operator returns one element from the matrix
    // representation of the coordinate transform by value.
    // The case statements should optimize away, since row and column
    // are both known at compile time.
    template <size_t ROW, size_t COLUMN>
    double
    Transform3D::
    value() const
    {
      switch(ROW) {
      case 0:
        switch(COLUMN) {
        case 0: return m_00; break;
        case 1: return m_01; break;
        case 2: return m_02; break;
        case 3: return m_03; break;
        default: break;
        }
        break;
      case 1:
        switch(COLUMN) {
        case 0: return m_10; break;
        case 1: return m_11; break;
        case 2: return m_12; break;
        case 3: return m_13; break;
        default: break;
        }
        break;
      case 2:
        switch(COLUMN) {
        case 0: return m_20; break;
        case 1: return m_21; break;
        case 2: return m_22; break;
        case 3: return m_23; break;
        default: break;
        }
        break;
      case 3:
        switch(COLUMN) {
        case 0: return m_30; break;
        case 1: return m_31; break;
        case 2: return m_32; break;
        case 3: return 1.0; break;
        default: break;
        }
        break;
      default:
        break;
      }
      std::ostringstream message;
      message << "Indices (" << ROW << ", " << COLUMN << ") are out of bounds.";
      DLR_THROW(IndexException, "Transform3D::value<size_t, size_t>()",
                message.str().c_str());
      return 0.0; // Dummy return to keep the compiler happy.
    }

  } // namespace numeric

} // namespace dlr
  
#endif // #ifndef _DLR_TRANSFORM3D_H_