Container3D.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_hpp
#define _Container3D_hpp

#include<imlib3dconfig.h>

#include<ImLib3D/CppTools.hpp>
#include<ImLib3D/RectZone3D.hpp>
#include<ImLib3D/Vect3D.hpp>
#include <assert.h>
#include <fstream>
#include<ImLib3D/ImLib3DFile.hpp>
#include<ImLib3D/Size3D.hpp>
#include<ImLib3D/Properties.hpp>
#include<ImLib3D/Image3D.hpp>
#include<ImLib3D/FloatCast.hpp>

template<class Im3DValue> 
class Interpolator3D;

#define _Container3D_internal
#include<ImLib3D/Container3DIterators.hpp>
#undef  _Container3D_internal


template<class T>
struct HasPointerIterators
{
    typedef __true_type value;
};

// ********************** Container3D ********************

template<class Im3DValue>
class Container3D : public Image3D
{
private:
    Im3DValue *imageData;
    Im3DValue *imageDataEnd;
    int widthXheight;

    typedef Container3D<Im3DValue> _Self;
public:
    typedef Im3DValue value_type;
public:

    typedef CTR3D_iteratorFast<      Container3D,Im3DValue &,Im3DValue *>    iterator;
    typedef CTR3D_iteratorFast<      Container3D,Im3DValue &,Im3DValue *>    iteratorFast;
    typedef CTR3D_iteratorXYZ<       Container3D,Im3DValue &,Im3DValue *>    iteratorXYZ;
    typedef CTR3D_iteratorZone<      Container3D,Im3DValue &,Im3DValue *>    iteratorZone;
    typedef CTR3D_iteratorFastMasked<Container3D,Im3DValue &,Im3DValue *>    iteratorFastMasked;
    typedef CTR3D_iteratorXYZMasked<Container3D,Im3DValue &,Im3DValue *>     iteratorXYZMasked;
    typedef CTR3D_iteratorBoxConcentric<Container3D,Im3DValue &,Im3DValue *> iteratorBoxConcentric;

    typedef CTR3D_iteratorFast<      const Container3D,const Im3DValue &,const Im3DValue *>    const_iterator;
    typedef CTR3D_iteratorFast<      const Container3D,const Im3DValue &,const Im3DValue *>    const_iteratorFast;
    typedef CTR3D_iteratorXYZ<       const Container3D,const Im3DValue &,const Im3DValue *>    const_iteratorXYZ;
    typedef CTR3D_iteratorZone<      const Container3D,const Im3DValue &,const Im3DValue *>    const_iteratorZone;
    typedef CTR3D_iteratorFastMasked<const Container3D,const Im3DValue &,const Im3DValue *>    const_iteratorFastMasked;
    typedef CTR3D_iteratorXYZMasked< const Container3D,const Im3DValue &,const Im3DValue *>    const_iteratorXYZMasked;
    typedef CTR3D_iteratorBoxConcentric<const Container3D,const Im3DValue &,const Im3DValue *> const_iteratorBoxConcentric;

    typedef reverse_iterator<const_iterator> const_reverse_iterator;
    typedef reverse_iterator<      iterator>       reverse_iterator;

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

    iteratorFast         begin()       {return iteratorFast(this,imageData);}
    const_iteratorFast   begin() const {return const_iteratorFast(this,imageData);}
    inline iteratorFast         end()         {return iteratorFast(this,imageDataEnd);}
    inline const_iteratorFast   end()   const {return const_iteratorFast(this,imageDataEnd);}

    inline       reverse_iterator rbegin()         { return       reverse_iterator(end()); }
    inline const_reverse_iterator rbegin() const   { return const_reverse_iterator(end()); }
    inline       reverse_iterator rend()           { return       reverse_iterator(begin()); }
    inline const_reverse_iterator rend() const     { return const_reverse_iterator(begin()); }

    // **************************************************
    // ****************** accessors *********************
    // **************************************************
    bool HasSupport() const {return Has("Support");}
    RectZone3Df    &AddSupport(const Vect3Df &p0,const Vect3Df &p1)
    {properties.Add("Support",RectZone3Df(p0,p1));return Support();}
    RectZone3Df    &AddSupport(const RectZone3Df& otherSupport)
    {properties.Add("Support",otherSupport);return Support();}
    RectZone3Df       &Support()       {return Property<RectZone3Df>("Support");}
    RectZone3Df const &Support() const {return Property<RectZone3Df>("Support");}   


    inline       Im3DValue *GetData()          {return imageData;}
    inline const Im3DValue *GetData() const    {return imageData;}
    inline       Im3DValue *GetDataEnd()       {return imageDataEnd;}
    inline const Im3DValue *GetDataEnd() const {return imageDataEnd;}
    
#ifdef SAFE_DEBUG
    inline       Im3DValue &operator()(int pos)                 {AssertBounds(pos);return imageData[pos];}
    inline const Im3DValue &operator()(int pos)           const {AssertBounds(pos);return imageData[pos];}
    inline       Im3DValue &operator()(int x,int y,int z)       {AssertBounds(x,y,z);return imageData[x+y*width+z*widthXheight];}
    inline const Im3DValue &operator()(int x,int y,int z) const {AssertBounds(x,y,z);return imageData[x+y*width+z*widthXheight];}
    inline       Im3DValue &operator()(const Vect3Di &v)        {AssertBounds(v.x,v.y,v.z);return imageData[v.x+v.y*width+v.z*widthXheight];}
    inline const Im3DValue &operator()(const Vect3Di &v)  const {AssertBounds(v.x,v.y,v.z);return imageData[v.x+v.y*width+v.z*widthXheight];}
#else //SAFE_DEBUG
    inline       Im3DValue &operator()(int pos)                 {return imageData[pos];}
    inline const Im3DValue &operator()(int pos)           const {return imageData[pos];}
    inline       Im3DValue &operator()(int x,int y,int z)       {return imageData[x+y*width+z*widthXheight];}
    inline const Im3DValue &operator()(int x,int y,int z) const {return imageData[x+y*width+z*widthXheight];}
    inline       Im3DValue &operator()(const Vect3Di &v)        {return imageData[v.x+v.y*width+v.z*widthXheight];}
    inline const Im3DValue &operator()(const Vect3Di &v)  const {return imageData[v.x+v.y*width+v.z*widthXheight];}
#endif //SAFE_DEBUG
    virtual float FloatValue(int x,int y,int z) const {return FloatCast<Im3DValue>::Cast((*this)(x,y,z));}


    // **************************************************
    // ****************** methods   *********************
    // **************************************************

    void  deprecated SetAll(const Im3DValue & value) {Fill(value);}
    void  Fill(const Im3DValue & value){fill(begin(),end(),value);}
protected:
    bool WarnOnUnkownType() const;

public:

    virtual void Read( ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL)      ;
    virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const;
private:
    virtual void WriteBinary(ImLib3DFile *file) const;
    virtual void ReadBinary(ImLib3DFile *file);
    virtual int  GetBinarySize() const {WarnOnUnkownType();return sizeof(Im3DValue)*GetNVoxels();}
public:
    virtual void WriteToFile (const string &fname) const {Streamable::WriteToFile(fname);}

public:
    void Resize(const Size3D &newSize);

    template<class OtherImageType >
    _Self& operator= (const OtherImageType & other);
    _Self& operator= (const _Self & other);
    bool   operator==(const _Self & other) const;
    bool   operator!=(const _Self & other) const {return !(this->operator==(other));}

    // **************************************************
    // ****************** constructors/destructors*******
    // **************************************************

protected:
    void Allocate();
    void DeAllocate();
public:

    virtual ~Container3D();
protected:
public:
    Container3D();
    Container3D(int _width, int _height, int _depth);
    explicit Container3D(const string& fname){ReadFromFile(fname);}
    explicit Container3D(const char   *fname){ReadFromFile(fname);}
    explicit Container3D(      char   *fname){ReadFromFile(fname);}
    explicit Container3D(const Size3D &size);
    Container3D(const Container3D & other);
    template<class OtherImageType >
    Container3D(const OtherImageType & other):
        Image3D(other),
        imageData(NULL),imageDataEnd(NULL)
    {
        Resize(other.Size());
        operator=(other);
    }



};

extern string Container3D_ReadImageType(const string &fname);



#define std_typedefs typedef Im3DValue value_type;      \
    typedef typename _Base::iteratorZone iteratorZone;  \
    typedef typename _Base::iteratorFast iteratorFast;  \
    typedef typename _Base::iteratorXYZ  iteratorXYZ;   \
    typedef typename _Base::const_iteratorZone const_iteratorZone;  \
    typedef typename _Base::const_iteratorFast const_iteratorFast;  \
    typedef typename _Base::const_iteratorXYZ  const_iteratorXYZ;    


#include<ImLib3D/Image3Dlinear.hpp>

#include<ImLib3D/Container3D.hxx>
#include<ImLib3D/Image3Dlinear.hxx>
#include<ImLib3D/Properties.hxx>


#endif  // _Container3D_hpp

---