Mask3D.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.
 */
#include<ImLib3D/Image3D.hpp>
#include<ImLib3D/Image3Dlinear.hpp>
#ifndef _Mask3D_hpp
#define _Mask3D_hpp



template<class MaskType>
class MaskConcept
{
    inline       MaskType * mask()       {return (MaskType *)(this);}
    inline const MaskType *cmask() const {return (MaskType *)(this);}
public:
    void Invert()
    {
        typename MaskType::iteratorFast p;
        for (p=mask()->begin(); p!=mask()->end(); p++)
        {
            if (!(*p)) { (*p) = 1;}
            else       { (*p) = 0;}
        }
    }
    void Normalize()
    {
        typename MaskType::iteratorFast p;
        for (p=mask()->begin(); p!=mask()->end(); p++)
        {
            if (*p){(*p) = 1;}
        }
    }

    void Select(byte v)
    {
        typename MaskType::iteratorFast p;
        for (p=mask()->begin(); p!=mask()->end(); p++)
        {
            if (*p==v){(*p) = 1;}else{*p=0;}
        }
    }
    template<class ImArgType>
    void ApplyOn(ImArgType &ima) const
    {
        if(ima.Size()!=cmask()->Size())
        {ThrowError("MaskIP3D::onceptOn different sizes");}
        typename MaskType::const_iteratorFast p;
        typename ImArgType::iteratorFast sp;
        for (p=cmask()->begin(),sp=ima.begin(); p!=cmask()->end(); p++,sp++)
        {
            if (!(*p)) { (*sp) = Zero<typename ImArgType::value_type>();}
        }
    }
    double Sum() const
    {
        double sum=0;
        for(typename MaskType::const_iteratorFast p=cmask()->begin(); p!=cmask()->end(); p++ )
        {
            sum+=*p;
        }
        return sum;
    }
    Vect3Di VectFromOffset(int position) const
    {
        int counter=0;
        typename MaskType::const_iteratorXYZ it;
        for (it=cmask()->begin(); it!=cmask()->end(); it++)
        {
            if (*it)
            {
                counter++;
                if (counter == position)
                    return Vect3Di(it.x, it.y, it.z);
            }
        }
        ThrowError("Mask3d::RealPosFromRelativePos position outside mask : %d\n", position);
        return Vect3Di(0, 0, 0);//compiler happy
    }
    RectZone3Di FindBoundingBox() const
    {
        RectZone3Di box(cmask()->Height(), cmask()->Width(), cmask()->Depth(), 0, 0, 0);
        typename MaskType::const_iteratorXYZ p;
        bool noValues = true;
        for (p=cmask()->begin(); p!=cmask()->end(); p++)
        {
            if ((*p)>0)
            {
                if (p.x < box.x0)
                    box.x0 = p.x;
                if (p.y < box.y0)
                    box.y0 = p.y;
                if (p.z < box.z0)
                    box.z0 = p.z;
                noValues = false;
            }
        }
        int n = cmask()->GetNVoxels();
        p=cmask()->begin(); p+=n-1;//No p=end() assignment possible at the moment
        for (; p!=cmask()->begin(); p--)
        {
            if ((*p)>0)
            {
                if (p.x > box.x1)
                    box.x1 = p.x;
                if (p.y > box.y1)
                    box.y1 = p.y;
                if (p.z > box.z1)
                    box.z1 = p.z;
                noValues = false;
            }
        }
        if (noValues)
        {
            box.x0 = 0; box.y0 = 0; box.z0 = 0;
        }
        return box;
    }

};

// ****************** Mask3D ********************

class Mask3D : public Image3Dlinear<byte> , public MaskConcept<Mask3D>
{
    typedef Image3Dlinear<byte> _Parent;
public:
    virtual string GetTypeName() const;
    virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const
    {
        node=_Parent::CreateWriteNode(file,parentNode,node);
        if(!file->HasAttribute(node,"Type")){node->set_attribute ("Type",GetTypeName());}
        _Parent::Write(file,NULL,node);
    }
    
    template<class OtherIm3DValue >
    Mask3D & operator=(const Image3Dlinear<OtherIm3DValue> & imOrig)
    {
        Container3D<byte>::operator=(imOrig);
        return *this;
    }

    double Sum() const {return MaskConcept<Mask3D>::Sum();}


    Mask3D():Image3Dlinear<byte>(){;}
    Mask3D(const Size3D &size) : 
        Image3Dlinear<byte>(size)
    {}
    Mask3D(const Mask3D &other):
        Image3Dlinear<byte>(other)
    {}
    Mask3D(int _width, int _height, int _depth) : 
        Image3Dlinear<byte>( _width, _height, _depth )
    {}
    Mask3D(const string& fname) :
        Image3Dlinear<byte>()
    {Streamable::ReadFromFile(fname);}
    Mask3D(const char * fname) :
        Image3Dlinear<byte>()
    {Streamable::ReadFromFile(fname);}
    Mask3D(      char * fname) :
        Image3Dlinear<byte>()
    {Streamable::ReadFromFile(fname);}
    template<class OtherImageType >
    Mask3D(const OtherImageType & other):
        Image3Dlinear<byte>(other)
    {}
};


// These methods of Image3D can only be defined now that Mask3D is declared
inline byte   Image3D::Mask(const Vect3Di &P) const  {return (*properties.mask)(P);}
inline byte  &Image3D::Mask(const Vect3Di &P)        {return (*properties.mask)(P);}
inline byte   Image3D::Mask(int x,int y,int z) const {return (*properties.mask)(x,y,z);}
inline byte  &Image3D::Mask(int x,int y,int z)       {return (*properties.mask)(x,y,z);}
inline void          Image3D::RemoveMask()
{
    if(!HasMask()){ThrowError("Container3D::RemoveMask: no mask");}
    delete properties.mask; 
    properties.mask = NULL;
}

template<> inline string TypeName<Mask3D>(){return "Mask3D";}

inline string Mask3D::GetTypeName() const {return TypeName<Mask3D>();}

#endif // _Mask3D_hpp

---