transform2D.h

Go to the documentation of this file.

#ifndef _DLR_TRANSFORM2D_H_
#define _DLR_TRANSFORM2D_H_

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

namespace dlr {

  namespace numeric {
    
    // Forward declaration.
    class Transform2DFunctor;

  
    class Transform2D {
    public:
      inline
      Transform2D()
        : m_00(1.0), m_01(0.0), m_02(0.0),
          m_10(0.0), m_11(1.0), m_12(0.0),
          m_20(0.0), m_21(0.0) {}

      inline
      Transform2D(double a00, double a01, double a02,
                  double a10, double a11, double a12,
                  double a20, double a21, double a22)
        : m_00(a00), m_01(a01), m_02(a02),
          m_10(a10), m_11(a11), m_12(a12),
          m_20(a20), m_21(a21) {
        this->normalize(a22);
      }

      Transform2D(const Array2D<double>& source);

      inline
      Transform2D(const Transform2D& src)
        : m_00(src.m_00), m_01(src.m_01), m_02(src.m_02),
          m_10(src.m_10), m_11(src.m_11), m_12(src.m_12),
          m_20(src.m_20), m_21(src.m_21) {}

      ~Transform2D() {}


      Transform2DFunctor
      getFunctor() const;
    
    
      Transform2D
      invert() const;

    
      void
      setTransform(double a00, double a01, double a02,
                   double a10, double a11, double a12,
                   double a20, double a21, double a22);

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

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

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

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

      Vector2D
      operator*(const Vector2D& vector0) const;

      Transform2D&
      operator=(const Transform2D& source);

    private:
      void normalize(double scaleFactor);
      
      double m_00, m_01, m_02;
      double m_10, m_11, m_12;
      double m_20, m_21;

    }; // class Transform2D


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


    class Transform2DFunctor
      : public std::unary_function<Vector2D, Vector2D> {

    public:

      Transform2DFunctor(const Transform2D& transform)
        : m_transform(transform) {}

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

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

  
    std::istream&
    operator>>(std::istream& stream, Transform2D& transform0);

  } // namespace numeric

} // namespace dlr


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

namespace dlr {

  using numeric::Transform2D;
  using numeric::Transform2DFunctor;

} // 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
    Transform2D::
    setValue(double value)
    {
      switch(ROW) {
      case 0:
        switch(COLUMN) {
        case 0: m_00 = value; return; break;
        case 1: m_01 = value; return; break;
        case 2: m_02 = value; return; break;
        default: break;
        }
        break;
      case 1:
        switch(COLUMN) {
        case 0: m_10 = value; return; break;
        case 1: m_11 = value; return; break;
        case 2: m_12 = value; return; break;
        default: break;
        }
        break;
      case 2:
        switch(COLUMN) {
        case 0: m_20 = value; return; break;
        case 1: m_21 = value; return; break;
        default: break;
        }
        break;
      default:
        break;
      }
      std::ostringstream message;
      message << "Indices (" << ROW << ", " << COLUMN << ") are out of bounds.";
      DLR_THROW(IndexException, "Transform2D::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
    Transform2D::
    value() const
    {
      // // Avoid ugly duplication of code using ugly const_cast.
      // return const_cast<Transform2D*>(this)->value<ROW, COLUMN>();
      switch(ROW) {
      case 0:
        switch(COLUMN) {
        case 0: return m_00; break;
        case 1: return m_01; break;
        case 2: return m_02; 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;
        default: break;
        }
        break;
      case 2:
        switch(COLUMN) {
        case 0: return m_20; break;
        case 1: return m_21; break;
        case 2: return 1.0; break;
        default: break;
        }
        break;
      default:
        break;
      }
      std::ostringstream message;
      message << "Index (" << ROW << ", " << COLUMN << ") out of bounds.";
      DLR_THROW3(IndexException, "Transform2D::value<>()",
                 message.str().c_str());
      return 0.0; // Dummy return to keep the compiler happy.
    }

  } // namespace numeric

} // namespace dlr
  
#endif // #ifndef _DLR_TRANSFORM2D_H_