/home/fayn/OpenKraken-dev/OpenKN-image/src/Image.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__IMAGE_HPP__
#define __OPENKN_IMAGE__IMAGE_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"

/*
 * Namespace
 */
namespace kn{
        
                /*
                 * Class definition
                 */

                template<typename T>
                class Image {

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

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

                        Image(const Image<T> & i);

                        virtual ~Image();

                        friend int kn::loadPPM(Image<unsigned char>& res,const std::string& filename);
                        friend int kn::loadTGA(Image<unsigned char>& res,const std::string& filename);
                        friend int kn::loadJPG(Image<unsigned char>& res,const std::string& filename);
                        friend int kn::loadHDR(Image<float>& res,const std::string& filename);

                protected :
                        T * data;

                        T ** rows;

                        void initRows();

                        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 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 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 {
                                return (rows[y]+x*nbChannel());
                        }

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

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

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

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

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


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


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


                        inline void flip() {
                           for(unsigned int i=0; i<imageHeight/2; i++)
                             std::swap_ranges(rows[i],rows[i+1],rows[imageHeight-i-1]);
                        }

                        inline void flop() {
                          for(unsigned int i=0; i<imageHeight; i++)
                            for(unsigned int j=0; j<imageWidth/2; j++)
                              for(unsigned int c=0; c<imageNbChannel;c++)
                                std::swap(rows[i][imageNbChannel*j+c],rows[i][imageNbChannel*(imageWidth-j-1)+c]);
                        }

                        inline void rotate() {
                          T* buffer = new T[size()*sizeof(T)];
                          T* b = buffer;
                            for(int j=imageWidth-1, d=(imageWidth-1)*imageNbChannel; j>=0; j--,d-=imageNbChannel)
                              for(unsigned int i=0; i<imageHeight; i++)
                                for(unsigned int c=0; c<imageNbChannel;c++,b++)
                                  *b = rows[i][d+c];
                          imageSize = 0;
                          buildImageFromBuffer(imageHeight, imageWidth, imageNbChannel, buffer, false);
                        }

                        inline void rotateInverse() {
                          T* buffer = new T[size()*sizeof(T)];
                          T* b = buffer;
                            for(unsigned int j=0, d=0; j<imageWidth; j++,d+=imageNbChannel)
                              for(int i=imageHeight-1; i>=0; i--)
                                for(unsigned int c=0; c<imageNbChannel;c++,b++)
                                  *b = rows[i][d+c];
                                imageSize = 0;
                                buildImageFromBuffer(imageHeight, imageWidth, imageNbChannel, buffer, false);
                        }

                        
                        void getSubImage(unsigned int x, unsigned int y, Image<T>& sub)const;

                        void setSubImage(unsigned int x, unsigned int y, const Image<T>& sub);


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

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

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

                        void erase();

                };

                /*
                 * Templates definitions
                 */

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

                template<typename T>
                Image<T>::Image(const size_t w, const size_t h, const size_t d,  T* buffer) {
                        imageSize = 0;
                        imageWidth = 0;
                        imageHeight = 0;
                        imageNbChannel = 0;
                        imageSize = 0;
                        
                        rows=0;
                        data=0;
                        begin_ = 0;
                        end_ = 0;

                        if (buffer) {
                                buildImageFromBuffer(w,h,d,buffer);
                        }
                        else {
                                buildEmptyImage(w,h,d);
                        }
                }

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

                        buildImageFromImage(i,true);
                }

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

                template<typename T>
                void Image<T>::initRows() {
                        unsigned int i;
                        if(rows) {
                                delete[] rows;
                                rows = 0;
                        }
                        rows = new T*[imageHeight];
                        for (i =0; i <imageHeight; i++) {
                                rows[i] = (data+(i*imageWidth*imageNbChannel));
                        }
                }
                
                template<typename T>
                void Image<T>::buildImageFromBuffer(const size_t width, const size_t height,
                                                    const size_t nbChannel, T* buffer, const bool copy) {
                        if (size()) {
                                throw ImageException("buildImageFromImage","Image already allocated");
                        }
                        imageWidth = width;
                        imageHeight = height;
                        if (imageNbChannel == 0) imageNbChannel = nbChannel;
                        imageSize = imageWidth*imageHeight*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;
                        }
                        initRows();

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

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

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


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

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

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

                        return *this;
                }
                
                template<typename T>
                void Image<T>::getSubImage(unsigned int x, unsigned int y, Image<T>& sub)const{
                        if(sub.imageNbChannel != imageNbChannel)
                                throw ImageException("incompatible nb channel","Image<T>::getSubImage");
                        if(sub.imageWidth+x > imageWidth || sub.imageHeight+y > imageHeight)
                                throw ImageException("incompatible dimensions","Image<T>::getSubImage");
                        unsigned int dx = x*imageNbChannel;
                        unsigned int s = sub.imageWidth*imageNbChannel;
                        for(unsigned int j = 0; j < sub.imageNbChannel; j++)
                                std::copy(rows[j+y]+dx,rows[j+y]+dx+s, sub.rows[j]);
                }
                
                
                template<typename T>
                void  Image<T>::setSubImage(unsigned int x, unsigned int y, const Image<T>& sub){
                        if(sub.imageNbChannel != imageNbChannel)
                                throw ImageException("incompatible nb channel","Image<T>::setSubImage");
                        if(sub.imageWidth+x > imageWidth || sub.imageHeight+y > imageHeight)
                                throw ImageException("incompatible dimensions","Image<T>::setSubImage");
                        unsigned int dx = x*imageNbChannel;
                        unsigned int s = sub.imageWidth*imageNbChannel;
                        for(unsigned int j = 0; j < sub.imageNbChannel; j++)
                                std::copy(sub.rows[j],sub.rows[j]+s,rows[j+y]+dx);
                }

                /*
                 * End of Namespace
                 */
        }

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

---