The Machine Perception Toolbox

[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

integralimage.h

Go to the documentation of this file.

#ifndef _INTEGRALIMAGE_H_
#define _INTEGRALIMAGE_H_

#include <iostream>
#include <fstream>

#ifndef ASSERT
#ifdef _DEBUG
#include <assert.h>
#define ASSERT(x) assert(x)
#else
#define ASSERT(x) 
#endif
#endif

/* ================================================================ */

template <class T>
class TImage 
{
protected:
        T *array;
        int width;
        int height;
        int numpixels;
        int my_memory;

public: 
        TImage (const T *array, const int, const int);
        TImage (const int, const int);
        TImage (const int, const int, T);
        TImage (const TImage &other){
                width = other.width;
                height = other.height;
                numpixels = other.numpixels;
                array = other.array;
        }
        TImage (){};
        inline void setSize(const int width_, const int height_){
                width = width_;
                height = height_;
                numpixels = width * height;
                array = new T[numpixels];
                memset(array,0,sizeof(T)*numpixels);
                my_memory = 1;
        }
        inline void deleteArray(){
                delete [] array;
        }
        
        virtual ~TImage ( );
        
        virtual T* getArray(){return array;}
        
        void print ( ) const;
        void print ( const int m ) const;
};

/* ================================================================ */

template <class T>
inline TImage<T>::TImage (const T *array_, const int width_, const int height_ )
{
        width = width_;
        height = height_;
        numpixels = width * height;
        array = const_cast<T *>(array_);
        my_memory = 0;
}

/* ================================================================ */

template <class T>
inline TImage<T>::TImage ( const int width_, const int height_ )
{
        setSize(width_,height_);
}

/* ================================================================ */

template <class T>
inline TImage<T>::TImage ( const int width_, const int height_ , const T val)
{
        setSize(width_,height_);
        T *ptr = array;
        for(int y=0; y <height_; y++)
                for(int x=0; x <width_; x++)    
                        *(ptr++) = val; 
}

/* ================================================================ */

template <class T>
inline TImage<T>::~TImage ()
{
        if(my_memory)
                delete [] array;
}

/* ================================================================ */

template <class T>
void TImage<T>::print ( ) const 
{
        for(int y = 0; y < height; y++) {
                for(int x = 0; x < width; x++) {
                        cout << getPixel(x,y) << " ";
                }
                cout << endl;
        }
}

/* ================================================================ */

template <class T>
void TImage<T>::print ( const int m ) const 
{
        for(int y = 0; y < min(m,height); y++) {
                for(int x = 0; x < min(m,width); x++) {
                        cout << getPixel(x,y) << " ";
                }
                cout << endl;
        }
}

/* ================================================================ */

template <class T>
class TIntegral : public TImage<T>
{
        
public:
        const int getImWidth() const {return width -1;  }
        const int getImHeight() const {return height -1;        }
        const int getIntWidth() const {return width;    }
        const int getIntHeight() const {return height;  }
        
        const int getImNumPix() const { return getImWidth()*getImHeight();}
        const int getIntNumPix() const { return getIntWidth()*getIntHeight();}
        
        
        TIntegral(const int width, const int height){
                setSize(width,height);
        }
  void setSize(const int width, const int height){
    TImage<T>::setSize(width+1,height+1);
        }
        TIntegral() : TImage<T>() {
        }

        /* integrate in place */
        void integrate() { 
                int x, y;
                T * p = array;
//              for(int x = 0; x < width; ++x) setIntPixel(x,0,0);   /* create top row of zeros */
//              for(int y = 0; y < width; ++y) setIntPixel(0,y,0);   /* create left column of zeros */

                for(x = 1; x < width; ++x) {
                        double v0 = getIntPixel(x-1,0);
                        double v1 = getIntPixel(x,0);
                        setIntPixel(x,0,v0+v1);   /* integrate top row */
                }

                for(y = 1; y < height; ++y) {
                        double v0 = getIntPixel(0,y-1);
                        double v1 = getIntPixel(0,y);
                        setIntPixel(0,y,v0+v1);   /* create left column of zeros */
    }

                for(y = 1; y < height; ++y){
                        for(x = 1; x < width; ++x){
                                T val = getIntPixel(x,y) + getIntPixel(x-1, y) +
                                        getIntPixel(x, y-1) - getIntPixel(x-1, y-1);
                          setIntPixel(x,y,val);
                        }
                }
        }
        
        inline  T getIntPixel (int x, int y) const{
                int lx = x, ly = y;
                if(lx < 0 || ly < 0) return 0;
                
                if(lx >= width) lx = width - 1;
                if(ly >= height) ly = height - 1;
                
                int index = width * ly + lx;
                ASSERT (index >= 0 && index < numpixels);
                return array[index];
        };
        
        
        inline  void setIntPixel ( const int x, const int y, const T &value )
        {
                int lx = x, ly = y;
                
                ASSERT( lx >= 0 && ly >=0 && lx < width && ly < height); 
                if (lx < 0) lx = 0;
                if (ly < 0) ly = 0;
                if(lx >= width) lx = width - 1;
                if(ly >= height) ly = height - 1;

                int index = width * ly + lx;
                ASSERT (index >= 0 && index < numpixels);
                array[index] = value;
                
        }
        inline  T getImPixel (int x, int y) const{
                return getIntPixel(x+1,y+1);
        };
        
        
        inline  void setImPixel ( const int x, const int y, const T &value )
        {
                setIntPixel(x+1,y+1,value);
        };
        
        void printIm(const char *filename) {
                FILE *fid = fopen(filename, "w");
                int z= 12003;
                for (int y = 0; y < getImHeight(); y++) {
                        for (int x = 0; x < getImWidth(); x++)
                                fprintf(fid, "%g\t", getImPixel(x, y));
                        fprintf(fid, "\n");
                }
                fclose(fid);
        }

        void printInt(const char *filename) {
                FILE *fid = fopen(filename, "w");
                for (int y = 0; y < getIntHeight(); y++) {
                        for (int x = 0; x < getIntWidth(); x++)
                                fprintf(fid, "%g\t", getIntPixel(x, y));
                        fprintf(fid, "\n");
                }
                fclose(fid);
        }

        void printImBin(const char *filename, bool flag) {
                std::ofstream os(filename, ios::binary | ios::app);
                if (flag) {
                        os.flags(ios::binary);
                        int width = getImWidth();
                        int height = getImHeight();
                        os.write((char *)&width, sizeof(width));
                        os.write((char *)&height, sizeof(height));
                }
                for (int y = 0; y < getImHeight(); y++) {
                        for (int x = 0; x < getImWidth(); x++) {
                                T val = (T)(getImPixel(x, y));
                                os.write((char *)&val, sizeof(val));
                        }
                }
                os.close();
        }

        void printIntBin(const char *filename, bool flag) {
                std::ofstream os(filename, ios::binary | ios::app);
                if (flag) {
                        os.flags(ios::binary);
                        int width = getIntWidth();
                        int height = getIntHeight();
                        os.write((char *)&width, sizeof(width));
                        os.write((char *)&height, sizeof(height));
                }
                for (int y = 0; y < getIntHeight(); y++) {
                        for (int x = 0; x < getIntWidth(); x++) {
                                T val = (T)(getIntPixel(x, y));
                                os.write((char *)&val, sizeof(val));
                        }
                }
                os.close();
        }

        void setToMinLog () {
          static TImage<T> cache(getIntWidth(), getIntHeight(), -1000);
                T *ptr = array;
                memcpy(ptr, cache.getArray(), sizeof(T)*getIntNumPix());
        }

};

/* ================================================================ */

#endif  _INTEGRALIMAGE_H_

---