ImageIO.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

#ifndef IMAGINE_GRAPHICS_IMAGEIO_H
#define IMAGINE_GRAPHICS_IMAGEIO_H

namespace Imagine {

    // ====================================================
    // ImageIO: displaying, loading, saving, capturing, ...

    // Image displaying functions

    void putColorImage(int x, int y, const Color* cols, int w, int h, bool xorMode = false, double fact = 1.);
    inline void putColorImage(const IntPoint2& p, const Color* cols, int w, int h, bool xorMode = false, double fact = 1.)
    { putColorImage(p.x(), p.y(), cols, w, h, xorMode, fact); }
    void putColorImage(int x, int y, const byte *rgb, int w, int h, bool xorMode = false, double fact = 1.);
    inline void putColorImage(const IntPoint2& p, const byte *rgb, int w, int h, bool xorMode = false, double fact = 1.)
    { putColorImage(p.x(), p.y(), rgb, w, h, xorMode, fact); }
    void putColorImage(int x, int y, const byte *r, const byte *g, const byte *b, int w, int h, bool xorMode = false, double fact = 1.);

    inline void putColorImage(const IntPoint2& p, const byte *r, const byte *g, const byte *b, int w, int h, bool xorMode = false, double fact = 1.)
    { putColorImage(p.x(), p.y(), r, g, b, w, h, xorMode, fact); }

    // Color Image whith transparency displaying functions
    void putAlphaColorImage(int x, int y, Imagine::AlphaColor *cols, int w, int h, bool xorMode = false, double fact = 1.);
    void putColorImage(int x, int y, const byte *r, const byte *g, const byte *b, const byte *a,int w, int h, bool xorMode = false, double fact = 1.);
    inline void putColorImage(const IntPoint2& p, const byte *r, const byte *g, const byte *b, const byte *a,int w, int h, bool xorMode = false, double fact = 1.)
    { putColorImage(p.x(), p.y(), r, g, b, a ,w, h, xorMode, fact); }
    void putAlphaColorImage(int x, int y, byte *rgba, int w, int h, bool xorMode = false, double fact = 1.);
    void putAlphaColorImage(const IntPoint2& p, byte *rgba, int w, int h, bool xorMode = false, double fact = 1.);
    void putGreyImage(int x, int y, const byte* g, int w, int h, bool xorMode = false, double fact = 1.);
    inline void putGreyImage(const IntPoint2& p, const byte* g, int w, int h, bool xorMode = false, double fact = 1.)
    { putGreyImage(p.x(), p.y(), g, w, h, xorMode, fact); }
    void setMaskFromColor(byte *&r, byte *&g, byte *&b, byte *&a, int w, int h, const Color &col);
    void setMaskFromColor(byte *&rgba, int w, int h, const Color &col);
    void setMaskFromColor(AlphaColor *&acols, int w, int h, AlphaColor col);
    AlphaColor* convertColorToAlphaColor(const Imagine::Color *cols, int w, int h);
    // Image loading functions
    bool loadColorImage(const std::string& name, Color *&cols, int& w, int& h);
    bool loadAlphaColorImage(const std::string& name, AlphaColor *&acols, int& w, int& h);
    bool loadColorImage(const std::string &name, byte *&rgb, int &w, int &h);
    bool loadAlphaColorImage(const std::string &name, byte *&rgba, int &w, int &h);
    bool loadColorImage(const std::string &name, byte *&r, byte *&g, byte *&b, int &w, int &h);
    bool loadColorImage(const std::string &name, byte *&r, byte *&g, byte *&b, byte*&a, int &w, int &h);
    bool loadGreyImage(const std::string& name, byte*& g, int& w, int& h);

    // Image saving functions

    bool saveColorImage(const std::string& name,const Color* cols, int w, int h, int quality = 85);
    bool saveAlphaColorImage(const std::string& name, Imagine::AlphaColor *cols, int w, int h, int quality = 85);
    bool saveColorImage(const std::string &name, const byte *rgb, int w, int h, int quality = 85);
    bool saveAlphaColorImage(const std::string &name, byte *rgba, int w, int h, int quality = 85);
    bool saveColorImage(const std::string &name, const byte *r, const byte *g, const byte *b, int w, int h, int quality = 85);
    bool saveAlphaColorImage(const std::string &name, const byte *r, const byte *g, const byte *b, const byte *a,int w, int h, int quality = 85);
    bool saveGreyImage(const std::string& name, const byte* g, int w, int h, int quality = 85);

    // Image capture functions

    Color capturePoint(int x, int y);
    inline Color capturePoint(const IntPoint2& p)
    { return capturePoint(p.x(), p.y()); }
    void captureRectangle(int x, int y, Color *c, int w, int h);
    inline void captureRectangle(const IntPoint2& p, Color *c, int w, int h)
    { captureRectangle(p.x(), p.y(), c, w, h); }
    void captureRectangle(int x, int y, byte *RGB, int w, int h);
    inline void captureRectangle(const IntPoint2& p, byte *RGB, int w, int h)
    { captureRectangle(p.x(), p.y(), RGB, w, h); }
    void captureRectangle(int x, int y, byte *R, byte *G, byte *B, int w, int h);
    inline void captureRectangle(const IntPoint2& p, byte *R, byte *G, byte *B, int w, int h)
    { captureRectangle(p.x(), p.y(), R, G, B, w, h); }
    void captureWindow(Color *&cols, int &w, int &h);
    void captureWindow(byte *&RGB, int &w, int &h);
    void captureWindow(byte *&R, byte *&G, byte *&B, int &w, int &h);

    // ====================================================
    // NativeBitmap class
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    class NativeBitmapInternal; // Private
    class NativeBitmap;
#endif
    void putNativeBitmap(int x,int y,const NativeBitmap &bm,bool xorMode=false,double fact=1.);

    class NativeBitmap {
        NativeBitmapInternal* priv;
    public:
        NativeBitmap();
        NativeBitmap(int w,int h);
        NativeBitmap(const NativeBitmap& I);
        ~NativeBitmap();
        const NativeBitmap& operator=(const NativeBitmap& I);
        void setColorImage(int x,int y,const byte *r,const byte *g,const byte *b,int w,int h);
        inline void setColorImage(const IntPoint2&p,const byte *r,const byte *g,const byte *b,int w,int h)
        {       setColorImage(p.x(),p.y(),r,g,b,w,h);   }
        void setColorImage(int x,int y,const Color *cols,int w,int h);
        inline void setColorImage(const IntPoint2& p,const Color *cols,int w,int h)
        {       setColorImage(p.x(),p.y(),cols,w,h);    }
        inline void setColorImage(int x,int y,const byte *rgb,int w,int h)
        {       setColorImage(x,y,(const Color*)rgb,w,h);   }
        inline void setColorImage(const IntPoint2& p,const byte *rgb,int w,int h)
        {       setColorImage(p.x(),p.y(),(const Color*)rgb,w,h);   }
        void setGreyImage(int x,int y,const byte *g,int w,int h);
        inline void setGreyImage(const IntPoint2 &p,const byte *g,int w,int h)
        {       setGreyImage(p.x(),p.y(),g,w,h);    }
        void setPoint(int x,int y,Color col);
        inline void setPoint(const IntPoint2&p,Color col)
        {       setPoint(p.x(),p.y(),col);  }
        friend void putNativeBitmap(int x,int y,const NativeBitmap &bm,bool xorMode,double fact);
        friend inline void putNativeBitmap(const IntPoint2& p,const NativeBitmap &bm,bool xorMode=false,double fact=1.) // Variant with IntPoint2
        {       putNativeBitmap(p.x(),p.y(),bm,xorMode,fact);   }
    };

} /* namespace Imagine */

#endif // IMAGINE_GRAPHICS_IMAGEIO_H