Container3D.hxx

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_hxx
#define _Container3D_hxx

// *******************************************************
// template implementations for Container3D
// *******************************************************

template<class Im3DValue>
bool 
Container3D<Im3DValue>::WarnOnUnkownType() const
{
    if(!(IsSameType<Im3DValue,float  >() || IsSameType<Im3DValue,double   >() || 
         IsSameType<Im3DValue,Vect3Df>() || IsSameType<Im3DValue,byte     >() || 
         IsSameType<Im3DValue,int    >() || IsSameType<Im3DValue,short int>()))
    {
        mprintf("Warning: Container3D value type is unknown, using default routines:typename:%s\n",TypeName<Im3DValue>().c_str());
        return true;
    }
    return false;
}



template<class Im3DValue>
void 
Container3D<Im3DValue>::Write(ImLib3DFile *file,xmlpp::Element *parentNode,xmlpp::Element *node) const
{
    node=CreateWriteNode(file,parentNode,node);
    // **** Optionally add unset image properties ***
    // set image type (Image3Df, Field3D etc....) 
    if(!file->HasAttribute(node,"Type")){node->set_attribute("Type",GetTypeName());}
    // store Data (binary) information
    if(!file->HasChild(node,"ImageData"))
    {
        xmlpp::Element *dataN=node->add_child("ImageData");
        file->AddBinaryNode(dataN,GetBinarySize());
        // write image's binary block 
        WriteBinary(file);
    }      
    // write parents data (image size and properties)
    Image3D::Write(file,NULL,node);
}
template<class Im3DValue>
void 
Container3D<Im3DValue>::Read(ImLib3DFile *file,xmlpp::Element *parentNode,xmlpp::Element *node)
{
    node=CreateReadNode(file,parentNode,node);
    Image3D::Read(file,NULL,node);

    if(file->debug){cout << "Container3D::Read: " << endl;file->ShowXML(node);}
    
    //type checking
    string type=file->GetAttribute(node,"Type");
    if(type!=GetTypeName()){ThrowError("Container3D::Read: Expected type:\"%s\" found type:\"%s\"",GetTypeName(),type);}

    //image data
    xmlpp::Element *dataN=file->GetChild(node,"ImageData");
    file->ReadBinaryNode(dataN);
    ReadBinary(file);
    if(!file->CheckBinaryReadComplete())
    {ThrowError("XMLBinaryFile::BinaryRead bad read size (maybe wrong image type?) ");}
}


template<class Im3DValue>
void
Container3D<Im3DValue>::WriteBinary(ImLib3DFile *file) const
{
    file->template BinaryWrite<Im3DValue,Im3DValue *>(imageData,imageData+GetNVoxels());
}
template<class Im3DValue>
void
Container3D<Im3DValue>::ReadBinary(ImLib3DFile *file)
{
    file->template BinaryRead<Im3DValue>(imageData,imageData+GetNVoxels());
}

// *******************************************************
template<class Im3DValue>
void 
Container3D<Im3DValue>::Resize(const Size3D &newSize)
{
    if(GetData() && newSize==Size()){return;}
    Image3D::Resize(newSize);
    DeAllocate();
    nvoxels=width*height*depth;
    widthXheight=width*height;
    if(nvoxels>0){Allocate();}
    if(nvoxels<0){ThrowError("Container3D::Resize size<0??");}
    if(HasMask()){Mask().Resize(newSize);}
}


// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>& 
Container3D<Im3DValue>::operator=(const Container3D<Im3DValue> & other)
{
    if (this == &other){return *this;}
    if(other.Size()!=Size()){Resize(other.Size());}
    // call parent operator =
    Image3D::operator=(*dynamic_cast<const Image3D *>(&other));
    // now copy the actual image data   
    if(IsSameType<Im3DValue,float  >() || IsSameType<Im3DValue,double>() || 
       IsSameType<Im3DValue,Vect3Df>() || IsSameType<Im3DValue,int   >() || 
       IsSameType<Im3DValue,byte   >() )
    {
        // memcpy is 2xfaster and works safely on these types
        memcpy((void *)GetData(),(void *)other.GetData(),sizeof(Im3DValue)*GetNVoxels());
    }
    else
    {
        // use fast iterators for unknown types
        const_iteratorFast pOrig;
        iteratorFast p;
        for (p = begin(),pOrig=other.begin(); p != end(); p++,pOrig++)
        {
            *p = *pOrig;
        }       
    }
    
    return *this;
}

// *******************************************************
template<class Im3DValue>
template<class OtherImageType>
Container3D<Im3DValue>& 
Container3D<Im3DValue>::operator=(const OtherImageType & other)
{
    // copy information in parent class
    Image3D::operator=(other);

    // now copy data, using cast
    typename OtherImageType::const_iteratorFast pOrig;
    iteratorFast p;
    for (p = begin(),pOrig=other.begin(); p != end(); p++,pOrig++)
    {
        *p = static_cast<Im3DValue>(*pOrig);
    }       
        
    return *this;
}

// *******************************************************
template<class Im3DValue>
bool 
Container3D<Im3DValue>::operator==(const Container3D<Im3DValue> & other) const
{
    if(other.Size()!=Size()){return false;}

    const_iteratorFast pOrig;
    const_iteratorXYZ p;
    for (p = begin(),pOrig=other.begin(); p != end(); p++,pOrig++)
    {
        if(!((*p) == (*pOrig))){return false;}
    }       
    
    if(!(properties==other.properties)){return false;}
    
    return true;
}


// *******************************************************
template<class Im3DValue>
void
Container3D<Im3DValue>:: Allocate()
{
    DeAllocate();
    try
    {
//              mprintf("Container3D::Allocate: nvoxels:%d sizeof element:%d\n",nvoxels,sizeof(Im3DValue));
//              mprintf("Container3D::Allocate: %d %d %d\n",Width(),Height(),Depth());
        imageData=new Im3DValue[GetNVoxels()];      
        if(!imageData)
        {
            ThrowError("Container3D::Allocate: allocate failed. nvoxels:%d sizeof element:%d\n",GetNVoxels(),sizeof(Im3DValue));
        }
        imageDataEnd=imageData+GetNVoxels();
    }
    catch(...)
    {
        ThrowError("Container3D::Allocate: allocate failed. nvoxels:%d sizeof element:%d\n",GetNVoxels(),sizeof(Im3DValue));
    }
}

// *******************************************************
template<class Im3DValue>
void 
Container3D<Im3DValue>::DeAllocate()
{
    if(imageData){delete [] imageData;}
    imageData=NULL;
    imageDataEnd=NULL;
}

// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>::~Container3D()
{
    DeAllocate();
}

// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>::Container3D(int _width, int _height, int _depth) : 
    Image3D(_width,_height,_depth),
    imageData(NULL),imageDataEnd(NULL)
{
    Resize(Size3D(_width,_height,_depth));
}
// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>::Container3D():
    Image3D(),
    imageData(NULL),imageDataEnd(NULL)
{
    Resize(Size3D(0,0,0));
}

// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>::Container3D(const Size3D &size):
    Image3D(size),
    imageData(NULL),imageDataEnd(NULL)
{
    Resize(size);
}

// *******************************************************
template<class Im3DValue>
Container3D<Im3DValue>::Container3D(const Container3D & other) :
    Image3D(other),
    imageData(NULL),imageDataEnd(NULL)
{
    Resize(other.Size());
    (*this)=other;
}

#endif // _Container3D_hxx

---