amanatidesWoo3DIterator.h

Go to the documentation of this file.

#ifndef _DLR_NUMERIC_AMANATIDESWOO3DITERATOR_H_
#define _DLR_NUMERIC_AMANATIDESWOO3DITERATOR_H_

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

namespace dlr {

  namespace numeric {
    
    template <class ARRAY3D>
    class AmanatidesWoo3DIterator
      : public std::iterator<std::forward_iterator_tag,
                             typename ARRAY3D::value_type>
    {
    public:
      AmanatidesWoo3DIterator(ARRAY3D& data,
                              int U, int V, int W,
                              int stepU, int stepV, int stepW,
                              double tMaxU, double tMaxV, double tMaxW,
                              double tDeltaU, double tDeltaV, double tDeltaW,
                              double tStart);

      AmanatidesWoo3DIterator(const AmanatidesWoo3DIterator& source);

      ~AmanatidesWoo3DIterator() {};

      double
      tEntry() {return m_tEntry;}

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

      int
      U() {return m_U;}

      int
      V() {return m_V;}

      int
      W() {return m_W;}

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

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

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

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

      AmanatidesWoo3DIterator&
      operator=(const AmanatidesWoo3DIterator& source);

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

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

    private:
      ARRAY3D& m_data;
      bool m_inBounds;
      int m_stepU;
      int m_stepV;
      int m_stepW;
      double m_tDeltaU;
      double m_tDeltaV;
      double m_tDeltaW;
      double m_tEntry;
      double m_tMaxU;
      double m_tMaxV;
      double m_tMaxW;
      int m_U;
      int m_uLimit;
      int m_V;
      int m_vLimit;
      int m_W;
      int m_wLimit;
    };

  } // namespace numeric

} // namespace dlr


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

namespace dlr {

  using numeric::AmanatidesWoo3DIterator;

} // 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 ARRAY3D>
    AmanatidesWoo3DIterator<ARRAY3D>::
    AmanatidesWoo3DIterator(ARRAY3D& data,
                            int U, int V, int W,
                            int stepU, int stepV, int stepW,
                            double tMaxU, double tMaxV, double tMaxW,
                            double tDeltaU, double tDeltaV, double tDeltaW,
                            double tStart)
      : m_data(data),
        m_inBounds(true),
        m_stepU(stepU),
        m_stepV(stepV),
        m_stepW(stepW),
        m_tDeltaU(tDeltaU),
        m_tDeltaV(tDeltaV),
        m_tDeltaW(tDeltaW),
        m_tEntry(tStart),
        m_tMaxU(tMaxU),
        m_tMaxV(tMaxV),
        m_tMaxW(tMaxW),
        m_U(U),
        m_uLimit(stepU > 0 ? static_cast<int>(data.shape()[2]) : -1),
        m_V(V),
        m_vLimit(stepV > 0 ? static_cast<int>(data.shape()[1]) : -1),
        m_W(W),
        m_wLimit(stepW > 0 ? static_cast<int>(data.shape()[0]) : -1)
    {
      if((m_U < 0)
         || (m_V < 0)
         || (m_W < 0)
         || (m_U >= static_cast<int>(data.shape()[2]))
         || (m_V >= static_cast<int>(data.shape()[1]))
         || (m_W >= static_cast<int>(data.shape()[0]))) {
        m_inBounds = false;      
      }
    }

    // Copy constructor.
    template<class ARRAY3D>
    AmanatidesWoo3DIterator<ARRAY3D>::
    AmanatidesWoo3DIterator(const AmanatidesWoo3DIterator& source)
      : m_data(source.m_data),
        m_inBounds(source.m_inBounds),
        m_stepU(source.m_stepU),
        m_stepV(source.m_stepV),
        m_stepW(source.m_stepW),
        m_tDeltaU(source.m_tDeltaU),
        m_tDeltaV(source.m_tDeltaV),
        m_tDeltaW(source.m_tDeltaW),
        m_tEntry(source.m_tEntry),
        m_tMaxU(source.m_tMaxU),
        m_tMaxV(source.m_tMaxV),
        m_tMaxW(source.m_tMaxW),
        m_U(source.m_U),
        m_uLimit(source.m_uLimit),
        m_V(source.m_V),
        m_vLimit(source.m_vLimit),
        m_W(source.m_W),
        m_wLimit(source.m_wLimit)
    {
      // Empty
    }

    // This operator returns a reference to the Array3D element at the
    // current voxel.
    template<class ARRAY3D>
    inline typename ARRAY3D::value_type& // element_type?
    AmanatidesWoo3DIterator<ARRAY3D>::
    operator*()
    {
      return m_data(m_W, m_V, m_U);
    }

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

    // The pre-increment operator increments the iterator so that it
    // points to the next voxel along the path.
    template<class ARRAY3D>
    inline AmanatidesWoo3DIterator<ARRAY3D>&
    AmanatidesWoo3DIterator<ARRAY3D>::
    operator++()
    {
      if(m_tMaxU < m_tMaxV) {
        if(m_tMaxW < m_tMaxU) {
          m_tEntry = m_tMaxW;
          m_W += m_stepW;
          m_tMaxW += m_tDeltaW;
          if(m_W == m_wLimit) {
            m_inBounds = false;
          }
        } else {
          m_tEntry = m_tMaxU;
          m_U += m_stepU;
          m_tMaxU += m_tDeltaU;
          if(m_U == m_uLimit) {
            m_inBounds = false;
          }
        }
      } else {
        if(m_tMaxW < m_tMaxV) {
          m_tEntry = m_tMaxW;
          m_W += m_stepW;
          m_tMaxW += m_tDeltaW;
          if(m_W == m_wLimit) {
            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 voxel along the path.  It differs from the
    // pre-increment operator in its return value.
    template<class ARRAY3D>
    inline AmanatidesWoo3DIterator<ARRAY3D>
    AmanatidesWoo3DIterator<ARRAY3D>::
    operator++(int)
    {
      AmanatidesWoo3DIterator<ARRAY3D> thisCopy(*this);
      ++this;
      return thisCopy;
    }

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

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

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

} // namespace dlr

#endif // #ifndef _DLR_NUMERIC_AMANATIDESWOO3DITERATOR_H_