Image3Dlinear.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>

#ifndef _Image3Dlinear_hpp
#define _Image3Dlinear_hpp


#include<ImLib3D/Complex.hpp>
#include<ImLib3D/Zero.hpp>


// **************** Image3Dlinear ***************************

template<class Im3DValue>
class Image3Dlinear : public Container3D<Im3DValue>
{
    // ********* template typedefs
private:
    typedef Container3D<Im3DValue> _Base;
    typedef Image3Dlinear<Im3DValue> _Self;
public:
    typedef Im3DValue value_type;
//  std_typedefs;
protected:
    mutable Interpolator3D<Im3DValue> *interpolator;
    mutable bool destroyInterpolator;
    Im3DValue zero;

public:
    virtual string GetTypeName() const {return TypeName<_Self>();}


    Im3DValue  Value( float x, float y, float z ) const;
    Im3DValue  Value( const Vect3Df &v ) const {return Value(v.x,v.y,v.z);}
    void SetInterpolator(Interpolator3D<Im3DValue> *_interpolator,bool autoDestroy=true,bool autoReset=true) const
    {
        // cleanup
        if(interpolator && autoDestroy){delete interpolator;}
        // new values
        interpolator=_interpolator;
        destroyInterpolator=autoDestroy;
        // do optional reset
        if(autoReset && interpolator){interpolator->Reset(this);}
    }
    Interpolator3D<Im3DValue>       *GetInterpolator()       {return interpolator;}
    const Interpolator3D<Im3DValue> *GetInterpolator() const {return interpolator;}

    Im3DValue Sum() const 
    {
        Im3DValue sum=Zero<Im3DValue>();
        for(typename _Self::const_iteratorFast p=this->begin(); p!=this->end(); p++ )
        {
            sum+=*p;
        }
        return sum;
    }

    // **************************************************
    // ****************** Accessors *********************
    // **************************************************
    Im3DValue      SafeValue(int pos)     const ;
    Im3DValue      SafeValue(int x,int y,int z) const   
    {return this->IsInside(x,y,z) ? (*this)(x,y,z) : zero ;}
    Im3DValue      SafeValue(const Vect3Di &v)  const   
    {return this->IsInside(v    ) ? (*this)(v    ) : zero ;}
//      Im3DValue      SafeValue(int x,int y,int z) const   
//      {return IsInside(x,y,z) ? (*this)(x,y,z) : (properties.background ? *properties.background : zero) ;}
//      Im3DValue      SafeValue(const Vect3Di &v)  const   
//      {return IsInside(v    ) ? (*this)(v    ) : (properties.background ? *properties.background : zero) ;}

    void ComplexImag(Image3Dlinear<float> &imag) const;
    void ComplexReal(Image3Dlinear<float> &imag) const;
    void ComplexNorm2(Image3Dlinear<float> &imag) const;
    void ComplexModule(Image3Dlinear<float> &imag) const;

    void GetComponent(int c,Image3Dlinear<float> &res) const;
    void SetComponent(int c,const Image3Dlinear<float> &src);
    double L2Norm() const;

    virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const
    {
        node=this->CreateWriteNode(file,parentNode,node);
        if(!file->HasAttribute(node,"Type")){node->set_attribute("Type",GetTypeName());}
        _Base::Write(file,NULL,node);
    }


    // **************************************************
    // ****************** Operators *********************
    // **************************************************
    _Self& operator+=(const _Self &im);     
    _Self& operator+=(const Im3DValue &scalarValue);    
    _Self& operator-=(const _Self &im);     
    _Self& operator-=(const Im3DValue &scalarValue);    
    _Self& operator*=(const _Self &im); 
    _Self& operator*=(double scalarValue);  
    _Self& operator/=(const _Self &im); 


    template<class OtherIm3DValue >
    Image3Dlinear & operator=(const Image3Dlinear<OtherIm3DValue> & other)
    {
        Container3D<Im3DValue>::operator=(other);
        ComputeZero();
        SetInterpolator(NULL);//FIXME, should duplicate interpolator?
        return *this;
    }
    Image3Dlinear & operator=(const Image3Dlinear & other)
    {
        Container3D<Im3DValue>::operator=(*dynamic_cast<const Container3D<Im3DValue> *>(&other));
        zero=other.zero;
        SetInterpolator(NULL);//FIXME, should duplicate
        //FIXME copy zero,interpolator etc.?
        return *this;
    } 

    
    void ComputeZero()
    {
        SetZero<Im3DValue>::Set(zero);
    }
    void ReadWithImageTypeConversion(const string &fname0);

    virtual ~Image3Dlinear();

    Image3Dlinear(const Image3Dlinear & other) : 
        Container3D<Im3DValue>(other),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        ComputeZero();
    }

    explicit Image3Dlinear(const Size3D &size) : 
        Container3D<Im3DValue>(size),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        ComputeZero();
    }

    Image3Dlinear(int _width, int _height, int _depth) : 
        Container3D<Im3DValue>(_width,_height,_depth),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        ComputeZero();
    }


    explicit Image3Dlinear(const string& fname):
        Container3D<Im3DValue>(),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        Streamable::ReadFromFile(fname);ComputeZero();
    }

    explicit Image3Dlinear(const char   *fname):
        Container3D<Im3DValue>(),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        Streamable::ReadFromFile(fname);ComputeZero();
    }

    explicit Image3Dlinear(      char   *fname):
        Container3D<Im3DValue>(),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        Streamable::ReadFromFile(fname);ComputeZero();
    }

    Image3Dlinear() :
        Container3D<Im3DValue>(),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        ComputeZero();
    }

    template<class OtherImageType >
    Image3Dlinear(const OtherImageType & other):
        Container3D<value_type>(other),
        interpolator(NULL),
        destroyInterpolator(false)
    {
        ComputeZero();
    }

};







#include<ImLib3D/Vect3D.hpp>
#include<ImLib3D/Complex.hpp>
typedef Image3Dlinear<float>    Image3Df;
typedef Image3Dlinear<double>   Image3Dd;
typedef Image3Dlinear<Vect3Df>  Field3Df;
typedef Image3Dlinear<complexd> Image3Dcomplex;
typedef Image3Dlinear<complexd> Image3Dcomplexd;
typedef Image3Dlinear<complexf> Image3Dcomplexf;
typedef Image3Dlinear<int>      LabelImage3D;


#include<ImLib3D/Mask3D.hpp>

template<> inline string TypeName<Image3Df>(){return "Image3Df";}
template<> inline string TypeName<Image3Dd>(){return "Image3Dlinear<double>";}
template<> inline string TypeName<Image3Dlinear<int> >(){return "Image3Dlinear<int>";}
template<> inline string TypeName<Image3Dlinear<short int> >(){return "Image3Dlinear<short int>";}
template<> inline string TypeName<Image3Dlinear<Vect3Df> >(){return "Image3Dlinear<Vect3Df>";}
template<> inline string TypeName<Image3Dcomplexf >(){return "Image3Dlinear<std::complex<float> >";}
template<> inline string TypeName<Image3Dcomplexd >(){return "Image3Dlinear<std::complex<double> >";}

#endif // _Image3Dlinear_hpp

---