2d/iterator.hh

Go to the documentation of this file.

/* -*- mia-c++  -*-
 *
 * This file is part of MIA - a toolbox for medical image analysis 
 * Copyright (c) Leipzig, Madrid 1999-2017 Gert Wollny
 *
 * MIA is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with MIA; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef mia_2d_iterator_hh
#define mia_2d_iterator_hh

#include <mia/2d/vector.hh>

NS_MIA_BEGIN

template <typename I> 
class EXPORT_2D range2d_iterator_with_boundary_flag: public std::forward_iterator_tag {
public: 
        typedef typename I::reference reference; 
        typedef typename I::pointer pointer; 
        typedef I internal_iterator; 

        typedef typename I::value_type value_type; 
        
        enum EBoundary {
                eb_none  = 0, 
                eb_xlow  = 1, 
                eb_xhigh = 2, 
                eb_x     = 3, 
                eb_ylow = 4,  
                eb_yhigh = 8, 
                eb_y     = 0xC, 
        }; 
        

        
        range2d_iterator_with_boundary_flag(); 

        range2d_iterator_with_boundary_flag(const C2DBounds& pos, const C2DBounds& size, 
                         const C2DBounds& start, const C2DBounds& end, I iterator);
        
        range2d_iterator_with_boundary_flag(const C2DBounds& pos);

        range2d_iterator_with_boundary_flag<I>& operator = (const range2d_iterator_with_boundary_flag<I>& other); 
        
        range2d_iterator_with_boundary_flag(const range2d_iterator_with_boundary_flag<I>& other); 

        template <typename AI> 
        friend class range2d_iterator_with_boundary_flag; 
        
        template <typename AI>
        range2d_iterator_with_boundary_flag(const range2d_iterator_with_boundary_flag<AI>& other); 


        template <typename AI>
        range2d_iterator_with_boundary_flag<I>& operator = (const range2d_iterator_with_boundary_flag<AI>& other); 

        
        range2d_iterator_with_boundary_flag<I>& operator ++(); 
        range2d_iterator_with_boundary_flag<I> operator ++(int); 
        
        reference  operator *() const;
        
        pointer    operator ->() const;

        const C2DBounds& pos() const; 

        template <typename T> friend
        bool operator == (const range2d_iterator_with_boundary_flag<T>& left, 
                          const range2d_iterator_with_boundary_flag<T>& right); 

        template <typename T> friend
        bool operator != (const range2d_iterator_with_boundary_flag<T>& left, 
                          const range2d_iterator_with_boundary_flag<T>& right); 

        internal_iterator get_point(); 

        int get_boundary_flags() const; 

private: 

        void increment_y(); 
        void increment_z(); 

        C2DBounds m_pos; 
        C2DBounds m_size; 
        C2DBounds m_begin; 
        C2DBounds m_end; 
        int m_xstride; 
        I m_iterator; 
        int m_boundary; 
}; 



template <typename I> 
template <typename AI>
range2d_iterator_with_boundary_flag<I>& range2d_iterator_with_boundary_flag<I>::operator = (const range2d_iterator_with_boundary_flag<AI>& other)
{
        m_pos = other.m_pos; 
        m_size = other.m_size;  
        m_begin = other.m_begin; 
        m_end = other.m_end; 
        m_iterator = other.m_iterator; 
        m_xstride = other.m_xstride; 
        m_boundary = other.m_boundary; 
        return *this; 
}

template <typename I> 
template <typename AI>
range2d_iterator_with_boundary_flag<I>::range2d_iterator_with_boundary_flag(const range2d_iterator_with_boundary_flag<AI>& other):
        m_pos(other.m_pos), 
        m_size(other.m_size), 
        m_begin(other.m_begin), 
        m_end(other.m_end), 
        m_xstride(other.m_xstride),
        m_iterator(other.m_iterator), 
        m_boundary(other.m_boundary)
{
}       

template <typename T> 
bool operator == (const range2d_iterator_with_boundary_flag<T>& left, const range2d_iterator_with_boundary_flag<T>& right)
{
        return left.m_pos == right.m_pos; 
}

template <typename T> 
bool operator != (const range2d_iterator_with_boundary_flag<T>& left, const range2d_iterator_with_boundary_flag<T>& right)
{
        return left.m_pos != right.m_pos; 
}


template <typename I> 
class EXPORT_2D range2d_iterator: public  std::iterator<std::forward_iterator_tag, typename I::value_type>
{
public: 
        typedef typename I::reference reference; 
        typedef typename I::pointer pointer; 
        typedef I internal_iterator; 

        typedef typename I::value_type value_type; 
        
        range2d_iterator(); 

        range2d_iterator(const C2DBounds& pos, const C2DBounds& size, 
                         const C2DBounds& start, const C2DBounds& end, I iterator);
        
        range2d_iterator(const C2DBounds& pos);

        range2d_iterator<I>& operator = (const range2d_iterator<I>& other); 
        
        range2d_iterator(const range2d_iterator<I>& other); 

        template <typename AI> 
        friend class range2d_iterator; 
        
        template <typename AI>
        range2d_iterator(const range2d_iterator<AI>& other); 


        template <typename AI>
        range2d_iterator<I>& operator = (const range2d_iterator<AI>& other); 

        
        range2d_iterator<I>& operator ++(); 
        range2d_iterator<I> operator ++(int); 
        
        reference  operator *() const;
        
        pointer    operator ->() const;

        const C2DBounds& pos() const; 

        template <typename T> friend
        bool operator == (const range2d_iterator<T>& left, const range2d_iterator<T>& right); 

        internal_iterator get_point(); 

        
        range2d_iterator_with_boundary_flag<I> with_boundary_flag() const;

         const reference operator[] (int i) const;

private: 

        void increment_y(); 
        void increment_z(); 

        C2DBounds m_pos; 
        C2DBounds m_size; 
        C2DBounds m_begin; 
        C2DBounds m_end; 
        int m_xstride; 
        I m_iterator; 
}; 



template <typename I> 
template <typename AI>
range2d_iterator<I>& range2d_iterator<I>::operator = (const range2d_iterator<AI>& other)
{
        m_pos = other.m_pos; 
        m_size = other.m_size;  
        m_begin = other.m_begin; 
        m_end = other.m_end; 
        m_iterator = other.m_iterator; 
        m_xstride = other.m_xstride; 
        return *this; 
}

template <typename I> 
template <typename AI>
range2d_iterator<I>::range2d_iterator(const range2d_iterator<AI>& other):
        m_pos(other.m_pos), 
        m_size(other.m_size), 
        m_begin(other.m_begin), 
        m_end(other.m_end), 
        m_xstride(other.m_xstride),
        m_iterator(other.m_iterator)
{
}       




template <typename I> 
bool operator == (const range2d_iterator<I>& left, const range2d_iterator<I>& right)
{
        // we really want these two to the same range 
//      assert(left.m_size == right.m_size);
//      assert(left.m_begin == right.m_begin);
//      assert(left.m_end == right.m_end);

        return left.m_pos == right.m_pos; 

}

template <typename I> 
bool operator != (const range2d_iterator<I>& a, const range2d_iterator<I>& b)
{
        return !(a == b); 
}

template <typename I> 
const typename range2d_iterator<I>::reference
range2d_iterator<I>::operator[] (int i) const
{
        return m_iterator[i];
}


NS_MIA_END


namespace std {

template <typename I>
class iterator_traits< mia::range2d_iterator<I> > {
public: 
        typedef typename I::difference_type  difference_type; 
        typedef typename I::value_type  value_type; 
        typedef typename I::pointer     pointer; 
        typedef typename I::reference   reference; 
        typedef forward_iterator_tag    iterator_category; 
}; 

template <typename I>
class iterator_traits< mia::range2d_iterator_with_boundary_flag<I> > {
public: 
        typedef typename I::difference_type  difference_type; 
        typedef typename I::value_type  value_type; 
        typedef typename I::pointer     pointer; 
        typedef typename I::reference   reference; 
        typedef forward_iterator_tag    iterator_category; 
}; 

}

#endif