Home Research Papers Posters Manuals Talks Download People Help Wiki Internal

util/ckimage.h

Go to the documentation of this file.

/*
2D flat image class:
This class represents a 2D raster image; a rectangular 2D
array of pixels.

Orion Sky Lawlor, olawlor@acm.org, 5/15/2002
*/
#ifndef __CK_IMAGE_H
#define __CK_IMAGE_H

#include "pup.h"

#undef min
#undef max
inline int min(int a,int b) {return (a<b)?a:b;}
inline int max(int a,int b) {return (a>b)?a:b;}
class CkRect {
public:
        int l,r; //X boundaries of rectangle
        int t,b; //Y boundaries of rectangle
        CkRect() {l=r=t=b=-1;}
        CkRect(int l_,int t_,int r_,int b_) 
                :l(l_), r(r_), t(t_), b(b_) {}
        CkRect(int w,int h)
                :l(0), r(w), t(0), b(h) {}
        //Default copy constructor, assignment operator
        int wid(void) const {return r-l;}
        int ht(void) const {return b-t;}
        int getWidth(void) const {return r-l;}
        int getHeight(void) const {return b-t;}
        inline int operator==(const CkRect &a) 
                {return l==a.l && r==a.r && t==a.t && b==a.b;}
        CkRect getUnion(const CkRect &a) {
                return CkRect(min(l,a.l),min(t,a.t), max(r,a.r),max(b,a.b));
        }
        CkRect getIntersect(const CkRect &a) {
                return CkRect(max(l,a.l),max(t,a.t), min(r,a.r),min(b,a.b));
        }
        CkRect getShift(int dx,int dy) {
                return CkRect(l+dx,t+dy,r+dx,b+dy);
        }
        CmiBool isEmpty(void) const {return (CmiBool)((l>=r) || (t>=b));}
        CmiBool inbounds(int x,int y) const {
                if (x<l || x>=r) return CmiFalse;
                if (y<t || y>=b) return CmiFalse;
                return CmiTrue;
        }
        void makeEmpty(void) {l=t=1000000000; b=r=-1000000000;}
        void empty(void) {makeEmpty();}
        void add(int x,int y) {
                l=min(x,l); r=max(x,r);
                t=min(y,t); b=max(y,b);
        }
        void enlarge(int dx,int dy) {
                l-=dx; r+=dx; t-=dy; b+=dy;
        }
        void zero(void) {l=r=t=b=0;}
        int area(void) const {return (r-l)*(b-t);}
        
        void pup(PUP::er &p) {
                p|l; p|r; p|t; p|b;
        }
};
PUPmarshall(CkRect);

class CkImage {
public:
        //This is the data type of a color channel, such as the red channel.
        typedef unsigned char channel_t;
        enum {channel_max=255};
        
        typedef enum {
                layout_default=0,
                layout_reversed=1
        } layout_t;
private:
        int row,colors; 
        int layout; 
        int wid,ht; 
        channel_t *data; 
        
        CkImage(const CkImage &im) ; 
        void operator=(const CkImage &im);
public:
        CkImage() {row=colors=wid=ht=-1; setLayout(layout_default); data=NULL;}
        CkImage(int w_,int h_,int colors_,channel_t *data_)
                :row(w_*colors_), colors(colors_),
                wid(w_), ht(h_), data(data_) { setLayout(layout_default); }
        
        channel_t *getData(void) {return data;}
        void setData(channel_t *d) {data=d;}
        
        CkRect getRect(void) const {return CkRect(0,0,wid,ht);}
        int getRow(void) const {return row;}
        int getColors(void) const {return colors;}
        
        layout_t getLayout(void) const {return (layout_t)layout;}
        void setLayout(layout_t a) {layout=(layout_t)a;}
        
        int getWidth(void) const {return wid;}
        int getHeight(void) const {return ht;}
        
        //Copy the pixel at src onto the one at dest
        inline void copyPixel(const channel_t *src,channel_t *dest) {
                for (int i=0;i<colors;i++)
                        dest[i]=src[i];
        }
        //Set this pixel to this value
        inline void setPixel(const channel_t src,channel_t *dest) {
                for (int i=0;i<colors;i++)
                        dest[i]=src;
        }
        //Add the pixel at src to the one at dest, ignoring overflow
        inline void addPixel(const channel_t *src,channel_t *dest) {
                for (int i=0;i<colors;i++)
                        dest[i]+=src[i];
        }
        //Add the pixel at src to the one at dest, clipping instead of overflowing
        inline void addPixelClip(const channel_t *src,channel_t *dest,
                const channel_t *clip) 
        {
                for (int i=0;i<colors;i++)
                        dest[i]=clip[(int)dest[i]+(int)src[i]];
        }
        
        
        //Get a pixel
        inline channel_t *getPixel(int x,int y) {return data+x*colors+y*row;}
        inline const channel_t *getPixel(int x,int y) const {return data+x*colors+y*row;}
        
        
        /*
         Clip out this subregion of this image-- make us a subregion
         */
        void window(const CkRect &src) {
                data+=src.t*row+src.l*colors;
                wid=src.wid(); ht=src.ht();
        }
        
        /*
        Zero out this image-- make it all black.
        */
        void clear(void);
        
        /*
         Copy all of src onto this image starting at (x,y).
         */
        void put(int sx,int sy,const CkImage &src); 
        
        /*
         Add all of src onto this image starting at (x,y).
         */
        void add(int sx,int sy,const CkImage &src);
        /*
         Add all of src onto this image starting at (x,y), clipping
         values instead of overflowing.
         */
        void addClip(int sx,int sy,const CkImage &src,const channel_t *clip);
        
        //Allocate clipping array for above routine
        static channel_t *newClip(void);
        
        //Pup only the image *size*, not the image *data*.
        void pup(PUP::er &p) {
                p|wid; p|ht; p|colors; p|layout; p|row;
        }
};
PUPmarshall(CkImage);


//A heap-allocated image
class CkAllocImage : public CkImage {
        channel_t *allocData;
public:
        CkAllocImage() {allocData=NULL;}
        CkAllocImage(int w,int h,int c)
                :CkImage(w,h,c,new channel_t[w*h*c]) 
        {
                allocData=getData();
        }
        ~CkAllocImage() {delete[] allocData;}
        
        // Allocate the image with its current size.
        void allocate(void) {
                int len=getRect().area()*getColors();
                allocData=new channel_t[len];
                setData(allocData);
        }
        
        // Deallocate the image data (does not change size).
        void deallocate(void) {
                delete[] allocData; allocData=0;
                setData(allocData);
        }
        
        //Pup both image size as well as image data.
        void pup(PUP::er &p);
};
PUPmarshall(CkAllocImage);


#endif

---