MatrixSubRectIterator.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLMath/src/ICLMath/MatrixSubRectIterator.h            **
** Module : ICLMath                                                **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <iterator>

namespace icl{
  namespace math{

    template <typename Type>
    class MatrixSubRectIterator : public std::iterator<std::forward_iterator_tag, Type>{
      protected:
      inline void init () {
         m_lineStep = m_matrixWidth - m_subRectWidth + 1;
         m_dataEnd = m_dataCurr;
         if (m_subRectWidth > 0){
            m_dataEnd += m_subRectWidth + (m_subRectHeight-1) * m_matrixWidth;
         }
         m_currLineEnd = m_dataCurr + m_subRectWidth - 1;
      }

      public:

      static inline const MatrixSubRectIterator<Type> create_end_iterator(const Type *dataOrigin,  int matrixWidth, int subRectX,
                                                                          int subRectY, int subRectWidth, int subRectHeight){
        MatrixSubRectIterator<Type> i(const_cast<Type*>(dataOrigin),matrixWidth,subRectX, subRectY, subRectWidth,subRectHeight);
        i.m_dataCurr = i.m_dataEnd - subRectWidth + matrixWidth;
        i.m_currLineEnd = i.m_dataCurr + subRectWidth;
        return i;
      }

      inline MatrixSubRectIterator():
         m_matrixWidth(0),m_subRectWidth(0),m_subRectHeight(0),
         m_dataOrigin(0), m_dataCurr(0) {init();}

      inline MatrixSubRectIterator(Type *ptData,int matrixWidth,int subRectX, int subRectY, int subRectWidth, int subRectHeight):
         m_matrixWidth(matrixWidth),m_subRectWidth(subRectWidth),m_subRectHeight(subRectHeight),
         m_dataOrigin(ptData),m_dataCurr(ptData+subRectX+subRectY*matrixWidth) {init();}

      inline MatrixSubRectIterator &assign(const MatrixSubRectIterator &other){
        m_matrixWidth = other.m_matrixWidth;
        m_subRectWidth = other.m_subRectWidth;
        m_subRectHeight = other.m_subRectHeight;
        m_lineStep = other.m_lineStep;
        m_dataOrigin = other.m_dataOrigin;
        m_dataCurr = other.m_dataCurr;
        m_dataEnd = other.m_dataEnd;
        m_currLineEnd = other.m_currLineEnd;
        return *this;
      }

      inline const MatrixSubRectIterator& operator=(const MatrixSubRectIterator &other) const{
                  return (*const_cast<MatrixSubRectIterator*>(this)).assign(other);
      }


      inline const Type &operator*() const { return *m_dataCurr;  }


      inline Type &operator*(){  return *m_dataCurr;  }


      inline MatrixSubRectIterator& operator++(){
        if ( ICL_UNLIKELY(m_dataCurr == m_currLineEnd) ){
          m_dataCurr += m_lineStep;
          m_currLineEnd += m_matrixWidth;
        }else{
          m_dataCurr++;
        }
        return *this;
      }

      inline const MatrixSubRectIterator& operator++() const{
        return ++(*const_cast<MatrixSubRectIterator*>(this));
      }

      inline MatrixSubRectIterator operator++(int){
        MatrixSubRectIterator current (*this);
        ++(*this); // call prefix operator
        return current; // return previous
      }

      inline const MatrixSubRectIterator operator++(int) const{
        return (*const_cast<MatrixSubRectIterator*>(this))++;
      }



      inline bool inSubRect() const{
        return m_dataCurr < m_dataEnd;
      }



      inline bool operator!=(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr != it.m_dataCurr;
      }
      inline bool operator==(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr == it.m_dataCurr;
      }
      inline bool operator<(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr < it.m_dataCurr;
      }
      inline bool operator>(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr > it.m_dataCurr;
      }
      inline bool operator<=(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr <= it.m_dataCurr;
      }
      inline bool operator>=(const MatrixSubRectIterator<Type> &it) const{
        return m_dataCurr >= it.m_dataCurr;
      }



      inline int getSubRectWidth() const{
        return m_subRectWidth;
      }

      inline int getSubRectHeight() const{
        return m_subRectHeight;
      }


      inline void incRow(int numLines=1) const {
        m_dataCurr += numLines * m_matrixWidth;
        m_currLineEnd += numLines * m_matrixWidth;
      }


      inline int x(){
        return (m_dataCurr-m_dataOrigin) % m_matrixWidth;
      }


      inline int y(){
        return (m_dataCurr-m_dataOrigin) / m_matrixWidth;
      }

      protected:
      int m_matrixWidth;

      int m_subRectWidth, m_subRectHeight;

      int m_lineStep;

      Type *m_dataOrigin;

      mutable Type *m_dataCurr;

      Type *m_dataEnd;

      mutable Type *m_currLineEnd;

    };
  } // namespace math
}