/home/fayn/OpenKraken-dev/OpenKN-image/src/Image3D.hpp

Go to the documentation of this file.

/***************************************************************************\
 * Copyright (C) by University Paris-Est - MISS team   
 * Image.hpp created in 09 2008.
 * Mail : biri@univ-mlv.fr
 *
 * This file is part of the OpenKraken-image.
 *
 * The OpenKraken-image is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * The OpenKraken-image 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.      If not, see <http://www.gnu.org/licenses/>.
 *
\***************************************************************************/

/*
 * Anti-doublon
 */
#ifndef __OPENKN_IMAGE__IMAGE3D_HPP__
#define __OPENKN_IMAGE__IMAGE3D_HPP__

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma warning(disable:4996)
#endif

/*
 * External Includes
 */
#include <iostream>
#include <sstream>
#include <string>
#include <cstring>
#include <algorithm>

/*
 * Internal Includes
 */
#include "ImageException.hpp"
#include "Image.hpp"
/*
 * Namespace
 */
namespace kn{
        
                /*
                 * Class definition
                 */

                template<typename T>
                class Image3D {

                        /*
                         * Constructor & destructors
                         */
                public:
                        Image3D();

                        Image3D(const size_t width, const size_t height, const size_t depth, const size_t nbChannel, T* buffer=0);

                        Image3D(const Image3D<T> & i);

                        virtual ~Image3D();

           
                protected :
                        T * data;
                        
                
                        T ** frames;

                        T *** rows;
                        
                        
                        void initRowsAndFrames();

                        T * begin_;

                        T * end_;

                public :
                        inline virtual T  * begin() const {return begin_;}

                        inline virtual T  * end() const {return end_;}
                        
                protected :
                        size_t imageWidth;

                        size_t imageHeight;

                        size_t imageDepth;
                        
                        size_t imageNbChannel;

                        size_t imageSize;
                public:
                        inline virtual size_t width() const {return imageWidth; }

                        inline virtual size_t height() const {return imageHeight; }

                        inline virtual size_t depth() const {return imageDepth; }

                        inline virtual size_t nbChannel() const {return imageNbChannel; }

                        inline virtual size_t size() const {return imageSize; }
                        
                        inline virtual T * operator()(const unsigned int x, const unsigned int y, const unsigned int z) const {
                                return (rows[y][z]+x*imageNbChannel);
                        }

                        inline virtual T * at(const unsigned int x, const unsigned int y, const unsigned int z) const {
                                if (x>=imageWidth || y>=imageHeight || z>=imageDepth ) {
                                        std::ostringstream o("Operator("); o << x << "," << y << "," << z << ") " ;
                                        throw ImageException(o.str(), "Invalid range");
                                }
                                return (*this)(x,y,z);//(rows[y]+x*nbChannel());
                        }

                        inline virtual T & operator()(const unsigned int x, const unsigned int y, const unsigned int z, const unsigned int channel) {
                                return (*this)(x,y,z)[channel];
                        }

                        inline virtual T & at(const unsigned int x, const unsigned int y, const unsigned int z, const unsigned int channel) {
                                if (channel>=imageNbChannel) {
                                        std::ostringstream o("Operator("); o << x << "," << y << "," << z << "," << channel <<") " ;
                                        throw ImageException(o.str(), "Invalid range");
                                }
                                return (at(x,y,z)[channel]);
                        }

                        inline virtual const T & operator()(const unsigned int x, const unsigned int y, const unsigned int z, const unsigned int channel)const {
                                return (*this)(x,y,z)[channel];
                        }

                        inline virtual const T & at(const unsigned int x, const unsigned int y, const unsigned int z, const unsigned int channel)const {
                                if (channel>=imageNbChannel) {std::ostringstream o("Operator("); o << x << "," << y << "," << z << "," <<channel<< ") " ; throw ImageException(o.str(), "Invalid range"); }
                                return (*this)(x,y,z)[channel];
                        }


                        virtual Image3D<T> & operator=(const Image3D &i) ;


                        inline void fill(const T &value) {
                          std::fill(begin_,end_,value);
                        }

                        inline void setFrame(unsigned int index, Image<T>& frame){
                                if(frame.width() != imageWidth || frame.height() != imageHeight || frame.nbChannel() != imageNbChannel)
                                        throw ImageException("invalid frame dimensions", "Image3D::setFrame");
                                if(index >= imageDepth)
                                        throw ImageException("index out of bound", "Image3D::setFrame");
                                std::copy(frame.begin(), frame.end(), frames[index]);
                        } 
                        
                        inline void getFrame(unsigned int index, Image<T>& frame){
                                if(frame.width() != imageWidth || frame.height() != imageHeight || frame.nbChannel() != imageNbChannel)
                                        throw ImageException("Invalid frame dimensions", "Image3D::setFrame");
                                if(index >= imageDepth)
                                        throw ImageException("index out of bound", "Image3D::setFrame");
                                std::copy(frames[index], frames[index]+frame.size(), frame.begin());
                        } 

                        /*
                         * Building and erasing images
                         */
                private:
                        void buildImageFromBuffer(const size_t width, const size_t height, const size_t depth, const size_t nbChannel, T* buffer, const bool copy=true);

                        void buildImageFromImage(const Image3D<T> & i, const bool copy=true);

                private:
                        void buildEmptyImage(const size_t width, const size_t height, const size_t depth, const size_t nbChannel);

                        void erase();

                };

                /*
                 * Templates definitions
                 */

                /*
                 * Functions definitions
                 */
                template<typename T>
                Image3D<T>::Image3D() {
                        imageWidth = 0;
                        imageHeight = 0;
                        imageDepth = 0;
                        imageNbChannel = 0;
                        imageSize = 0;
                        frames = 0;
                        rows = 0;
                        data = 0;
                        begin_ = 0;
                        end_ = 0;
                        //std::cerr<<"CONSTRUCT VIDE"<<std::endl;
                }

                template<typename T>
                Image3D<T>::Image3D(const size_t width, const size_t height, const size_t depth, const size_t nbChannel, T* buffer) {
                        imageSize = 0;
                        imageWidth = 0;
                        imageHeight = 0;
                        imageDepth = 0;
                        imageNbChannel = 0;
                        imageSize = 0;
                        
                        rows=0;
                        frames = 0;
                        data=0;
                        begin_ = 0;
                        end_ = 0;

                        if (buffer) {
                                buildImageFromBuffer(width,height,depth,nbChannel,buffer);
                        }
                        else {
                                buildEmptyImage(width,height,depth,nbChannel);
                        }
                }

                template<typename T>
                Image3D<T>::Image3D(const Image3D<T> & i) {
                        imageSize = 0;
                        imageSize = 0;
                        imageWidth = 0;
                        imageHeight = 0;
                        imageDepth = 0;
                        imageNbChannel = 0;
                        imageSize = 0;
                        
                        rows=0;
                        frames=0;
                        data=0;
                        begin_ = 0;
                        end_ = 0;

                        buildImageFromImage(i,true);
                }

                template<typename T>
                Image3D<T>::~Image3D() {
                        erase();
                }

                template<typename T>
                void Image3D<T>::initRowsAndFrames() {
                        unsigned int i,j;
                        if(rows) {
                                delete[] rows;
                                rows = 0;
                        }
                        if(frames) {
                                delete[] frames;
                                frames = 0;
                        }
                        
                        frames = new T*[imageDepth*imageHeight];
                        rows = new T**[imageHeight];
                        
                        unsigned int frameDec = imageHeight*imageWidth*imageNbChannel;
                        unsigned int rowDec = imageWidth*imageNbChannel;
                        
                        for (i =0; i <imageHeight; i++) {
                                rows[i] = frames+i*imageDepth;
                                for (j =0; j <imageDepth; j++) {
                                        frames[i*imageDepth+j] = data+j*frameDec+i*rowDec;
                                }
                        }
                }
                
                template<typename T>
                void Image3D<T>::buildImageFromBuffer(const size_t width, const size_t height, const size_t depth, const size_t nbChannel, T* buffer, const bool copy) {
                        if (size()) {
                                throw ImageException("buildImageFromImage","Image already allocated");
                        }
                        imageWidth = width;
                        imageHeight = height;
                        imageDepth = depth;
                        imageNbChannel = nbChannel;
                        imageSize = imageWidth*imageHeight*imageDepth*imageNbChannel;
                        if (copy) {
                                if(data){
                                        delete[] data;
                                        data = 0;
                                }
                                data = new T[size()*sizeof(T)];
                                std::copy(buffer,buffer+size(),data);
                        }
                        else {
                                if(data){
                                        delete[] data;
                                }
                                data = buffer;
                        }
                        initRowsAndFrames();

                        begin_ = data;
                        end_ = data+imageSize;
                }
                
                template<typename T>
                void Image3D<T>::buildImageFromImage(const Image3D<T> & i, const bool copy) {
                        buildImageFromBuffer(i.imageWidth,i.imageHeight,i.imageDepth,i.imageNbChannel,i.begin_,copy);
                }

                template<typename T>
                void Image3D<T>::buildEmptyImage(const size_t width, const size_t height, const size_t depth, const size_t nbChannel) {
                        if(imageSize) {
                                throw ImageException("buildEmptyImage","Image already allocated");                         
                        }                       
                        imageWidth = width;
                        imageHeight = height;
                        imageDepth = depth;
                        imageNbChannel = nbChannel;
                        imageSize = width * height * depth * nbChannel;
            if(data){
                delete[] data;
                data = 0;
            }
                        data = new T[imageSize * sizeof(T)];
                        initRowsAndFrames();

                        begin_ = data;
                        end_ = data+imageSize;
                }
                
                
                template<typename T>
                void Image3D<T>::erase() {
                        imageWidth = 0;
                        imageHeight = 0;
                        imageDepth = 0;
                        imageNbChannel = 0;
                        imageSize = 0;
                        if(data) delete[] data;
                        if(rows) delete[] rows;
                        if(frames) delete[] frames;
                        data = 0;
                        rows = 0;
                        frames = 0;
                        begin_ = 0;
                        end_ = 0;
                }


                template<typename T>
                Image3D<T> & Image3D<T>::operator=(const Image3D &i) {
                        // precaution
                        if(&i == this) return *this;

                        // 0 size image
                        if(this->imageWidth  == 0 && this->imageHeight ==0 && this->imageDepth ==0){
                            buildImageFromImage(i);
                            return *this;
                        }

                        // standard copy
                        if(this->imageWidth  == i.imageWidth  && 
                           this->imageHeight == i.imageHeight &&
                           this->imageDepth == i.imageDepth &&
                           this->imageNbChannel == i.imageNbChannel)
                        std::copy(i.begin_,i.end_,this->begin_);
                        else throw ImageException("operator=","incompatible image size");

                        return *this;
                }
                
                

                /*
                 * End of Namespace
                 */
        }

/*
 * End of Anti-doublon
 */
#endif

---