ConvenienceProcessors.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 _ConvenienceProcessors_hpp
#define _ConvenienceProcessors_hpp

#include<ImLib3D/ImageProcessor.hpp>

namespace IP3D
{
    template <class ImageType1,class ImageType2>
    void ImageTypeConversion(const ImageType1& src,ImageType2& res){res=src;}
};

namespace IP3D
{
    template <class ImageType>
    void Crop(const ImageType& src,const RectZone3Di &zone,ImageType& res0);
};


namespace IP3D
{
    template <class ImageType>
    void FindFirstDifference(const ImageType& src1,const ImageType& src2,bool &found,Vect3Di &pos)
    {
        if(src1.Size()!=src2.Size()){ThrowError("CFindFirstDifference images size differ");}
        typename ImageType::const_iterator p=mismatch(src1.begin(),src1.end(),src2.begin()).first;
        if(p!=src1.end()){found=true;pos=p.ComputePosition();}
        else{found=false;}
    }
};


namespace IP3D
{
    template <class ImageType>
    void FindMinMax(const ImageType& src,
                      typename ImageType::value_type& vmin,
                      typename ImageType::value_type& vmax,
                      Vect3Di *posMin=NULL,
                      Vect3Di *posMax=NULL)
    {
        typename ImageType::const_iterator p;
        typename ImageType::const_iterator pmin=src.begin();
        typename ImageType::const_iterator pmax=src.begin();
        vmin=src(0,0,0);
        vmax=src(0,0,0);
        for(p=src.begin();p!=src.end();++p)
        {
            if(*p<vmin){pmin=p;vmin=*p;}
            if(*p>vmax){pmax=p;vmax=*p;}
        }
        if(posMin){*posMin=pmin.ComputePosition();}
        if(posMax){*posMax=pmax.ComputePosition();}
    }
};

namespace IP3D
{
    template <class ImageType>
    void L2Norm(const ImageType& src, double& energy)
    {
        energy = src.L2Norm();
    }
};

namespace IP3D
{
    template <class ImageType>
    void SetAllVoxels(const ImageType& src, const typename ImageType::value_type& v,ImageType& res)
    {
        if(&res!=&src){res=src;}
        res.Fill(v);
    }
};

namespace IP3D
{
    template <class ImageType>
    void AddMask(const ImageType& src,ImageType& res, const Mask3D *mask=NULL)
    {
        if(&res!=&src){res=src;}
        res.AddMask();
        if(mask)
        {
            if(mask->Size()!=res.Size()){ThrowError("CAddMask: mask size does not mathc with images size");}
            res.Mask()=*mask;
        }
    }
};
namespace IP3D
{
    template <class ImageType>
    void GetMask(const ImageType& src,Mask3D& res)
    {
        if(!src.HasMask()){ThrowError("GetMask: no mask");}
        res=src.Mask();
    }
};

namespace IP3D
{
    template<class ImageType>
    void ApplyMask(const ImageType& src, ImageType& res, byte maskvalue=0, const Mask3D* optmask=NULL);
};

namespace IP3D
{
    template <class ImageType>
    void SetDefaultInterpolator(const ImageType& src,const string&name,ImageType &res)
    {
        res=src;
        res.SetProperty("DefaultInterpolatorName",name);
    }
};

namespace IP3D
{
    template <class ComplexImageType>
    void ExtractFromComplexImage(const ComplexImageType& src,const string &type,Image3Df &res);
};


namespace IP3D
{
    template <class ImageType>
    void SetProperty(const ImageType& src,const string &name,const string &typeName,string value,ImageType &res)
    {
        res=src;
        xmlpp::Document tmpDocument;
        xmlpp::Element *node=tmpDocument.create_root_node(name);
        node->set_attribute("value",value);
        node->set_attribute("PropertyType","PropertyWrapPtr");
        node->set_attribute("type",typeName);
        PropertyXML propertyXML(name,node);
        res.properties.AddUnparsed(name,propertyXML);
    }
};

namespace IP3D
{
    template <class ImageType>
    void RemoveProperty(const ImageType& src,const string &name,ImageType &res)
    {
        res=src;
        res.properties.Remove(name);
    }
};


namespace IP3D
{
    template <class ImageType>
    void Pad(const ImageType& src,Vect3Di paddingV,ImageType &res,bool padLinear=false)
    {
        Vect3Di newSize=src.SizeV()+2*paddingV;
        res.Resize(Size3D(newSize));
        IP3D::InsertImage(res,src,paddingV,res);
        for(int dir=0;dir<3;dir++)
        {
            if(!paddingV(dir)){continue;}
            for(int t=0;t<2;t++)
            {
                Vect3Di p0(0,0,0),p1=newSize-Vect3Di(1,1,1);
                if(t==1)
                {
                    p0(dir)=newSize(dir)-paddingV(dir);
                }
                else
                {
                    p1(dir)=paddingV(dir)-1;
                }
                RectZone3Di centralZone(paddingV,src.Size());
                RectZone3Di zone(p0,p1);
                typename ImageType::iteratorZone p(zone);
                for(p=res.begin();p!=res.end();p++)
                {
                    if(padLinear)
                    {
                        Vect3Di closest=centralZone.ClosestPoint(p.Pos());
                        Vect3Df dPos=closest-p.Pos();
                        dPos.x/=paddingV.x;
                        dPos.y/=paddingV.y;
                        dPos.z/=paddingV.z;
                        *p=(typename ImageType::value_type)((max(0.0f,1-dPos.Norm()))*res(closest));
                    }
                    else
                    {
                        *p=0;
                    }
                }
            }  
        }
    }
}

#include<ImLib3D/ConvenienceProcessors.hxx>

#endif// _ConvenienceProcessors_hpp

---