gdpp.h

Go to the documentation of this file.

/* *****************************************************************************
** Initial file written and documented by:
** Kevin Shepherd <kshepherd@php.net> December 2007
** of Scarlet Line http://www.scarletline.com/
** with contributions from Torben Nielsen.
*******************************************************************************/
#ifndef _gdpp_h
#define _gdpp_h
#ifdef __cplusplus
#include "gd_intern.h"
#include "gd_io_stream.h"
#include <string>
 
 
namespace GD {
class BGD_EXPORT_DATA_PROT Point {
  public:
    // Constructors
    Point(int x, int y) : _x(x), _y(y) {}
    Point(const Point &p) : _x(p._x), _y(p._y) {}
    Point() : _x(0), _y(0) {}
    Point &operator=(const Point &p)
    {
        _x = p._x;
        _y = p._y;
        return (*this);
    }
    // Accessors
    int X() const { return _x; }
    int Y() const { return _y; }
    // Updaters
    void X(int x) { _x = x; }
    void Y(int y) { _y = y; }
    void set(int x, int y)
    {
        _x = x;
        _y = y;
    }
    int &lhsX() { return _x; }
    int &lhsY() { return _y; }
 
    gdPointPtr as_gdPointPtr() { return (gdPointPtr)this; }
 
  protected:
    int _x, _y;
};
typedef Point *PointPtr;
class BGD_EXPORT_DATA_PROT Size {
  public:
    // Constructors
    Size(int w, int h) : _w(w), _h(h) {}
    Size(const Size &p) : _w(p._w), _h(p._h) {}
    Size() : _w(0), _h(0) {}
    Size &operator=(const Size &p)
    {
        _w = p._w;
        _h = p._h;
        return (*this);
    }
    // Accessors
    int W() const { return _w; }
    int H() const { return _h; }
    // Updaters
    void W(int w) { _w = w; }
    void H(int h) { _h = h; }
    void set(int w, int h)
    {
        _w = w;
        _h = h;
    }
    int &lhsW() { return _w; }
    int &lhsH() { return _h; }
 
  protected:
    int _w, _h;
};
typedef Size *SizePtr;
 
class BGD_EXPORT_DATA_PROT TrueColor {
  public:
    union as_types {
        int as_int;
        struct uchars {
            unsigned char blue, green, red, alpha;
        } as_uchar;
    };
    TrueColor() { internal.as_int = 0; }
    TrueColor(int c) { internal.as_int = c; }
    TrueColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0)
    {
        internal.as_uchar.alpha = a;
        internal.as_uchar.red = r;
        internal.as_uchar.green = g;
        internal.as_uchar.blue = b;
    }
    // Accessors
    int Int() const { return internal.as_int; }
    unsigned char Red() const { return internal.as_uchar.red; }
    unsigned char Green() const { return internal.as_uchar.green; }
    unsigned char Blue() const { return internal.as_uchar.blue; }
    unsigned char Alpha() const { return internal.as_uchar.alpha; }
    // Updaters
    void set(int c) { internal.as_int = c; }
    void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0)
    {
        internal.as_uchar.alpha = a;
        internal.as_uchar.red = r;
        internal.as_uchar.green = g;
        internal.as_uchar.blue = b;
    }
    void Red(unsigned char c) { internal.as_uchar.red = c; }
    void Green(unsigned char c) { internal.as_uchar.green = c; }
    void Blue(unsigned char c) { internal.as_uchar.blue = c; }
    void Alpha(unsigned char c) { internal.as_uchar.alpha = c; }
 
  protected:
    as_types internal;
};
/*  The following tags are simply empty structures which are used
        to tell the compiler which constructor we want when we know
        the image file format.
*/
struct BGD_EXPORT_DATA_PROT Png_tag {};
struct BGD_EXPORT_DATA_PROT Gif_tag {};
struct BGD_EXPORT_DATA_PROT WBMP_tag {};
struct BGD_EXPORT_DATA_PROT Jpeg_tag {};
struct BGD_EXPORT_DATA_PROT Gd_tag {};
struct BGD_EXPORT_DATA_PROT Gd2_tag {};
struct BGD_EXPORT_DATA_PROT Xbm_tag {};
 
class BGD_EXPORT_DATA_PROT Image {
  public:
    Image() : im(0) {}
    Image(int sx, int sy, bool istruecolor = false) : im(0)
    {
        if (istruecolor)
            CreateTrueColor(sx, sy);
        else
            Create(sx, sy);
    }
    Image(const Size &s, bool istruecolor = false) : im(0)
    {
        if (istruecolor)
            CreateTrueColor(s);
        else
            Create(s);
    }
    Image(gdImagePtr i) : im(i) {}
    Image(const GD::Image &i) : im(0) { Copy(i); }
    Image(std::istream &in) : im(0) { CreateFrom(in); }
    Image(FILE *in) : im(0) { CreateFrom(in); }
    Image(int size, void *data) : im(0) { CreateFrom(size, data); }
 
    Image(std::istream &in, Png_tag) : im(0) { CreateFromPng(in); }
    Image(FILE *in, Png_tag) : im(0) { CreateFromPng(in); }
    Image(gdIOCtxPtr in, Png_tag) : im(0) { CreateFromPng(in); }
    Image(int size, void *data, Png_tag) : im(0) { CreateFromPng(size, data); }
 
    Image(std::istream &in, Gif_tag) : im(0) { CreateFromGif(in); }
    Image(FILE *in, Gif_tag) : im(0) { CreateFromGif(in); }
    Image(gdIOCtxPtr in, Gif_tag) : im(0) { CreateFromGif(in); }
    Image(int size, void *data, Gif_tag) : im(0) { CreateFromGif(size, data); }
 
    Image(std::istream &in, WBMP_tag) : im(0) { CreateFromWBMP(in); }
    Image(FILE *in, WBMP_tag) : im(0) { CreateFromWBMP(in); }
    Image(gdIOCtxPtr in, WBMP_tag) : im(0) { CreateFromWBMP(in); }
    Image(int size, void *data, WBMP_tag) : im(0) { CreateFromWBMP(size, data); }
 
    Image(std::istream &in, Jpeg_tag) : im(0) { CreateFromJpeg(in); }
    Image(FILE *in, Jpeg_tag) : im(0) { CreateFromJpeg(in); }
    Image(gdIOCtxPtr in, Jpeg_tag) : im(0) { CreateFromJpeg(in); }
    Image(int size, void *data, Jpeg_tag) : im(0) { CreateFromJpeg(size, data); }
 
    Image(std::istream &in, Gd_tag) : im(0) { CreateFromGd(in); }
    Image(FILE *in, Gd_tag) : im(0) { CreateFromGd(in); }
    Image(gdIOCtxPtr in, Gd_tag) : im(0) { CreateFromGd(in); }
    Image(int size, void *data, Gd_tag) : im(0) { CreateFromGd(size, data); }
 
    Image(std::istream &in, Gd2_tag) : im(0) { CreateFromGd2(in); }
    Image(FILE *in, Gd2_tag) : im(0) { CreateFromGd2(in); }
    Image(gdIOCtxPtr in, Gd2_tag) : im(0) { CreateFromGd2(in); }
    Image(int size, void *data, Gd2_tag) : im(0) { CreateFromGd2(size, data); }
 
    Image(FILE *in, Xbm_tag) : im(0) { CreateFromXbm(in); }
 
    ~Image() { clear(); }
 
    GD::Image &operator=(const GD::Image &src)
    {
        Copy(src);
        return (*this);
    }
    void Copy(const GD::Image &src)
    {
        int w = src.Width(), h = src.Height();
        if (src.IsTrueColor())
            CreateTrueColor(w, h);
        else {
            Create(w, h);
            PaletteCopy(src);
        }
        Copy(src, 0, 0, 0, 0, w, h);
    }
    bool good() const { return (im != 0); }
    // Creation:
    bool Create(int sx, int sy)
    {
        clear();
        return ((im = gdImageCreate(sx, sy)) != 0);
    }
    bool CreateTrueColor(int sx, int sy)
    {
        clear();
        return ((im = gdImageCreateTrueColor(sx, sy)) != 0);
    }
    bool Create(const Size &s) { return Create(s.W(), s.H()); }
    bool CreateTrueColor(const Size &s) { return CreateTrueColor(s.W(), s.H()); }
    // Create, determining the image format from the data
    bool CreateFrom(FILE *in);
    bool CreateFrom(std::istream &in);
    bool CreateFrom(int size, void *data);
 
    // Png
    bool CreateFromPng(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromPng(in)) != 0);
    }
    bool CreateFromPng(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromPngCtx(in)) != 0);
    }
    bool CreateFromPng(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromPngPtr(size, data)) != 0);
    }
    bool CreateFromPng(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromPngCtx(&_in_ctx)) != 0);
    }
 
    // Gif
    bool CreateFromGif(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromGif(in)) != 0);
    }
    bool CreateFromGif(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromGifCtx(in)) != 0);
    }
    bool CreateFromGif(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromGifPtr(size, data)) != 0);
    }
    bool CreateFromGif(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromGifCtx(&_in_ctx)) != 0);
    }
    // WBMP
    bool CreateFromWBMP(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromWBMP(in)) != 0);
    }
    bool CreateFromWBMP(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromWBMPCtx(in)) != 0);
    }
    bool CreateFromWBMP(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromWBMPPtr(size, data)) != 0);
    }
    bool CreateFromWBMP(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromWBMPCtx(&_in_ctx)) != 0);
    }
 
    // Jpeg
    bool CreateFromJpeg(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromJpeg(in)) != 0);
    }
    bool CreateFromJpeg(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromJpegCtx(in)) != 0);
    }
    bool CreateFromJpeg(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromJpegPtr(size, data)) != 0);
    }
    bool CreateFromJpeg(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromJpegCtx(&_in_ctx)) != 0);
    }
 
    // Gd
    bool CreateFromGd(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromGd(in)) != 0);
    }
    bool CreateFromGd(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromGdCtx(in)) != 0);
    }
    bool CreateFromGd(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromGdPtr(size, data)) != 0);
    }
    bool CreateFromGd(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromGdCtx(&_in_ctx)) != 0);
    }
    // Gd2
    bool CreateFromGd2(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromGd2(in)) != 0);
    }
    bool CreateFromGd2(gdIOCtxPtr in)
    {
        clear();
        return ((im = gdImageCreateFromGd2Ctx(in)) != 0);
    }
    bool CreateFromGd2(int size, void *data)
    {
        clear();
        return ((im = gdImageCreateFromGd2Ptr(size, data)) != 0);
    }
    bool CreateFromGd2(std::istream &in)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromGd2Ctx(&_in_ctx)) != 0);
    }
    // Gd2 Part
    bool CreateFromGd2Part(FILE *in, int srcx, int srcy, int w, int h)
    {
        clear();
        return ((im = gdImageCreateFromGd2Part(in, srcx, srcy, w, h)) != 0);
    }
    bool CreateFromGd2Part(gdIOCtxPtr in, int srcx, int srcy, int w, int h)
    {
        clear();
        return ((im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h)) != 0);
    }
    bool CreateFromGd2Part(int size, void *data, int srcx, int srcy, int w, int h)
    {
        clear();
        return ((im = gdImageCreateFromGd2PartPtr(size, data, srcx, srcy, w, h)) != 0);
    }
    bool CreateFromGd2Part(std::istream &in, int srcx, int srcy, int w, int h)
    {
        clear();
        istreamIOCtx _in_ctx(in);
        return ((im = gdImageCreateFromGd2PartCtx(&_in_ctx, srcx, srcy, w, h)) != 0);
    }
    bool CreateFromGd2Part(FILE *in, const Point &src, const Size &s)
    {
        return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());
    }
    bool CreateFromGd2Part(gdIOCtxPtr in, const Point &src, const Size &s)
    {
        return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());
    }
    bool CreateFromGd2Part(int size, void *data, const Point &src, const Size &s)
    {
        return CreateFromGd2Part(size, data, src.X(), src.Y(), s.W(), s.H());
    }
    bool CreateFromGd2Part(std::istream &in, const Point &src, const Size &s)
    {
        return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H());
    }
    // Xbm
    bool CreateFromXbm(FILE *in)
    {
        clear();
        return ((im = gdImageCreateFromXbm(in)) != 0);
    }
    // Xpm
    bool CreateFromXpm(char *filename)
    {
        clear();
        return ((im = gdImageCreateFromXpm(filename)) != 0);
    }
    bool CreateFromXpm(std::string &filename) { return CreateFromXpm((char *)(filename.c_str())); }
 
    // Accessors, Updaters & Methods:
    void SetPixel(int x, int y, int color) { gdImageSetPixel(im, x, y, color); }
    void SetPixel(const Point &p, int color) { SetPixel(p.X(), p.Y(), color); }
    int GetPixel(int x, int y) const { return gdImageGetPixel(im, x, y); }
    int GetPixel(const Point &p) const { return GetPixel(p.X(), p.Y()); }
    int GetTrueColorPixel(int x, int y) const { return gdImageGetTrueColorPixel(im, x, y); }
    int GetTrueColorPixel(const Point &p) const { return GetTrueColorPixel(p.X(), p.Y()); }
 
    void SetPixel(int x, int y, TrueColor c) { SetPixel(x, y, c.Int()); }
    void SetPixel(const Point &p, TrueColor c) { SetPixel(p.X(), p.Y(), c.Int()); }
    void GetTrueColorPixel(TrueColor &c, int x, int y) const { c.set(GetTrueColorPixel(x, y)); }
    void GetTrueColorPixel(TrueColor &c, const Point &p) const
    {
        c.set(GetTrueColorPixel(p.X(), p.Y()));
    }
 
    void AABlend() { gdImageAABlend(im); }
 
    void Line(int x1, int y1, int x2, int y2, int color) { gdImageLine(im, x1, y1, x2, y2, color); }
    void Line(const Point &p1, const Point &p2, int color)
    {
        Line(p1.X(), p1.Y(), p2.X(), p2.Y(), color);
    }
    void Rectangle(int x1, int y1, int x2, int y2, int color)
    {
        gdImageRectangle(im, x1, y1, x2, y2, color);
    }
    void Rectangle(const Point &p1, const Point &p2, int color)
    {
        Rectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color);
    }
    void Rectangle(const Point &p, const Size &s, int color)
    {
        Rectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color);
    }
    void FilledRectangle(int x1, int y1, int x2, int y2, int color)
    {
        gdImageFilledRectangle(im, x1, y1, x2, y2, color);
    }
    void FilledRectangle(const Point &p1, const Point &p2, int color)
    {
        FilledRectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color);
    }
    void FilledRectangle(const Point &p, const Size &s, int color)
    {
        FilledRectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color);
    }
 
    void SetClip(int x1, int y1, int x2, int y2) { gdImageSetClip(im, x1, y1, x2, y2); }
    void SetClip(const Point &p1, const Point &p2) { SetClip(p1.X(), p1.Y(), p2.X(), p2.Y()); }
    void SetClip(const Point &p, const Size &s)
    {
        SetClip(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H());
    }
    void GetClip(int &x1, int &y1, int &x2, int &y2) const
    {
        gdImageGetClip(im, &x1, &y1, &x2, &y2);
    }
    void GetClip(Point &p1, Point &p2) const
    {
        GetClip(p1.lhsX(), p1.lhsY(), p2.lhsX(), p2.lhsY());
    }
    void GetClip(Point &p, Size &s) const
    {
        Point p2;
        GetClip(p.lhsX(), p.lhsY(), p2.lhsX(), p2.lhsY());
        s.set(p2.X() - p.X(), p2.Y() - p.Y());
    }
 
    bool BoundsSafe(int x, int y) const { return (gdImageBoundsSafeMacro(im, x, y) ? true : false); }
    bool BoundsSafe(const Point &p) const { return BoundsSafe(p.X(), p.Y()); }
 
    void Char(gdFontPtr f, int x, int y, int c, int color) { gdImageChar(im, f, x, y, c, color); }
    void CharUp(gdFontPtr f, int x, int y, int c, int color)
    {
        gdImageCharUp(im, f, x, y, c, color);
    }
 
    void Char(gdFontPtr f, const Point &p, int c, int color) { Char(f, p.X(), p.Y(), c, color); }
    void CharUp(gdFontPtr f, const Point &p, int c, int color)
    {
        CharUp(f, p.X(), p.Y(), c, color);
    }
 
    void String(gdFontPtr f, int x, int y, unsigned char *s, int color)
    {
        gdImageString(im, f, x, y, (unsigned char *)s, color);
    }
    void StringUp(gdFontPtr f, int x, int y, unsigned char *s, int color)
    {
        gdImageStringUp(im, f, x, y, (unsigned char *)s, color);
    }
    void String(gdFontPtr f, int x, int y, unsigned short *s, int color)
    {
        gdImageString16(im, f, x, y, (unsigned short *)s, color);
    }
    void StringUp(gdFontPtr f, int x, int y, unsigned short *s, int color)
    {
        gdImageStringUp16(im, f, x, y, (unsigned short *)s, color);
    }
    void String(gdFontPtr f, int x, int y, char *s, int color)
    {
        gdImageString(im, f, x, y, (unsigned char *)s, color);
    }
    void StringUp(gdFontPtr f, int x, int y, char *s, int color)
    {
        gdImageStringUp(im, f, x, y, (unsigned char *)s, color);
    }
    void String(gdFontPtr f, int x, int y, const std::string &s, int color)
    {
        String(f, x, y, (char *)s.c_str(), color);
    }
    void StringUp(gdFontPtr f, int x, int y, const std::string &s, int color)
    {
        StringUp(f, x, y, (char *)s.c_str(), color);
    }
 
    void String(gdFontPtr f, const Point &p, unsigned char *s, int color)
    {
        String(f, p.X(), p.Y(), (unsigned char *)s, color);
    }
    void StringUp(gdFontPtr f, const Point &p, unsigned char *s, int color)
    {
        StringUp(f, p.X(), p.Y(), (unsigned char *)s, color);
    }
    void String(gdFontPtr f, const Point &p, unsigned short *s, int color)
    {
        String(f, p.X(), p.Y(), (unsigned short *)s, color);
    }
    void StringUp(gdFontPtr f, const Point &p, unsigned short *s, int color)
    {
        StringUp(f, p.X(), p.Y(), (unsigned short *)s, color);
    }
    void String(gdFontPtr f, const Point &p, char *s, int color)
    {
        String(f, p.X(), p.Y(), (unsigned char *)s, color);
    }
    void StringUp(gdFontPtr f, const Point &p, char *s, int color)
    {
        StringUp(f, p.X(), p.Y(), (unsigned char *)s, color);
    }
    void String(gdFontPtr f, const Point &p, const std::string &s, int color)
    {
        String(f, p, (char *)s.c_str(), color);
    }
    void StringUp(gdFontPtr f, const Point &p, const std::string &s, int color)
    {
        StringUp(f, p, (char *)s.c_str(), color);
    }
 
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y,
                   char *string)
    {
        return gdImageStringFT(im, brect, fg, fontlist, ptsize, angle, x, y, string);
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y,
                   char *string, gdFTStringExtraPtr strex)
    {
        return gdImageStringFTEx(im, brect, fg, fontlist, ptsize, angle, x, y, string, strex);
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y,
                   const std::string &string)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, x, y, (char *)string.c_str());
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y,
                   const std::string &string, gdFTStringExtraPtr strex)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, x, y, (char *)string.c_str(), strex);
    }
 
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, const Point &p,
                   char *string)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, p.X(), p.Y(), string);
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, const Point &p,
                   char *string, gdFTStringExtraPtr strex)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, p.X(), p.Y(), string, strex);
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, const Point &p,
                   const std::string &string)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, p, (char *)string.c_str());
    }
    char *StringFT(int *brect, int fg, char *fontlist, double ptsize, double angle, const Point &p,
                   const std::string &string, gdFTStringExtraPtr strex)
    {
        return StringFT(brect, fg, fontlist, ptsize, angle, p, (char *)string.c_str(), strex);
    }
 
    void Polygon(gdPointPtr p, int n, int c) { gdImagePolygon(im, p, n, c); }
    void OpenPolygon(gdPointPtr p, int n, int c) { gdImageOpenPolygon(im, p, n, c); }
    void FilledPolygon(gdPointPtr p, int n, int c) { gdImageFilledPolygon(im, p, n, c); }
 
    void Polygon(PointPtr p, int n, int c) { Polygon(p->as_gdPointPtr(), n, c); }
    void OpenPolygon(PointPtr p, int n, int c) { OpenPolygon(p->as_gdPointPtr(), n, c); }
    void FilledPolygon(PointPtr p, int n, int c) { FilledPolygon(p->as_gdPointPtr(), n, c); }
 
    int ColorAllocate(int r, int g, int b) { return gdImageColorAllocate(im, r, g, b); }
    int ColorAllocate(int r, int g, int b, int a)
    {
        return gdImageColorAllocateAlpha(im, r, g, b, a);
    }
 
    int ColorClosest(int r, int g, int b) const { return gdImageColorClosest(im, r, g, b); }
    int ColorClosest(int r, int g, int b, int a) const
    {
        return gdImageColorClosestAlpha(im, r, g, b, a);
    }
    int ColorClosestHWB(int r, int g, int b) const { return gdImageColorClosestHWB(im, r, g, b); }
    int ColorExact(int r, int g, int b) const { return gdImageColorExact(im, r, g, b); }
    int ColorExact(int r, int g, int b, int a) const
    {
        return gdImageColorExactAlpha(im, r, g, b, a);
    }
    int ColorResolve(int r, int g, int b) { return gdImageColorResolve(im, r, g, b); }
    int ColorResolve(int r, int g, int b, int a)
    {
        return gdImageColorResolveAlpha(im, r, g, b, a);
    }
 
    void ColorDeallocate(int color) { gdImageColorDeallocate(im, color); }
 
    void TrueColorToPalette(int ditherFlag, int colorsWanted)
    {
        gdImageTrueColorToPalette(im, ditherFlag, colorsWanted);
    }
 
    void ColorTransparent(int color) { gdImageColorTransparent(im, color); }
 
    void PaletteCopy(gdImagePtr src) { gdImagePaletteCopy(im, src); }
    void PaletteCopy(const GD::Image &src) { PaletteCopy(src.im); }
 
    void Gif(FILE *out) const { gdImageGif(im, out); }
    void Gif(gdIOCtxPtr out) const { gdImageGifCtx(im, out); }
    void *Gif(int *size) const { return gdImageGifPtr(im, size); }
    void Gif(std::ostream &out) const
    {
        ostreamIOCtx _out_ctx(out);
        gdImageGifCtx(im, &_out_ctx);
    }
 
    void Png(FILE *out) const { gdImagePng(im, out); }
    void Png(gdIOCtxPtr out) const { gdImagePngCtx(im, out); }
    void *Png(int *size) const { return gdImagePngPtr(im, size); }
    void Png(std::ostream &out) const
    {
        ostreamIOCtx _out_ctx(out);
        gdImagePngCtx(im, &_out_ctx);
    }
    void Png(FILE *out, int level) const { gdImagePngEx(im, out, level); }
    void Png(gdIOCtxPtr out, int level) const { gdImagePngCtxEx(im, out, level); }
    void *Png(int *size, int level) const { return gdImagePngPtrEx(im, size, level); }
    void Png(std::ostream &out, int level) const
    {
        ostreamIOCtx _out_ctx(out);
        gdImagePngCtxEx(im, &_out_ctx, level);
    }
 
    void WBMP(int fg, FILE *out) const { gdImageWBMP(im, fg, out); }
    void WBMP(int fg, gdIOCtxPtr out) const { gdImageWBMPCtx(im, fg, out); }
    void *WBMP(int *size, int fg) const { return gdImageWBMPPtr(im, size, fg); }
    void WBMP(int fg, std::ostream &out) const
    {
        ostreamIOCtx _out_ctx(out);
        gdImageWBMPCtx(im, fg, &_out_ctx);
    }
 
    void Jpeg(FILE *out, int quality = -1) const { gdImageJpeg(im, out, quality); }
    void Jpeg(gdIOCtxPtr out, int quality = -1) const { gdImageJpegCtx(im, out, quality); }
    void *Jpeg(int *size, int quality = -1) const { return gdImageJpegPtr(im, size, quality); }
    void Jpeg(std::ostream &out, int quality = -1) const
    {
        ostreamIOCtx _out_ctx(out);
        gdImageJpegCtx(im, &_out_ctx, quality);
    }
 
    void GifAnimBegin(FILE *out, int GlobalCM, int Loops) const
    {
        gdImageGifAnimBegin(im, out, GlobalCM, Loops);
    }
    void GifAnimAdd(FILE *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                    gdImagePtr previm) const
    {
        gdImageGifAnimAdd(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm);
    }
    void GifAnimAdd(FILE *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                    const GD::Image &previm) const
    {
        GifAnimAdd(out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im);
    }
    inline static void GifAnimEnd(FILE *out) { gdImageGifAnimEnd(out); }
    void GifAnimBegin(gdIOCtxPtr out, int GlobalCM, int Loops) const
    {
        gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
    }
    void GifAnimAdd(gdIOCtxPtr out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                    gdImagePtr previm) const
    {
        gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm);
    }
    void GifAnimAdd(gdIOCtxPtr out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                    const GD::Image &previm) const
    {
        GifAnimAdd(out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im);
    }
    inline static void GifAnimEnd(gdIOCtxPtr out) { gdImageGifAnimEndCtx(out); }
    void *GifAnimBegin(int *size, int GlobalCM, int Loops) const
    {
        return gdImageGifAnimBeginPtr(im, size, GlobalCM, Loops);
    }
    void *GifAnimAdd(int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                     gdImagePtr previm) const
    {
        return gdImageGifAnimAddPtr(im, size, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm);
    }
    void *GifAnimAdd(int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal,
                     const GD::Image &previm) const
    {
        return GifAnimAdd(size, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im);
    }
    inline static void *GifAnimEnd(int *size) { return gdImageGifAnimEndPtr(size); }
 
    void Gd(FILE *out) const { gdImageGd(im, out); }
    void *Gd(int *size) const { return gdImageGdPtr(im, size); }
    void Gd2(FILE *out, int cs, int fmt) const { gdImageGd2(im, out, cs, fmt); }
    void *Gd2(int cs, int fmt, int *size) const { return gdImageGd2Ptr(im, cs, fmt, size); }
 
    void Ellipse(int cx, int cy, int w, int h, int color)
    {
        gdImageEllipse(im, cx, cy, w, h, color);
    }
    void FilledArc(int cx, int cy, int w, int h, int s, int e, int color, int style)
    {
        gdImageFilledArc(im, cx, cy, w, h, s, e, color, style);
    }
    void Arc(int cx, int cy, int w, int h, int s, int e, int color)
    {
        gdImageArc(im, cx, cy, w, h, s, e, color);
    }
    void FilledEllipse(int cx, int cy, int w, int h, int color)
    {
        gdImageFilledEllipse(im, cx, cy, w, h, color);
    }
    void FillToBorder(int x, int y, int border, int color)
    {
        gdImageFillToBorder(im, x, y, border, color);
    }
    void Fill(int x, int y, int color) { gdImageFill(im, x, y, color); }
 
    void Ellipse(const Point &c, const Size &s, int color)
    {
        Ellipse(c.X(), c.Y(), s.W(), s.H(), color);
    }
    void FilledArc(const Point &c, const Size &si, int s, int e, int color, int style)
    {
        FilledArc(c.X(), c.Y(), si.W(), si.H(), s, e, color, style);
    }
    void Arc(const Point &c, const Size &si, int s, int e, int color)
    {
        Arc(c.X(), c.Y(), si.W(), si.H(), s, e, color);
    }
    void FilledEllipse(const Point &c, const Size &s, int color)
    {
        FilledEllipse(c.X(), c.Y(), s.W(), s.H(), color);
    }
    void FillToBorder(const Point &p, int border, int color)
    {
        FillToBorder(p.X(), p.Y(), border, color);
    }
    void Fill(const Point &p, int color) { Fill(p.X(), p.Y(), color); }
 
    void Copy(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
    {
        gdImageCopy(im, src, dstX, dstY, srcX, srcY, w, h);
    }
    void CopyMerge(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h,
                   int pct)
    {
        gdImageCopyMerge(im, src, dstX, dstY, srcX, srcY, w, h, pct);
    }
    void CopyMergeGray(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h,
                       int pct)
    {
        gdImageCopyMergeGray(im, src, dstX, dstY, srcX, srcY, w, h, pct);
    }
 
    void CopyResized(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW,
                     int dstH, int srcW, int srcH)
    {
        gdImageCopyResized(im, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
    }
    void CopyResampled(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW,
                       int dstH, int srcW, int srcH)
    {
        gdImageCopyResampled(im, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
    }
    void CopyRotated(const gdImagePtr src, double dstX, double dstY, int srcX, int srcY,
                     int srcWidth, int srcHeight, int angle)
    {
        gdImageCopyRotated(im, src, dstX, dstY, srcX, srcY, srcWidth, srcHeight, angle);
    }
 
    Image *CopyGaussianBlurred(int radius, double sigma)
    {
        return new Image(gdImageCopyGaussianBlurred(im, radius, sigma));
    }
 
    void Copy(const gdImagePtr src, const Point &dstP, const Point &srcP, const Size &s)
    {
        Copy(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H());
    }
    void CopyMerge(const gdImagePtr src, const Point &dstP, const Point &srcP, const Size &s,
                   int pct)
    {
        CopyMerge(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct);
    }
    void CopyMergeGray(const gdImagePtr src, const Point &dstP, const Point &srcP, const Size &s,
                       int pct)
    {
        CopyMergeGray(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct);
    }
 
    void CopyResized(const gdImagePtr src, const Point &dstP, const Point &srcP, const Size &dstS,
                     const Size &srcS)
    {
        CopyResized(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(),
                    srcS.H());
    }
    void CopyResampled(const gdImagePtr src, const Point &dstP, const Point &srcP, const Size &dstS,
                       const Size &srcS)
    {
        CopyResampled(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(),
                      srcS.H());
    }
    void CopyRotated(const gdImagePtr src, double dstX, double dstY, const Point &srcP,
                     const Size &srcS, int angle)
    {
        CopyRotated(src, dstX, dstY, srcP.X(), srcP.Y(), srcS.W(), srcS.H(), angle);
    }
 
    void Copy(const GD::Image &src, int dstX, int dstY, int srcX, int srcY, int w, int h)
    {
        Copy(src.im, dstX, dstY, srcX, srcY, w, h);
    }
    void CopyMerge(const GD::Image &src, int dstX, int dstY, int srcX, int srcY, int w, int h,
                   int pct)
    {
        CopyMerge(src.im, dstX, dstY, srcX, srcY, w, h, pct);
    }
    void CopyMergeGray(const GD::Image &src, int dstX, int dstY, int srcX, int srcY, int w, int h,
                       int pct)
    {
        CopyMergeGray(src.im, dstX, dstY, srcX, srcY, w, h, pct);
    }
 
    void CopyResized(const GD::Image &src, int dstX, int dstY, int srcX, int srcY, int dstW,
                     int dstH, int srcW, int srcH)
    {
        CopyResized(src.im, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
    }
    void CopyResampled(const GD::Image &src, int dstX, int dstY, int srcX, int srcY, int dstW,
                       int dstH, int srcW, int srcH)
    {
        CopyResampled(src.im, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
    }
    void CopyRotated(const GD::Image &src, double dstX, double dstY, int srcX, int srcY,
                     int srcWidth, int srcHeight, int angle)
    {
        CopyRotated(src.im, dstX, dstY, srcX, srcY, srcWidth, srcHeight, angle);
    }
 
    void Copy(const GD::Image &src, const Point &dstP, const Point &srcP, const Size &s)
    {
        Copy(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H());
    }
    void CopyMerge(const GD::Image &src, const Point &dstP, const Point &srcP, const Size &s,
                   int pct)
    {
        CopyMerge(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct);
    }
    void CopyMergeGray(const GD::Image &src, const Point &dstP, const Point &srcP, const Size &s,
                       int pct)
    {
        CopyMergeGray(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct);
    }
 
    void CopyResized(const GD::Image &src, const Point &dstP, const Point &srcP, const Size &dstS,
                     const Size &srcS)
    {
        CopyResized(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(),
                    srcS.H());
    }
    void CopyResampled(const GD::Image &src, const Point &dstP, const Point &srcP, const Size &dstS,
                       const Size &srcS)
    {
        CopyResampled(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(),
                      srcS.H());
    }
    void CopyRotated(const GD::Image &src, double dstX, double dstY, const Point &srcP,
                     const Size &srcS, int angle)
    {
        CopyRotated(src.im, dstX, dstY, srcP.X(), srcP.Y(), srcS.W(), srcS.H(), angle);
    }
 
    Image *Clone() { return new Image(gdImageClone(im)); }
 
    void SetBrush(gdImagePtr brush) { gdImageSetBrush(im, brush); }
    void SetBrush(const GD::Image &brush) { SetBrush(brush.im); }
    void SetTile(gdImagePtr tile) { gdImageSetTile(im, tile); }
    void SetTile(const GD::Image &tile) { SetTile(tile.im); }
    void SetAntiAliased(int c) { gdImageSetAntiAliased(im, c); }
    void SetAntiAliasedDontBlend(int c, int dont_blend)
    {
        gdImageSetAntiAliasedDontBlend(im, c, dont_blend);
    }
    void SetStyle(int *style, int noOfPixels) { gdImageSetStyle(im, style, noOfPixels); }
    void SetThickness(int thickness) { gdImageSetThickness(im, thickness); }
    void SetResolution(int res_x, int res_y) { gdImageSetResolution(im, res_x, res_y); }
    void SetInterpolationMethod(gdInterpolationMethod interpolation_method)
    {
        gdImageSetInterpolationMethod(im, interpolation_method);
    }
 
    Image *RotateInterpolated(const float angle, int bgcolor)
    {
        return new Image(gdImageRotateInterpolated(im, angle, bgcolor));
    }
 
    void Interlace(bool interlaceArg) { gdImageInterlace(im, interlaceArg ? 1 : 0); }
    void AlphaBlending(bool alphaBlendingArg)
    {
        gdImageAlphaBlending(im, alphaBlendingArg ? 1 : 0);
    }
    void SaveAlpha(bool saveAlphaArg) { gdImageSaveAlpha(im, saveAlphaArg ? 1 : 0); }
 
    int ColorReplace(int src, int dst) { return gdImageColorReplace(im, src, dst); }
    int ColorReplaceArray(int len, int *src, int *dst)
    {
        return gdImageColorReplaceArray(im, len, src, dst);
    }
    int ColorReplaceCallback(gdCallbackImageColor callback)
    {
        return gdImageColorReplaceCallback(im, callback);
    }
    int ColorReplaceThreshold(int src, int dst, float threshold)
    {
        return gdImageColorReplaceThreshold(im, src, dst, threshold);
    }
 
    bool Pixelate(int block_size, gdPixelateMode mode)
    {
        return gdImagePixelate(im, block_size, mode) == 0 ? false : true;
    }
 
    Image *Scale(int new_width, int new_height)
    {
        return new Image(gdImageScale(im, new_width, new_height));
    }
 
    bool IsTrueColor() const { return (gdImageTrueColor(im) ? true : false); }
    int SX() const { return gdImageSX(im); }
    int SY() const { return gdImageSY(im); }
    int Width() const { return SX(); }
    int Height() const { return SY(); }
    int ResX() const { return gdImageResolutionX(im); }
    int ResY() const { return gdImageResolutionY(im); }
    void GetSize(Size &s) const { s.set(SX(), SY()); }
    int ColorsTotal() const { return gdImageColorsTotal(im); }
    int Red(int color) const { return gdImageRed(im, color); }
    int Green(int color) const { return gdImageGreen(im, color); }
    int Blue(int color) const { return gdImageBlue(im, color); }
    int Alpha(int color) const { return gdImageAlpha(im, color); }
    int GetTransparent() const { return gdImageGetTransparent(im); }
    int GetInterlaced() const { return gdImageGetInterlaced(im); }
    int PalettePixel(int x, int y) const { return gdImagePalettePixel(im, x, y); }
    int TrueColorPixel(int x, int y) const { return gdImageTrueColorPixel(im, x, y); }
 
    const gdImagePtr GetPtr() const { return im; }
 
  protected:
    void clear()
    {
        if (im)
            gdImageDestroy(im);
        im = 0;
    }
    gdImagePtr im;
};
} // namespace GD
std::istream &operator>>(std::istream &in, GD::Image &img);
 
#endif /* __cplusplus */
#endif /* _gdpp_h */