MorphologicalOperators.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 _MorphologicalOperators_hpp
#define _MorphologicalOperators_hpp

#include<ImLib3D/ImageProcessor.hpp>
#include<map>


enum StructureElementType
{
    MORPHO_CUSTOM,  
    MORPHO_FORWARD,  
    MORPHO_BACKWARD, 
    MORPHO_ALLDIRECTIONS, 
    MORPHO_Cubic27, 
    MORPHO_Cross7,  
    MORPHO_Planar19,
    MORPHO_Corner9 ,
    MORPHO_Pts81,       
    MORPHO_Pts14,
    MORPHO_Pts4,
    MORPHO_Pts10,
    MORPHO_Pts5,
    MORPHO_Pts41,
    MORPHO_XYCross5, 
    MORPHO_XZCross5, 
    MORPHO_YZCross5, 
    MORPHO_SphereR3, 
    MORPHO_SphereR4  
};


class StructureElement
{
protected:
    StructureElementType maskType;
    void CreateMask();
public:
    void ComputeMaskPointsSize(Vect3Di &minv,Vect3Di &maxv) const;
protected:
    void CreateMaskPoints(StructureElementType maskType);
    void CreateMaskPoints();

    vector<Vect3Di> maskPoints;
    vector<float> coeffs;

    Mask3D *mask;
public:
    static void CreateSpherePointList(int radius,vector<Vect3Di>& pl);
    void ComputeCoeffs();
    void Show(const string &name) const;
    inline const Vect3Di &GetPoint(int i) const {return maskPoints[i];}
    inline const Vect3Di &operator[](uint i) const {return maskPoints[i];}
    inline float GetCoeff(int i) const {return coeffs[i];}
    RectZone3Di SafeZone(const Size3D &imageSize) const
    {
        Vect3Di vmin,vmax;
        ComputeMaskPointsSize(vmin,vmax);
        return RectZone3Di(Vect3Di(0,0,0),imageSize).Intersection(
            RectZone3Di(-vmin,imageSize.GetV()-vmax-Vect3Di(1,1,1)));
    }
    int   FindPoint(const Vect3Di &P) const 
    {
        for(uint i=0;i<maskPoints.size();i++)
        {if(P==maskPoints[i]){return i;}}
        return -1;
    }
    float GetCoeff(const Vect3Di &P) const 
    {
        int i=FindPoint(P);
        if(i<0)ThrowError("GetCoeff(P=%d %d %d) point not found",P.x,P.y,P.z);
        return coeffs[i];
    }
    const Mask3D  &Mask() const {return *mask;}
    inline int  GetNbPoints() const {return maskPoints.size();}
    inline uint size() const {return maskPoints.size();}
    

    void RemoveCenter();
    
    ~StructureElement()
    {
        if(mask){delete mask;}
    }
    StructureElement(const string &s);

    StructureElement(const StructureElement &other,StructureElementType direction);

    StructureElement(StructureElementType _maskType):
        maskType(_maskType),
        mask(NULL)
    {
        CreateMaskPoints(maskType);
        CreateMask();
    }
    StructureElement(const vector<Vect3Di> &_maskPoints):
        maskType(MORPHO_CUSTOM),
        mask(NULL)
    {
        maskPoints=_maskPoints;
        CreateMask();
    }
};


template<class ImageType,class Inst=typename HasPointerIterators<ImageType>::value >
class ImageNeighbors
{
    typedef typename ImageType::value_type Im3DValue;
    typedef typename ImageType::iteratorFast Iterator;
    ImageType &image;
    const StructureElement &sel;
    Im3DValue ** iterators;//vector<Iterator> iterators;
    typename ImageType::iteratorXYZ p;
    uint npts;
    RectZone3Di safezone;
    int lastY;
    int lastX;
public:
    inline bool IsSafe(const Vect3Di &pos){return safezone.IsInside(pos);}
    inline void MoveTo(const Vect3Di &pos)
    {
        if(lastY!=pos.y || lastX!=pos.x-1)
        {// if we've changed line we have to recompute iterators (slow)
            for(uint i=0;i<npts;i++)
            {
                iterators[i]=(Im3DValue *)&image(pos+sel[i]);
//              iterators[i].MoveTo(pos+sel[i]);
            }
            lastY=pos.y;
            lastX=pos.x;
        }
        else
        {// fast!, just increment iterators
            for(uint i=0;i<npts;i++){iterators[i]++;}
            lastX++;
        }
    }
    inline void MoveBackwardsTo(const Vect3Di &pos)
    {
        if(lastY!=pos.y || lastX!=pos.x+1)
        {// if we've changed line we have to recompute iterators (slow)
            for(uint i=0;i<npts;i++)
            {
                iterators[i]=(Im3DValue *)&image(pos+sel[i]);
//              iterators[i].MoveTo(pos+sel[i]);
            }
            lastY=pos.y;
            lastX=pos.x;
        }
        else
        {// fast!, just decrement iterators
            for(uint i=0;i<npts;i++){iterators[i]--;}
            lastX--;
        }
    }
    inline Im3DValue &operator[](int i){return *(iterators[i]);}
    ~ImageNeighbors(){delete [] iterators;}
    ImageNeighbors(ImageType &_image,const StructureElement &_sel):
        image(_image),sel(_sel),
        iterators(new Im3DValue*[sel.size()]),//iterators(sel.size()),
        npts(sel.size()),
        safezone(sel.SafeZone(image.Size())),lastY(-1),lastX(-2)
    {
        //for(uint i=0;i<npts;i++){iterators[i]=image.begin();}
    }
};

template<class ImageType>
struct IteratorType
{
    typedef typename ImageType::iterator type;
};
template<class ImageType>
struct IteratorType<const ImageType>
{
    typedef typename ImageType::const_iterator type;
};

template<class ImageType>
class ImageNeighbors<ImageType,__false_type>
{
    typedef typename ImageType::value_type Im3DValue;
    typedef typename IteratorType<ImageType>::type Iterator;
    ImageType &image;
    const StructureElement &sel;
    vector<Iterator> iterators;
    typename ImageType::iteratorXYZ p;
    uint npts;
    RectZone3Di safezone;
    int lastY;
    int lastX;
public:
    inline bool IsSafe(const Vect3Di &pos){return safezone.IsInside(pos);}
    inline void MoveTo(const Vect3Di &pos)
    {
        if(lastY!=pos.y || lastX!=pos.x-1)
        {// if we've changed line we have to recompute iterators (slow)
            for(uint i=0;i<npts;i++)
            {
                iterators[i]=pos+sel[i];
            }
            lastY=pos.y;
            lastX=pos.x;
        }
        else
        {// fast!, just increment iterators
            for(uint i=0;i<npts;i++){iterators[i]++;}
            lastX++;
        }
    }
    inline void MoveBackwardsTo(const Vect3Di &pos)
    {
        if(lastY!=pos.y || lastX!=pos.x+1)
        {// if we've changed line we have to recompute iterators (slow)
            for(uint i=0;i<npts;i++)
            {
//              iterators[i]=(Im3DValue *)&image(pos+sel[i]);
                iterators[i]=pos+sel[i];
            }
            lastY=pos.y;
            lastX=pos.x;
        }
        else
        {// fast!, just decrement iterators
            for(uint i=0;i<npts;i++){iterators[i]--;}
            lastX--;
        }
    }
    inline Im3DValue operator[](int i){return *(iterators[i]);}
    ~ImageNeighbors(){}
    ImageNeighbors(ImageType &_image,const StructureElement &_sel):
        image(_image),sel(_sel),
//      iterators(new Im3DValue*[sel.size()]),
        iterators(sel.size()),
        npts(sel.size()),
        safezone(sel.SafeZone(image.Size())),lastY(-1),lastX(-2)
    {
        for(uint i=0;i<npts;i++){iterators[i]=image.begin();}
    }
};



namespace IP3D
{
    template <class ImageType>
    void MedianFilter(const ImageType& src, const StructureElement &mask, ImageType& res);
};

namespace IP3D
{
    template <class ImageType>
    void SharpeningFilter(const ImageType& src, const StructureElement &mask, ImageType& res);
};


namespace IP3D
{
    template <class ImageType>
    void Erosion(const ImageType& src, const StructureElement &mask, ImageType& res);
};

namespace IP3D
{
    template <class ImageType>
    void Dilation(const ImageType& src, const StructureElement &mask, ImageType& res);
};

namespace IP3D
{
    template <class ImageType>
    void Opening(const ImageType& src, const StructureElement &mask, ImageType& res)
    {
        IP3D::Erosion(src,mask,res);
        IP3D::Dilation(res,mask,res);
    }
};

namespace IP3D
{
    template <class ImageType>
    void Closing(const ImageType& src, const StructureElement &mask, ImageType& res)
    {
        IP3D::Dilation(src,mask,res);
        IP3D::Erosion(res,mask,res);
    }
};

namespace IP3D
{
        void DistanceTransform(const Mask3D& src, const StructureElement &mask, Image3Df& res,bool borderExtend=false);
};

namespace IP3D
{
    template <class ImageType>
    void ConnectedComponentLabelling(const ImageType& src, const StructureElement &mask0, LabelImage3D& res,typename ImageType::value_type *background0=NULL);
};
template <class ImageType> inline pair<bool,typename ImageType::value_type> DefaultBackground(){return pair<bool,typename ImageType::value_type>(false,typename ImageType::value_type());}
template <> inline pair<bool,byte> DefaultBackground<Mask3D>(){return pair<bool,byte>(true,0);}

namespace IP3D
{
        void FillHoles(const Mask3D& src, const StructureElement &mask, Mask3D& res);
};

class CMakeValueList;


template<class Im3DValue>
class ImageValues
{
    friend class CMakeValueList;
public:
    class ImageValue
    {
    public:
        int size;// number of voxels having this value
        Vect3Di point;// position of a voxel having this value
        ImageValue(){size=0;point.x=-1;point.y=-1;}
    };
    typedef map<Im3DValue,ImageValue> MapType;
    map<Im3DValue,ImageValue> values;
    ImageValue operator[](const Im3DValue &v)
    {
        return values[v];
    }

};
namespace IP3D
{
    template <class ImageType>
    void MakeValueList(const ImageType& src, ImageValues<typename ImageType::value_type>& res);
};

namespace IP3D
{
        void LargestConnectedComponent(const Mask3D &src,Mask3D &res);
};


#include<ImLib3D/MorphologicalOperators.hxx>

#endif // _MorphologicalOperators_hpp

---