FreeImagePlus.h

// ==========================================================
// FreeImagePlus 3
//
// Design and implementation by
// - Hervé Drolon (drolon@infonie.fr)
//
// This file is part of FreeImage 3
//
// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================

#ifndef FREEIMAGEPLUS_H
#define FREEIMAGEPLUS_H

#ifdef _WIN32
#include <windows.h>
#endif // _WIN32
#include "FreeImage.h"


// Compiler options ---------------------------------------------------------

#if defined(FREEIMAGE_LIB)
        #define FIP_API
        #define FIP_CALLCONV
#else
        #if defined(_WIN32) || defined(__WIN32__)
                #define WIN32_LEAN_AND_MEAN
                #define FIP_CALLCONV __stdcall
                // The following ifdef block is the standard way of creating macros which make exporting 
                // from a DLL simpler. All files within this DLL are compiled with the FIP_EXPORTS
                // symbol defined on the command line. this symbol should not be defined on any project
                // that uses this DLL. This way any other project whose source files include this file see 
                // FIP_API functions as being imported from a DLL, wheras this DLL sees symbols
                // defined with this macro as being exported.
                #ifdef FIP_EXPORTS
                        #define FIP_API __declspec(dllexport)
                #else
                        #define FIP_API __declspec(dllimport)
                #endif // FIP_EXPORTS
        #else
                // try the gcc visibility support (see http://gcc.gnu.org/wiki/Visibility)
                #if defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
                        #ifndef GCC_HASCLASSVISIBILITY
                                #define GCC_HASCLASSVISIBILITY
                        #endif
                #endif  
                #define FIP_CALLCONV
                #if defined(GCC_HASCLASSVISIBILITY)
                        #define FIP_API __attribute__ ((visibility("default")))
                #else
                        #define FIP_API
                #endif
        #endif // WIN32 / !WIN32
#endif // FREEIMAGE_LIB


// ----------------------------------------------------------

class FIP_API fipObject
{
public:
        virtual ~fipObject(){};
        
        virtual BOOL isValid() const = 0;
};

// ----------------------------------------------------------

class fipMemoryIO;
class fipMultiPage;
class fipTag;

class FIP_API fipImage : public fipObject
{
protected:
        FIBITMAP *_dib;
        FREE_IMAGE_FORMAT _fif;
        mutable BOOL _bHasChanged;

public:
        friend class fipMultiPage;

public:

        fipImage(FREE_IMAGE_TYPE image_type = FIT_BITMAP, unsigned width = 0, unsigned height = 0, unsigned bpp = 0);
        virtual ~fipImage();
        BOOL setSize(FREE_IMAGE_TYPE image_type, unsigned width, unsigned height, unsigned bpp, unsigned red_mask = 0, unsigned green_mask = 0, unsigned blue_mask = 0);
        virtual void clear();

        fipImage(const fipImage& src);
        fipImage& operator=(const fipImage& src);
        fipImage& operator=(FIBITMAP *dib);


        BOOL copySubImage(fipImage& dst, int left, int top, int right, int bottom) const;

        BOOL pasteSubImage(fipImage& src, int left, int top, int alpha = 256);

        BOOL crop(int left, int top, int right, int bottom);

        BOOL createView(fipImage& dynamicView, unsigned left, unsigned top, unsigned right, unsigned bottom);


        static FREE_IMAGE_FORMAT identifyFIF(const char* lpszPathName);

        static FREE_IMAGE_FORMAT identifyFIFU(const wchar_t* lpszPathName);

        static FREE_IMAGE_FORMAT identifyFIFFromHandle(FreeImageIO *io, fi_handle handle);

        static FREE_IMAGE_FORMAT identifyFIFFromMemory(FIMEMORY *hmem);



        BOOL load(const char* lpszPathName, int flag = 0);

        BOOL load(FREE_IMAGE_FORMAT fif, const char* lpszPathName, int flag = 0);

        BOOL loadU(const wchar_t* lpszPathName, int flag = 0);

        BOOL loadU(FREE_IMAGE_FORMAT fif, const wchar_t* lpszPathName, int flag = 0);

        BOOL loadFromHandle(FreeImageIO *io, fi_handle handle, int flag = 0);

        BOOL loadFromMemory(fipMemoryIO& memIO, int flag = 0);

        BOOL loadFromMemory(FREE_IMAGE_FORMAT fif, fipMemoryIO& memIO, int flag = 0);

        BOOL save(const char* lpszPathName, int flag = 0);

        BOOL save(FREE_IMAGE_FORMAT fif, const char* lpszPathName, int flag = 0);

        BOOL saveU(const wchar_t* lpszPathName, int flag = 0);

        BOOL saveU(FREE_IMAGE_FORMAT fif, const wchar_t* lpszPathName, int flag = 0);

        BOOL saveToHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flag = 0);

        BOOL saveToMemory(FREE_IMAGE_FORMAT fif, fipMemoryIO& memIO, int flag = 0);



        FREE_IMAGE_TYPE getImageType() const;

        FREE_IMAGE_FORMAT getFIF() const;

        unsigned getWidth() const;
        
        unsigned getHeight() const;
        
        unsigned getScanWidth() const;

        operator FIBITMAP*() { 
                return _dib; 
        }

        BOOL isValid() const;

        const BITMAPINFO* getInfo() const;

    const BITMAPINFOHEADER* getInfoHeader() const;

        unsigned getImageSize() const;

        unsigned getImageMemorySize() const;
        
        unsigned getBitsPerPixel() const;

        unsigned getLine() const;

        double getHorizontalResolution() const;
        
        double getVerticalResolution() const;

        void setHorizontalResolution(double value);
        
        void setVerticalResolution(double value);


        RGBQUAD* getPalette() const;
        
        unsigned getPaletteSize() const;

        unsigned getColorsUsed() const;

        FREE_IMAGE_COLOR_TYPE getColorType() const;

        BOOL isGrayscale() const;


        BOOL getThumbnail(fipImage& image) const;

        BOOL setThumbnail(const fipImage& image);

        BOOL hasThumbnail() const;

        BOOL clearThumbnail();



        BYTE* accessPixels() const;

        BYTE* getScanLine(unsigned scanline) const;

        BOOL getPixelIndex(unsigned x, unsigned y, BYTE *value) const;

        BOOL getPixelColor(unsigned x, unsigned y, RGBQUAD *value) const;

        BOOL setPixelIndex(unsigned x, unsigned y, BYTE *value);

        BOOL setPixelColor(unsigned x, unsigned y, RGBQUAD *value);


        BOOL convertToType(FREE_IMAGE_TYPE image_type, BOOL scale_linear = TRUE);

        BOOL threshold(BYTE T);
        
        BOOL dither(FREE_IMAGE_DITHER algorithm);

        BOOL convertTo4Bits();

        BOOL convertTo8Bits();

        BOOL convertToGrayscale();
        
        BOOL colorQuantize(FREE_IMAGE_QUANTIZE algorithm);

        BOOL convertTo16Bits555();
        
        BOOL convertTo16Bits565();
        
        BOOL convertTo24Bits();
        
        BOOL convertTo32Bits();

        BOOL convertToFloat();

        BOOL convertToRGBF();

        BOOL convertToRGBAF();

        BOOL convertToUINT16();

        BOOL convertToRGB16();

        BOOL convertToRGBA16();

        BOOL toneMapping(FREE_IMAGE_TMO tmo, double first_param = 0, double second_param = 0, double third_param = 1, double fourth_param = 0);



        BOOL isTransparent() const;

        unsigned getTransparencyCount() const;

        BYTE* getTransparencyTable() const;

        void setTransparencyTable(BYTE *table, int count);

        BOOL hasFileBkColor() const;

        BOOL getFileBkColor(RGBQUAD *bkcolor) const;

        BOOL setFileBkColor(RGBQUAD *bkcolor);

        BOOL getChannel(fipImage& image, FREE_IMAGE_COLOR_CHANNEL channel) const;

        BOOL setChannel(fipImage& image, FREE_IMAGE_COLOR_CHANNEL channel);

        BOOL splitChannels(fipImage& RedChannel, fipImage& GreenChannel, fipImage& BlueChannel);

        BOOL combineChannels(fipImage& red, fipImage& green, fipImage& blue);

        BOOL rotateEx(double angle, double x_shift, double y_shift, double x_origin, double y_origin, BOOL use_mask);

        BOOL rotate(double angle, const void *bkcolor = NULL);

        BOOL flipHorizontal();

        BOOL flipVertical();

        BOOL invert();
        
        BOOL adjustCurve(BYTE *LUT, FREE_IMAGE_COLOR_CHANNEL channel);

        BOOL adjustGamma(double gamma);

        BOOL adjustBrightness(double percentage);

        BOOL adjustContrast(double percentage);

        BOOL adjustBrightnessContrastGamma(double brightness, double contrast, double gamma);

        BOOL getHistogram(DWORD *histo, FREE_IMAGE_COLOR_CHANNEL channel = FICC_BLACK) const;


        BOOL rescale(unsigned new_width, unsigned new_height, FREE_IMAGE_FILTER filter);

        BOOL makeThumbnail(unsigned max_size, BOOL convert = TRUE);

        void setModified(BOOL bStatus = TRUE) {
                _bHasChanged = bStatus;
        }

        BOOL isModified() {
                return _bHasChanged;
        }

        unsigned getMetadataCount(FREE_IMAGE_MDMODEL model) const;
        BOOL getMetadata(FREE_IMAGE_MDMODEL model, const char *key, fipTag& tag) const;
        BOOL setMetadata(FREE_IMAGE_MDMODEL model, const char *key, fipTag& tag);
        
        void clearMetadata();

  protected:
          BOOL replace(FIBITMAP *new_dib);

};

// ----------------------------------------------------------

#ifdef _WIN32

class FIP_API fipWinImage : public fipImage
{
public:
        fipWinImage(FREE_IMAGE_TYPE image_type = FIT_BITMAP, unsigned width = 0, unsigned height = 0, unsigned bpp = 0);

        virtual ~fipWinImage();

        virtual void clear();

        BOOL isValid() const;


        fipWinImage& operator=(const fipImage& src);

        fipWinImage& operator=(const fipWinImage& src);

        HANDLE copyToHandle() const;

        BOOL copyFromHandle(HANDLE hMem);

        BOOL copyFromBitmap(HBITMAP hbmp);

        BOOL copyToClipboard(HWND hWndNewOwner) const;

        BOOL pasteFromClipboard();

        BOOL captureWindow(HWND hWndApplicationWindow, HWND hWndSelectedWindow);



        void draw(HDC hDC, RECT& rcDest) const {
                drawEx(hDC, rcDest, FALSE, NULL, NULL);
        }

        void drawEx(HDC hDC, RECT& rcDest, BOOL useFileBkg = FALSE, RGBQUAD *appBkColor = NULL, FIBITMAP *bg = NULL) const;

        void setToneMappingOperator(FREE_IMAGE_TMO tmo, double first_param = 0, double second_param = 0, double third_param = 1, double fourth_param = 0);

        void getToneMappingOperator(FREE_IMAGE_TMO *tmo, double *first_param, double *second_param, double *third_param, double *fourth_param) const;


protected:
        mutable FIBITMAP *_display_dib;
        mutable BOOL _bDeleteMe;
        FREE_IMAGE_TMO _tmo;
        double _tmo_param_1;
        double _tmo_param_2;
        double _tmo_param_3;
        double _tmo_param_4;
};

#endif // _WIN32

// ----------------------------------------------------------

class FIP_API fipMemoryIO : public fipObject
{
protected:
        FIMEMORY *_hmem;

public :
    fipMemoryIO(BYTE *data = NULL, DWORD size_in_bytes = 0);

        virtual ~fipMemoryIO();

        void close();

        BOOL isValid() const;

        FREE_IMAGE_FORMAT getFileType() const;

        operator FIMEMORY*() { 
                return _hmem; 
        }

        FIBITMAP* load(FREE_IMAGE_FORMAT fif, int flags = 0) const;
        FIMULTIBITMAP* loadMultiPage(FREE_IMAGE_FORMAT fif, int flags = 0) const;
        BOOL save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, int flags = 0);
        BOOL saveMultiPage(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap, int flags = 0);
        unsigned read(void *buffer, unsigned size, unsigned count) const;
        unsigned write(const void *buffer, unsigned size, unsigned count);
        long tell() const;
        BOOL seek(long offset, int origin);
        BOOL acquire(BYTE **data, DWORD *size_in_bytes);

private:
        fipMemoryIO(const fipMemoryIO& src);
        fipMemoryIO& operator=(const fipMemoryIO& src);

};

// ----------------------------------------------------------

class FIP_API fipMultiPage : public fipObject 
{
protected:
        FIMULTIBITMAP *_mpage;
        BOOL _bMemoryCache;

public:
        fipMultiPage(BOOL keep_cache_in_memory = FALSE);

        virtual ~fipMultiPage();

        BOOL isValid() const;

        operator FIMULTIBITMAP*() { 
                return _mpage; 
        }

        BOOL open(const char* lpszPathName, BOOL create_new, BOOL read_only, int flags = 0);

        BOOL open(fipMemoryIO& memIO, int flags = 0);

        BOOL open(FreeImageIO *io, fi_handle handle, int flags = 0);

        BOOL close(int flags = 0);

        BOOL saveToHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags = 0) const;

        BOOL saveToMemory(FREE_IMAGE_FORMAT fif, fipMemoryIO& memIO, int flags = 0) const;

        int getPageCount() const;

        void appendPage(fipImage& image);

        void insertPage(int page, fipImage& image);

        void deletePage(int page);

        BOOL movePage(int target, int source);

        FIBITMAP* lockPage(int page);

        void unlockPage(fipImage& image, BOOL changed);

        BOOL getLockedPageNumbers(int *pages, int *count) const;
};

// ----------------------------------------------------------

class FIP_API fipTag : public fipObject
{
protected:
        FITAG *_tag;

public:
        fipTag();
        virtual ~fipTag();
        BOOL setKeyValue(const char *key, const char *value);


        fipTag(const fipTag& tag);
        fipTag& operator=(const fipTag& tag);
        fipTag& operator=(FITAG *tag);

        operator FITAG*() { 
                return _tag; 
        }

        BOOL isValid() const;

        const char *getKey() const;
        const char *getDescription() const;
        WORD getID() const;
        FREE_IMAGE_MDTYPE getType() const;
        DWORD getCount() const;
        DWORD getLength() const;
        const void *getValue() const;
        BOOL setKey(const char *key);
        BOOL setDescription(const char *description);
        BOOL setID(WORD id);
        BOOL setType(FREE_IMAGE_MDTYPE type);
        BOOL setCount(DWORD count);
        BOOL setLength(DWORD length);
        BOOL setValue(const void *value);


        const char* toString(FREE_IMAGE_MDMODEL model, char *Make = NULL) const;

};

class FIP_API fipMetadataFind : public fipObject
{
protected:
        FIMETADATA *_mdhandle;

public:
        BOOL isValid() const;

        fipMetadataFind();
        virtual ~fipMetadataFind();
        BOOL findFirstMetadata(FREE_IMAGE_MDMODEL model, fipImage& image, fipTag& tag);
        BOOL findNextMetadata(fipTag& tag);

};

#endif  // FREEIMAGEPLUS_H