Container3DIterators.hpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program 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 2 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 this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#ifndef _Container3D_internal
#error Image3DIterators should only be included by Container3D.hpp
#endif

// **************************************************
// ****************** iterators *********************
// **************************************************

// FIXME!! this is a temporary fix for gcc>=3.1
#if (__GNUC__==3 && __GNUC_MINOR__>=1) || __GNUC__>3

template<typename _Tp, typename _Distance>
  struct random_access_iterator {
    typedef random_access_iterator_tag iterator_category;
    typedef _Tp                        value_type;
    typedef _Distance                  difference_type;
    typedef _Tp*                       pointer;
    typedef _Tp&                       reference;
  };

#endif


template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorFast : public random_access_iterator<typename Container3D::value_type,size_t>
{
    typedef CTR3D_iteratorFast<Container3D,_Ref,_Ptr> _Self;
public:
    Container3D *ima;
    _Ptr pos;
public:
    void AssertBounds()
    {
        if(pos<ima->begin().pos || pos>=ima->end().pos)
        {
            ThrowError("iteratorFast: out of bounds:pos:%x begin:%x end:%x\n",pos,ima->begin().pos,ima->end().pos);
        }
    }
    inline _Ref operator*(){return *pos;}
    double Progress() const {if(!this){return 0;}return (pos-ima->GetData())/(float)ima->GetNVoxels();}
    inline _Self  operator++(int)     {_Self __tmp=*this;pos++;return __tmp;}
    inline _Self &operator++()        {pos++;return *this;}
    inline void   operator+=(size_t m){pos+=m;}
    inline _Self  operator+ (size_t m){_Self __tmp=*this;__tmp.pos+=m;return __tmp;}
    inline _Self  operator- (size_t m){_Self __tmp=*this;__tmp.pos-=m;return __tmp;}
    inline _Self  operator--(int)     {_Self __tmp=*this;pos--;return __tmp;}
    inline _Self &operator--()        {pos--;return *this;}
    inline void   operator-=(size_t m){pos-=m;}
    inline int    operator- (const _Self &other) const {return pos-other.pos;}
    inline bool   operator< (const _Self &other) const {return pos< other.pos;}
    inline bool   operator<=(const _Self &other) const {return pos<=other.pos;}
    inline bool   operator> (const _Self &other) const {return pos> other.pos;}
    inline bool   operator>=(const _Self &other) const {return pos>=other.pos;}

    inline Vect3Di ComputePosition() const
    {
        int offset=pos-ima->GetData();
        Vect3Di res;
        res.z=offset/(ima->Height()*ima->Width());
        offset=offset%(ima->Height()*ima->Width());
        res.y=offset/ima->Width();
        res.x=offset%ima->Width();
        return res;
    }
    void operator+=(const Vect3Di &dV)
    {
        pos+=dV.x+ima->Width()*dV.y+ima->Width()*ima->Height()*dV.z;
    }
    inline void operator=(const Vect3Di &P)
    {
        pos=ima->GetData()+P.x+ima->Width()*P.y+ima->Width()*ima->Height()*P.z;
    }
    inline bool  operator!=(const _Self  &other){return pos!=other.pos; }
    inline bool  operator==(const _Self  &other){return pos==other.pos; }
    CTR3D_iteratorFast():ima(NULL),pos(NULL){}
    CTR3D_iteratorFast(Container3D *_ima,_Ptr _pos):ima(_ima),pos(_pos){}
};


template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorXYZ :    public CTR3D_iteratorFast<Container3D,_Ref,_Ptr>
{
    typedef CTR3D_iteratorFast<Container3D,_Ref,_Ptr> _Base;
    typedef CTR3D_iteratorXYZ <Container3D,_Ref,_Ptr> _Self;
    void Reposition(){Vect3Di v=this->ComputePosition();x=v.x;y=v.y;z=v.z;}
public:
    int x,y,z;

    void AssertBounds() 
    {       
        if(!this->ima->IsInside(x,y,z) || this->pos<this->ima->GetData() || this->pos>=this->ima->GetData()+this->ima->GetNVoxels())
        {
            ThrowError("iteratorXYZ: out of bounds %d %d %d: image %d %d %d :pos:%x begin:%x end:%x\n",
                     x,y,z,
                     this->ima->Width(),this->ima->Height(),this->ima->Depth(),
                     this->pos,this->ima->GetData(),this->ima->GetData()+this->ima->GetNVoxels());
        }
    }

    inline _Self  operator++(int){_Self __tmp=*this;++(*this);return __tmp;}
    inline _Self &operator++()
    {
        this->pos++;
        x++;
        if(x>=this->ima->Width())
        {
            x=0;
            y++;
            if(y>=this->ima->Height())
            {
                y=0;
                z++;
            }
        }
        return *this;
    }
    inline _Self  operator--(int){_Self __tmp=*this;--(*this);return __tmp;}
    inline _Self &operator--()
    {
        this->pos--;
        x--;
        if(x<0)
        {
            x=this->ima->Width()-1;
            y--;
            if(y<0)
            {
                y=this->ima->Height()-1;
                z--;
            }
        }
        return *this;
    }
    inline Vect3Di Pos() const {return Vect3Di(x,y,z);}
    // jump to new location
    inline void operator=(const Vect3Di &P)
    {
        x=P.x;
        y=P.y;
        z=P.z;
        this->pos=&(*this->ima)(P);
    }

    inline void   operator+=(size_t m){this->pos+=m;Reposition();}
    inline void   operator-=(size_t m){this->pos-=m;Reposition();}
    inline _Self  operator+ (size_t m){_Self __tmp=*this;__tmp.pos+=m;__tmp.Reposition();return __tmp;}
    inline _Self  operator- (size_t m){_Self __tmp=*this;__tmp.pos-=m;__tmp.Reposition();return __tmp;}

    void operator= (const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other)
    {
        this->ima=other.ima;
        this->pos=other.pos;        
        if(this->pos==this->ima->GetData()){x=0;y=0;z=0;}
        else{Reposition();}
    }
    CTR3D_iteratorXYZ():_Base(){;}
    CTR3D_iteratorXYZ(const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other) : _Base(other)
    {
        operator=(other);
    }
    CTR3D_iteratorXYZ(Container3D *_ima,_Ptr _pos) : _Base(_ima,_pos)
    {
        // optionally move xyz if pos is not at begining of ima
        if(this->pos!=this->ima->GetData())
        {_Base::operator=(CTR3D_iteratorFast<Container3D,_Ref,_Ptr>(this->ima,this->pos).ComputePosition());}
    }

};


template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorZone : public CTR3D_iteratorXYZ<Container3D,_Ref,_Ptr>
{
    typedef CTR3D_iteratorXYZ <Container3D,_Ref,_Ptr> _Base;
    typedef CTR3D_iteratorZone<Container3D,_Ref,_Ptr> _Self;
public:
    RectZone3Di zone;
    double Progress(){return (this->pos-this->ima->GetData())/(float)zone.Volume();}
    void AssertBounds()
    {       
        if(!this->ima->IsInside(this->x,this->y,this->z)  || !this->zone.IsInside(this->x,this->y,this->z) || 
           this->pos<this->ima->GetData() || this->pos>=this->ima->GetData()+this->ima->GetNVoxels())
        {
            ThrowError("iteratorZone: out of bounds %d %d %d:zone:%d %d %d - %d %d %d: image %d %d %d : pos:%x begin:%x end:%x\n",
                     this->x,this->y,this->z,
                     zone.x0,zone.y0,zone.z0,
                     zone.x1,zone.y1,zone.z1,
                     this->ima->Width(),this->ima->Height(),this->ima->Depth(),
                     this->pos,this->ima->GetData(),this->ima->GetData()+this->ima->GetNVoxels());
        }
    }
    inline _Self  operator++(int){_Self __tmp=*this;++(*this);return __tmp;}
    inline _Self &operator++()
    {
        this->pos++;
        if(this->zone.ToNext(this->x,this->y,this->z))
        {
            if(this->zone.IsInside(this->x,this->y,this->z))
            {
                this->pos=&(*this->ima)(this->x,this->y,this->z);
            }
            else{this->pos=this->ima->GetDataEnd();}
        }
        return *this;
    }
    inline void operator--(int)
    {
        this->pos--;
        if(this->zone.ToPrev(this->x,this->y,this->z))
        {
            if(this->zone.IsInside(this->x,this->y,this->z))
            {
                this->pos=&(*this->ima)(this->x,this->y,this->z);
            }
            else{this->pos=NULL;}
        }
    }

    inline void  operator+=(size_t m){while (m--) operator++(0);}
    inline void  operator-=(size_t m){while (m--) operator--(0);}
    inline _Self operator+ (size_t m){_Self __tmp=*this;__tmp+=m;return __tmp;}
    inline _Self operator- (size_t m){_Self __tmp=*this;__tmp-=m;return __tmp;}

    void operator= (const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other)
    {
        this->ima=other.ima;        
        this->pos=other.pos;        
        if(!this->ima->IsInside(zone.GetP0()) || !this->ima->IsInside(zone.GetP1()))
        {
            ThrowError("iteratorZone zone does not fit in image");
        }       
        // if iter fast is begining of image put it at begining of zone
        if(this->pos==this->ima->GetData()){this->zone.ToStart(this->x,this->y,this->z);}
        else{_Base::operator=(other.ComputePosition());}
        this->pos=&(*this->ima)(this->x,this->y,this->z);
    }
    CTR3D_iteratorZone():_Base(){}
//      CTR3D_iteratorZone(const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other) : _Base()
//      {
//          operator=(other);
//      }
    CTR3D_iteratorZone(const RectZone3Di &_zone):
        _Base(),zone(_zone)
    {
    }
};



template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorFastMasked : public CTR3D_iteratorFast<Container3D,_Ref,_Ptr>
{
    typedef CTR3D_iteratorFast      <Container3D,_Ref,_Ptr> _Base;
    typedef CTR3D_iteratorFastMasked<Container3D,_Ref,_Ptr> _Self;
    const byte *pmask;
public:
    void AssertMasked()
    {
        if(*pmask==0)
        {
            ThrowError("iteratorFastMasked: mask at pos==0 :pos:%x begin:%x end:%x\n",_Base::pos,_Base::begin,_Base::end);
        }
    }
    inline _Self  operator++(int){_Self __tmp=*this;++(*this);return __tmp;}
    inline _Self &operator++()
    {
        // for lazy programers that don't want to write masked and unmasked versions
        // of their algorithms... 
        // this works on unmasked images too but warning, this is a litle bit slower
        if(!pmask){_Base::operator++(0);return *this;}
        do
        {
            pmask++;
            _Base::operator++(0);
        }while(_Base::pos!=this->ima->GetDataEnd() && !(*pmask));
        return *this;
    }   
    inline _Self  operator--(int){_Self __tmp=*this;--(*this);return __tmp;}
    inline _Self &operator--()
    {
        // waring: this is dangerous beacause there is no 100% safe way of checking if we are under begining
        // for lazy programers that don't want to write masked and unmasked versions
        // of their algorithms... 
        // this works on unmasked images too but warning, this is a litle bit slower
        if(!pmask){_Base::operator--(0);return *this;}
        do
        {
            pmask--;
            _Base::operator--(0);
        }while(!(*pmask) && _Base::pos!=this->ima->GetData());
        return *this;
    }   


    inline void  operator+=(size_t m){while (m--) operator++(0);}
    inline void  operator-=(size_t m){while (m--) operator--(0);}
    inline _Self operator+ (size_t m){_Self __tmp=*this;__tmp+=m;return __tmp;}
    inline _Self operator- (size_t m){_Self __tmp=*this;__tmp-=m;return __tmp;}

    void operator=(const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other)
    { 
        _Base::operator=(other);
        if(this->ima->HasMask())
        {
            pmask=this->ima->Mask().GetData();
            if(!(*pmask)){operator++();}
        }
        else
        {pmask=NULL;}
    }

    CTR3D_iteratorFastMasked():_Base(),pmask(NULL){}
    CTR3D_iteratorFastMasked(const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other):
        _Base()
    {
        operator=(other);
    }
};



template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorXYZMasked :    public CTR3D_iteratorXYZ<Container3D,_Ref,_Ptr>
{
    typedef CTR3D_iteratorXYZ      <Container3D,_Ref,_Ptr> _Base;
    typedef CTR3D_iteratorXYZMasked<Container3D,_Ref,_Ptr> _Self;
    const byte *pmask;
public:
    inline _Self  operator++(int){_Self __tmp=*this;++(*this);return __tmp;}
    inline _Self &operator++()
    {
        // for lazy programers that don't want to write masked and unmasked versions
        // of their algorithms... 
        // this works on unmasked images too but warning, this is a litle bit slower
        if(!pmask){_Base::operator++(0);return *this;}
        do
        {
            pmask++;
            _Base::operator++(0);
        }while(!(*pmask) && _Base::pos!=this->ima->GetDataEnd());
        return *this;
    }   
    inline _Self  operator--(int){_Self __tmp=*this;--(*this);return __tmp;}
    inline _Self &operator--()
    {
        // waring: this is dangerous beacause there is no 100% safe way of checking if we are under begining
        // for lazy programers that don't want to write masked and unmasked versions
        // of their algorithms... 
        // this works on unmasked images too but warning, this is a litle bit slower
        if(!pmask){_Base::operator--(0);return *this;}
        do
        {
            pmask--;
            _Base::operator--(0);
        }while(!(*pmask) && _Base::pos!=this->ima->GetData());
        return *this;
    }   
    // jump to new location
    inline void operator=(const Vect3Di &P)
    {
        ThrowError("iteratorXYZMasked operator=V unimplemented");
    }

    inline void  operator+=(size_t m){while (m--) operator++(0);}
    inline void  operator-=(size_t m){while (m--) operator--(0);}
    inline _Self operator+ (size_t m){_Self __tmp=*this;__tmp+=m;return __tmp;}
    inline _Self operator- (size_t m){_Self __tmp=*this;__tmp-=m;return __tmp;}

    void operator= (const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other)
    {
        _Base::operator=(other);
        if(this->ima->HasMask())
        {
            pmask=this->ima->Mask().GetData();
            if(!(*pmask)){operator++();}
        }
        else
        {pmask=NULL;}
    }
    CTR3D_iteratorXYZMasked():_Base(),pmask(NULL){;}
    CTR3D_iteratorXYZMasked(const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other):
        _Base()
    {
        operator=(other);
    }
};


template<class Container3D,class _Ref,class _Ptr>
class CTR3D_iteratorBoxConcentric : public CTR3D_iteratorFast<Container3D,_Ref,_Ptr>
{
    typedef CTR3D_iteratorFast         <Container3D,_Ref,_Ptr> _Base;
    typedef CTR3D_iteratorBoxConcentric<Container3D,_Ref,_Ptr> _Self;
public:
    // intersection of current box and image box
    RectZone3Di currentBox;
    RectZone3Di imazone;
    int x,y,z;
    void AssertBounds()
    {       
//          if(!ima->IsInside(x,y,z)  || !zone.IsInside(x,y,z) || 
//             pos<ima->GetData() || pos>=ima->GetData()+ima->GetNVoxels())
//          {
//              ThrowError("iteratorZone: out of bounds %d %d %d:zone:%d %d %d - %d %d %d: image %d %d %d : pos:%x begin:%x end:%x\n",
//                       x,y,z,
//                       zone.x0,zone.y0,zone.z0,
//                       zone.x1,zone.y1,zone.z1,
//                       ima->Width(),ima->Height(),ima->Depth(),
//                       pos,ima->GetData(),ima->GetData()+ima->GetNVoxels());
//          }
    }
    inline _Self  operator++(int){_Self __tmp=*this;++(*this);return __tmp;}
    inline _Self &operator++()
    {
#ifdef SAFE_DEBUG
        AssertBounds();
#endif
        // go to next point on current box that's inside image
        do{currentBox.ToNextOnSurface(x,y,z);}
        while(!imazone.IsInside(x,y,z) && currentBox.IsInside(x,y,z));

        if(currentBox.IsInside(x,y,z))
        {
            this->pos=&(*this->ima)(x,y,z);
        }
        else
        {
            // finished this box, now find next concentric box
            currentBox=RectZone3Di(currentBox.GetP0()-Vect3Di(1,1,1),currentBox.GetP1()+Vect3Di(1,1,1));
            // check if this was last box
            if(currentBox.IsInside(imazone.GetP0()) && !currentBox.IsOnSurface(imazone.GetP0()) &&
               currentBox.IsInside(imazone.GetP1()) && !currentBox.IsOnSurface(imazone.GetP1())    )
            {this->pos=this->ima->GetDataEnd();return *this;}
            // place current pos at first point in box that's ok
            currentBox.ToStart(x,y,z);
            while(!imazone.IsInside(x,y,z) ){currentBox.ToNextOnSurface(x,y,z);}
            this->pos=&(*this->ima)(x,y,z);
        }
        return *this;
    }
    inline deprecated Vect3Di V() const {return Vect3Di(x,y,z);} // deprecated : use Pos()
    inline Vect3Di Pos() const {return Vect3Di(x,y,z);}
    inline _Ref operator*()
    {
#ifdef SAFE_DEBUG
        AssertBounds();
#endif
        return *this->pos;
    }
    void operator= (const CTR3D_iteratorFast<Container3D,_Ref,_Ptr> &other)
    {
        _Base::operator=(other);
        if(this->pos!=this->ima->GetData()){ThrowError("BoxConcentric::operator= jump to rand this->pos unimplemented");}
        this->imazone=this->ima->GetZone();
        currentBox.ToStart(x,y,z);
        if(!imazone.IsInside(x,y,z))
        {
            Vect3Di p=Vect3Di(x,y,z);
            Vect3Di cp=imazone.ClosestPoint(p);
            Vect3Di dp=p-cp;
            int mx=max(abs(dp.x),max(abs(dp.y),abs(dp.z)));
            dp=Vect3Di(mx,mx,mx);
            currentBox=RectZone3Di(p-dp,p+dp);
            currentBox.ToStart(x,y,z);
            while(!imazone.IsInside(x,y,z) ){currentBox.ToNextOnSurface(x,y,z);}
        }
        this->pos=&(*this->ima)(x,y,z);
    }
    CTR3D_iteratorBoxConcentric():_Base(){}
    CTR3D_iteratorBoxConcentric(const Vect3Di &p0):
        _Base(),currentBox(p0,p0),imazone(0,0,0,0,0,0)
    {
    }
};

---