amanatidesWoo2DIterator.h

Go to the documentation of this file.

#ifndef _DLR_NUMERIC_AMANATIDESWOO2DITERATOR_H_
#define _DLR_NUMERIC_AMANATIDESWOO2DITERATOR_H_

#include <iostream>
#include <dlrCommon/exception.h>

namespace dlr {

  namespace numeric {
    
    template <class ARRAY2D>
    class AmanatidesWoo2DIterator
      : public std::iterator<std::forward_iterator_tag,
                             typename ARRAY2D::value_type>
    {
    public:
      AmanatidesWoo2DIterator(ARRAY2D& data,
                              int U, int V,
                              int stepU, int stepV,
                              double tMaxU, double tMaxV,
                              double tDeltaU, double tDeltaV,
                              double tStart);

      AmanatidesWoo2DIterator(const AmanatidesWoo2DIterator& source);

      ~AmanatidesWoo2DIterator() {};

      double
      tEntry() {return m_tEntry;}

      double
      tExit() {return std::min(m_tMaxU, m_tMaxV);}

      int
      U() {return m_U;}

      int
      V() {return m_V;}

      inline typename ARRAY2D::value_type& // element_type?
      operator*();

      inline typename ARRAY2D::value_type* // element_type?
      operator->();

      inline AmanatidesWoo2DIterator&
      operator++();                  // prefix

      inline AmanatidesWoo2DIterator
      operator++(int dummy);                 // postfix

      AmanatidesWoo2DIterator&
      operator=(const AmanatidesWoo2DIterator& source);

      inline bool
      operator==(const AmanatidesWoo2DIterator& other);

      inline bool
      operator!=(const AmanatidesWoo2DIterator& other);

    private:
      ARRAY2D& m_data;
      bool m_inBounds;
      int m_stepU;
      int m_stepV;
      double m_tDeltaU;
      double m_tDeltaV;
      double m_tEntry;
      double m_tMaxU;
      double m_tMaxV;
      int m_U;
      int m_uLimit;
      int m_V;
      int m_vLimit;
    };

  } // namespace numeric

} // namespace dlr


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

namespace dlr {

  using numeric::AmanatidesWoo2DIterator;

} // namespace dlr


/* ========================================================= */
/* Implementation follows                                    */
/* ========================================================= */

namespace dlr {

  namespace numeric {
    
    // The class constructor is initialized with all of the internal
    // variables of the voxel traversal algorithm, plus the starting
    // value of the ray parameter.
    template<class ARRAY2D>
    AmanatidesWoo2DIterator<ARRAY2D>::
    AmanatidesWoo2DIterator(ARRAY2D& data,
                            int U, int V,
                            int stepU, int stepV,
                            double tMaxU, double tMaxV,
                            double tDeltaU, double tDeltaV,
                            double tStart)
      : m_data(data),
        m_inBounds(true),
        m_stepU(stepU),
        m_stepV(stepV),
        m_tDeltaU(tDeltaU),
        m_tDeltaV(tDeltaV),
        m_tEntry(tStart),
        m_tMaxU(tMaxU),
        m_tMaxV(tMaxV),
        m_U(U),
        m_uLimit(stepU > 0 ? static_cast<int>(data.columns()) : -1),
        m_V(V),
        m_vLimit(stepV > 0 ? static_cast<int>(data.rows()) : -1)
    {
      if((m_U < 0)
         || (m_V < 0)
         || (m_U >= static_cast<int>(m_data.columns()))
         || (m_V >= static_cast<int>(m_data.rows()))) {
        m_inBounds = false;      
      }
    }

    // Copy constructor.
    template<class ARRAY2D>
    AmanatidesWoo2DIterator<ARRAY2D>::
    AmanatidesWoo2DIterator(const AmanatidesWoo2DIterator& source)
      : m_data(source.m_data),
        m_inBounds(source.m_inBounds),
        m_stepU(source.m_stepU),
        m_stepV(source.m_stepV),
        m_tDeltaU(source.m_tDeltaU),
        m_tDeltaV(source.m_tDeltaV),
        m_tEntry(source.m_tEntry),
        m_tMaxU(source.m_tMaxU),
        m_tMaxV(source.m_tMaxV),
        m_U(source.m_U),
        m_uLimit(source.m_uLimit),
        m_V(source.m_V),
        m_vLimit(source.m_vLimit)
    {
      // Empty
    }

    // This operator returns a reference to the Array2D element at the
    // current pixel.
    template<class ARRAY2D>
    inline typename ARRAY2D::value_type& // element_type?
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator*()
    {
      return m_data(m_V, m_U);
    }

    // This operator returns a pointer to the Array2D element at the
    // current pixel.
    template<class ARRAY2D>
    inline typename ARRAY2D::value_type* // element_type?
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator->()
    {
      return &(this->operator*());
    }

    // The pre-increment operator increments the iterator so that it
    // points to the next pixel along the path.
    template<class ARRAY2D>
    inline AmanatidesWoo2DIterator<ARRAY2D>&
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator++()
    {
      if(m_tMaxU < m_tMaxV) {
        m_tEntry = m_tMaxU;
        m_U += m_stepU;
        m_tMaxU += m_tDeltaU;
        if(m_U == m_uLimit) {
          m_inBounds = false;
        }
      } else {
        m_tEntry = m_tMaxV;
        m_V += m_stepV;
        m_tMaxV += m_tDeltaV;
        if(m_V == m_vLimit) {
          m_inBounds = false;
        }
      }
      return *this;
    }

    // The post-increment operator increments the iterator so that it
    // points to the next pixel along the path.  It differs from the
    // pre-increment operator in its return value.
    template<class ARRAY2D>
    inline AmanatidesWoo2DIterator<ARRAY2D>
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator++(int)
    {
      AmanatidesWoo2DIterator<ARRAY2D> thisCopy(*this);
      ++this;
      return thisCopy;
    }

    // This is the assignment operator.  It copies the value of its
    // argument into *this.
    template<class ARRAY2D>
    AmanatidesWoo2DIterator<ARRAY2D>&
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator=(const AmanatidesWoo2DIterator& source)
    {
      m_data = source.m_data;
      m_inBounds = source.m_inBounds;
      m_stepU = source.m_stepU;
      m_stepV = source.m_stepV;
      m_tDeltaU = source.m_tDeltaU;
      m_tDeltaV = source.m_tDeltaV;
      m_tEntry = source.m_tEntry;
      m_tMaxU = source.m_tMaxU;
      m_tMaxV = source.m_tMaxV;
      m_U = source.m_U;
      m_uLimit = source.m_uLimit;
      m_V = source.m_V;
      m_vLimit = source.m_vLimit;
      return *this;
    }

    // The equality operator returns true if *this currently
    // references the same pixel as the argument.
    template<class ARRAY2D>
    inline bool
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator==(const AmanatidesWoo2DIterator& other)
    {
      // Return true if both refer to valid pixels or if both refer to
      // invalid pixels.
      return (m_inBounds == other.m_inBounds);
    }

    // The inequality operator returns true if *this currently
    // references the a different pixel than the argument.
    template<class ARRAY2D>
    inline bool
    AmanatidesWoo2DIterator<ARRAY2D>::
    operator!=(const AmanatidesWoo2DIterator& other)
    {
      return !(this->operator==(other));
    }
  
  } // namespace numeric

} // namespace dlr

#endif // #ifndef _DLR_NUMERIC_AMANATIDESWOO2DITERATOR_H_