iAbstractImage.h

Go to the documentation of this file.

/*
imagen - Simple object-oriented imaging library
Copyright (C) 2011-2012 Mark D. Procarione

imagen 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.

imagen 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 General Public License for more details.
*/

#ifndef __IABSTRACTIMAGE_H__
#define __IABSTRACTIMAGE_H__

#include "imagen.h"

#include "iPalette.h"
#include "iColor.h"
#include "iDateTime.h"
#include "iDataStream.h"

namespace imagen
{
    class iSharedData
    {
        public:

            iSharedData();


            iSharedData( const iSharedData &d );


            iSharedData( Iubyte *d, int length );

            iSharedData( int length );

            ~iSharedData();

            void attach();


            void detach();


            iSharedData *unalias();

        public:
            Iubyte *data; 
            int len;      

        private:
            int refCount;
            bool delData;
    };

    class iAbstractImage;

    typedef void (*iReadCallback)( int numRows, int curRow, Iubyte *data );
    typedef void (*iWriteCallback)( int numRows, int curRow );


    class iAbstractImage
    {
        public:
            iAbstractImage();


            iAbstractImage( const iAbstractImage &img );


            iAbstractImage( int w, int h, iImageFormat f );


            iAbstractImage( Iubyte *d, int w, int h, iImageFormat f, int b );


            virtual ~iAbstractImage();


            bool load( const char *filename );


            bool load( Iubyte *buf, int len );


            bool load( iDataStream *s );


            bool save( const char *filename );


           bool save( Iubyte *buf, int len );


            bool save( iDataStream *s );


            void loadData( Iubyte *d, int w, int h, iImageFormat f, int b );

            virtual void clear();


            void detachData();

            void flipVertical();

            void flipHorizontal();


            void rotateLeft();


            void rotateRight();

            void rotate180();

            void fill( const iColor &col );


            bool pad( int top, int left, int bottom, int right, iWrapMode mode );


            bool resize( int w, int h, int x, int y );

            void swapRGB();


            void convertFormat( iImageFormat fmt, int alpha = 255 );

            int imageSize() const { return width*height*bpp; }

            bool isNull() const;


            virtual bool isFormatSupported( iImageFormat fmt ) const = 0;

            Iubyte *getData() { return data->data; }

            const Iubyte *getData() const { return data->data; }

            int getWidth() const { return width; }

            int getHeight() const { return height; }

            iImageFormat getFormat() const { return format; }

            int getBpp() const { return bpp; }

            iImageType getType() const { return type; }

            void setXOffset( int x ) { xoffset = x; }

            void setYOffset( int y ) { yoffset = y; }

            int getXOffset() const { return xoffset; }

            int getYOffset() const { return yoffset; }

            void setUnitType( iUnitType unit ) { unitType = unit; }

            iUnitType getUnitType() const { return unitType; }

            void setXRes( int x ) { XResolution = x; }

            void setYRes( int y ) { YResolution = y; }

            int getXRes() const { return XResolution; }

            int getYRes() const { return YResolution; }

            void setOrigin( iImageOrigin org ) { origin = org; }

            iImageOrigin getOrigin() const { return origin; }

            void setWriteOrigin( iImageOrigin org ) { worigin = org; }

            iImageOrigin getWriteOrigin() const { return worigin; }

            void setCreationTime( const iDateTime &dt ) { createTime = dt; }

            iDateTime getCreationTime() const { return createTime; }


            void updateCreationTime( bool bup ) { updateTime = bup; }

            void setJobTime( const iJobTime &jt ) { jobTime = jt; }

            iJobTime getJobTime() const { return jobTime; }

            void setAuthor( const char *name ) { author = name; }

            const char *getAuthor() const { return author; }

            void setComment( const char *comm ) { comment = comm; }

            const char *getComment() const { return comment; }


            void setClearCol( iColor col ) { clrcol = col; }

            iColor getClearCol() const { return clrcol; }

            bool hasPalette() const;

            iPalette setPalette( const iPalette &pal ) { palette = pal; }

            iPalette getPalette() const { return palette; }

            bool hasAlpha() const;

            iColor getPixel( int x, int y ) const;

            iColor getPixel( int index ) const;

            void setPixel( int x, int y, const iColor &col );

            void setPixel( int index, const iColor &col );

            int getPixelIndex( int x, int y ) const;

            void setReadFunc( iReadCallback func ) { readFunc = func; }

            void setWriteFunc( iWriteCallback func ) { writeFunc = func; }

            iAbstractImage &operator=( const iAbstractImage &img );

        protected:
            void init();
            virtual bool loadImage() = 0;
            virtual bool saveImage() = 0;

        protected:
            iSharedData *data;   
            int width;           
            int height;          
            iImageFormat format; 
            int bpp;             

            int xoffset;         
            int yoffset;         

            iColor clrcol;       

            iImageType type;     
            iImageOrigin origin; 
            iImageOrigin worigin;
            iPalette palette;    

            iUnitType unitType;  
            int XResolution;     
            int YResolution;     

            iDateTime createTime; 
            bool updateTime;      

            iJobTime jobTime;    

            const char *author;  
            const char *comment; 

            iDataStream *stream; 

            iReadCallback readFunc;   
            iWriteCallback writeFunc; 
    };
}

#endif // __IABSTRACTIMAGE_H__