transform3DTo2D.h

Go to the documentation of this file.

#ifndef _DLR_TRANSFORM3DTO2D_H_
#define _DLR_TRANSFORM3DTO2D_H_

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

namespace dlr {

  namespace numeric {
    
    // Forward declaration.
    class Transform3DTo2DFunctor;


    class Transform3DTo2D {
    public:
      Transform3DTo2D()
        : 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(1.0)
        {}

      inline
      Transform3DTo2D(double a00, double a01, double a02, double a03,
                      double a10, double a11, double a12, double a13,
                      double a20, double a21, double a22, double a23)
        : 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) {
      }

      Transform3DTo2D(const Array2D<double>& source);

      inline
      Transform3DTo2D(const Transform3DTo2D& 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) {
      }

      ~Transform3DTo2D() {}


      Transform3DTo2DFunctor
      getFunctor() 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);

      // John Culbertson argues convincingly that this breaks the
      // abstraction, so we remove it for now.
      // 
      // template <size_t row, size_t column>
      // double&
      // value();

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

      // John Culbertson argues convincingly that this breaks the
      // abstraction, so we remove it for now.
      // 
      // double&
      // operator()(size_t row, size_t column);

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

      Vector2D
      operator*(const Vector3D& vector0) const;

      Transform3DTo2D&
      operator=(const Transform3DTo2D& 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;

    }; // class Transform3DTo2D


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


    class Transform3DTo2DFunctor
      : public std::unary_function<Vector3D, Vector2D> {

    public:

      Transform3DTo2DFunctor(const Transform3DTo2D& transform)
        : m_transform(transform) {}

    
      inline Vector2D
      operator()(const Vector3D& vec) const {return m_transform * vec;}
    
    private:
      Transform3DTo2D m_transform;
    };
  

    /* ================ Non member functions below ================ */

    Transform3DTo2D
    operator*(const Transform3DTo2D& transform0, const Transform3D& transform1);


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

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

}; // namespace dlr


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

namespace dlr {

  using numeric::Transform3DTo2D;
  using numeric::Transform3DTo2DFunctor;

} // namespace dlr


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

namespace dlr {

  namespace numeric {
    
    // This operator returns one element from the matrix
    // representation of the coordinate transform by reference.
    // 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()
//   {
//     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;
//       default: break;
//       }
//       break;
//     default:
//       break;
//     }
//     std::ostringstream message;
//     message << "Index (" << ROW << ", " << COLUMN << ") out of bounds.";
//     DLR_THROW(IndexException, message.str().c_str());
//     return m_00; // Dummy return to keep the compiler happy.
//   }

    // 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
    Transform3DTo2D::
    value() const
    {
      // // Avoid ugly duplication of code using ugly const_cast.
      // return const_cast<Transform3D*>(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;
        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;
      default:
        break;
      }
      std::ostringstream message;
      message << "Indices (" << ROW << ", " << COLUMN << ") are out of bounds.";
      DLR_THROW(IndexException, "Transform3DTo2D::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_TRANSFORM3DTO2D_H_