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