gilImageBase.h

Go to the documentation of this file.

//
// Generic Image Library
// Yung-Yu Chaung, 2003
//

#ifndef __GIL_IMAGE_BASE_H__
#define __GIL_IMAGE_BASE_H__

#include <map>
#include <string>

using std::map;
using std::string;

namespace Gil{

template <typename Type> class PixelPtr {
    private:
        Type* pixel;
        int channel;
    public:
        inline PixelPtr(void){
                pixel = NULL;
                channel = c;
        }
        inline PixelPtr(Type* p, int c){
            pixel = p;
            channel = c;
        }
        inline PixelPtr(const PixelPtr<Type>& ptr){
            pixel = ptr.pixel;
            channel = ptr.channel;
        }

        inline bool operator ==(const PixelPtr<Type>& ptr){
            return pixel == ptr.pixel;
        }

        inline bool operator !=(const PixelPtr<Type>& ptr){
            return pixel != ptr.pixel;
        }

        inline PixelPtr<Type> operator =(const PixelPtr<Type>& ptr){
            pixel = ptr.pixel;
            channel = ptr.channel;
            return *this;
        }

        inline Type& operator [](int i){
            return pixel[i];
        }

        inline PixelPtr<Type>& operator ++(void){ // ++ptr
            pixel += channel;
            return *this;
        }

        inline PixelPtr<Type> operator ++(int){ // ptr++
            PixelPtr<Type> tmp(pixel, channel);
            pixel += channel;
            return tmp;
        }
        
        inline PixelPtr<Type>& operator --(void){ // --ptr
            pixel -= channel;
            return *this;
        }

        inline PixelPtr<Type> operator --(int){ // ptr--
            PixelPtr<Type> tmp(pixel, channel);
            pixel -= channel;
            return tmp;
        }

        inline void assign(const PixelPtr<Type>& ptr){
            for(int i=0; i<channel; i++)
                pixel[i] = ptr.pixel[i];
        }

};
    
template <typename Type> class ImageBase {
    private:
        // member variables
        int  m_nWidth;
        int  m_nHeight;
        int  m_nChannels;
        Type *m_pBuffer;
        Type **m_pRow;
        int  m_nPitch;
        int  m_nSaveQuality;

        map<string, string> m_comments;

        // member functions
        void init_rowp();

        void read_comments();
        void write_comments();

    public:
        ImageBase(void);
        
        ImageBase(int w, int h, int c);
        
        ImageBase(const ImageBase<Type> &image);
        ~ImageBase(void);
        
        inline int width(void) const{ return m_nWidth;}

        inline int height(void) const { return m_nHeight; }

        inline int channels(void) const { return m_nChannels; }

        inline int elements(void) const { return m_nWidth*m_nHeight*m_nChannels; }

        inline int pitch(void) const { return m_nPitch; }

        inline Type* data(void) { return m_pBuffer; }

        inline Type* rowp(int r){ return m_pRow[r]; }

        void allocate(int w, int h, int c);

        void allocate(const ImageBase<Type> &image){ 
            allocate(image.width(), image.height(), image.channels());
        }
        
        void fillPixels(Type value);

        void copyPixelsTo(ImageBase<Type> &dst);

        inline PixelPtr<Type> getPixelPtr(int x, int y){
            return PixelPtr<Type>(m_pRow[y]+m_nChannels*x, m_nChannels);
        }
        
        inline PixelPtr<Type> begin(void){
            return PixelPtr<Type>(m_pBuffer, m_nChannels);
        }
        
        inline PixelPtr<Type> end(void){
            return PixelPtr<Type>(m_pRow[m_nHeight-1]+m_nPitch, m_nChannels);
        }

        inline Type& pixel(int x, int y, int channel=0){
            return m_pRow[y][m_nChannels*x+channel];
        }

        inline bool inBounds(int x, int y){
            return x>=0 && x<m_nWidth && y>=0 && y<m_nHeight;
        }

        void reverseRows();

        bool readFile(const char* filename);

        bool writeFile(const char* filename);

        ImageBase<Type>* subImage(int x, int y, int w, int h);
        void cropImage(int x, int y, int w, int h);

        inline void setSaveQuality(int q) { m_nSaveQuality=q; }

        inline int getNumComments() { return (int)(m_comments.size()); }
        void printComments();
        void addComment(string key, string text);
        string getComment(string key);
        void getOriginalSize(int &w, int &h);
        void getOriginalPos(int &x, int &y);
};

// instantiation
template class ImageBase<unsigned char>;
template class ImageBase<float>;
// alias
typedef PixelPtr<unsigned char> BytePixelPtr;
typedef PixelPtr<float> FloatPixelPtr;
typedef ImageBase<unsigned char> ByteImage;
typedef ImageBase<float> FloatImage;


} // namespace Gil

#endif // __IMAGE_BASE_H__

---