summaryrefslogtreecommitdiff
path: root/Build/source/libs/gd/libgd-src/src/gdpp.h
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/gd/libgd-src/src/gdpp.h')
-rw-r--r--Build/source/libs/gd/libgd-src/src/gdpp.h1546
1 files changed, 1546 insertions, 0 deletions
diff --git a/Build/source/libs/gd/libgd-src/src/gdpp.h b/Build/source/libs/gd/libgd-src/src/gdpp.h
new file mode 100644
index 00000000000..2ebda162e1c
--- /dev/null
+++ b/Build/source/libs/gd/libgd-src/src/gdpp.h
@@ -0,0 +1,1546 @@
+/* *****************************************************************************
+** $Id$
+** 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.
+*******************************************************************************/
+/** \file gdpp.h
+ \brief Object Oriented C++ wrappers around libgd functionality.
+
+ Example usage, convert png to gif:
+ #include <fstream>
+ #include <gdpp.h>
+
+ std::ifstream in("image.png", std::ios_base::in | std::ios_base::binary );
+ GD::Image im(in, GD::Png_tag());
+ if (im.good())
+ {
+ std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary );
+ im.Gif(out);
+ }
+*/
+#ifdef __cplusplus
+#ifndef _gdpp_h
+#define _gdpp_h
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gd_io_stream.h"
+#include <string>
+
+/// namespace GD:: contains the C++ wrapper classes for libgd
+/** This namespace is primarily to avoid name clashes, and to
+ contain all of the gd classes within one namespace.
+ It is not recommended to use the "using namespace" directive with this namespace.
+ Example usage:
+ GD::Image im(64, 32, true); // Create a truecolor image 64 pixels wide by 32 pixels high
+ GD::Point pt(10, 8); // The point at x=10, y=8.
+ GD::Size sz(16, 8); // The size width=16, height=8.
+ GD::TrueColor col(0xFF, 0, 0); // The colour red; R=255, G=0, B=0.
+ im.Rectangle(pt, sz, col.Int()); // Draw a red rectangle with top left corner at pt, of size sz.
+*/
+namespace GD
+{
+/** This class GD::Point stores a point in two dimensions, somewhere
+ on the plane of an image.
+*/
+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;
+/** This class GD::Size stores length in two dimensions.
+ Giving the size of an area as width and height.
+*/
+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;
+
+/** This class GD::TrueColor stores a colour as an RGBA quadruplet.
+ It can also be read as an integer, and in other colour formats.
+*/
+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 {};
+
+/** This class GD::Image wraps all of the 'C' libgd functionality
+ for the convenience of C++ users. An instance of this class
+ corresponds to a single image.
+*/
+class BGD_EXPORT_DATA_PROT Image
+{
+public:
+ /** Construct a null image
+ */
+ Image()
+ :im(0)
+ {}
+ /** Construct a blank image, of the given size and colour format type.
+ \param[in] sx Width of the image
+ \param[in] sy Height of the image
+ \param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image.
+ */
+ Image(int sx, int sy, bool istruecolor = false)
+ :im(0) {
+ if (istruecolor)
+ CreateTrueColor(sx, sy);
+ else
+ Create(sx, sy);
+ }
+ /** Construct a blank image, of the given size and colour format type.
+ \param[in] s Width and height of the image
+ \param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image.
+ */
+ Image(const Size & s, bool istruecolor = false)
+ :im(0) {
+ if (istruecolor)
+ CreateTrueColor(s);
+ else
+ Create(s);
+ }
+ /** Construct an instance of the GD::Image class, given the internal gdImage poimter.
+ Note that gdImageDestroy will be called on the image pointer in the destructor.
+ \param[in] i Pointer to the internal gdImage
+ */
+ Image(gdImagePtr i)
+ :im(i) {}
+ /** Copy constructor. Construct an instance of the GD::Image class,
+ by making a copy of the GD::Image provided.
+ \param[in] i Reference to the image to be copied
+ */
+ Image(const GD::Image & i)
+ :im(0) {
+ Copy(i);
+ }
+ /** Construct an image by reading from \p in. This constructor
+ will first attempt to determine the file format.
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in)
+ :im(0) {
+ CreateFrom(in);
+ }
+ /** Construct an image by reading from \p in. This constructor
+ will first attempt to determine the file format.
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in)
+ :im(0) {
+ CreateFrom(in);
+ }
+ /** Construct an image by reading from memory block \p data. This constructor
+ will first attempt to determine the image formatting.
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data)
+ :im(0) {
+ CreateFrom(size, data);
+ }
+#ifdef HAVE_LIBPNG
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, Png_tag)
+ :im(0) {
+ CreateFromPng(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Png_tag)
+ :im(0) {
+ CreateFromPng(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, Png_tag)
+ :im(0) {
+ CreateFromPng(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::Png_tag()); // read a png file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, Png_tag)
+ :im(0) {
+ CreateFromPng(size, data);
+ }
+#endif
+
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, Gif_tag)
+ :im(0) {
+ CreateFromGif(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Gif_tag)
+ :im(0) {
+ CreateFromGif(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, Gif_tag)
+ :im(0) {
+ CreateFromGif(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::Gif_tag()); // read a gif file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, Gif_tag)
+ :im(0) {
+ CreateFromGif(size, data);
+ }
+
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, WBMP_tag)
+ :im(0) {
+ CreateFromWBMP(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, WBMP_tag)
+ :im(0) {
+ CreateFromWBMP(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, WBMP_tag)
+ :im(0) {
+ CreateFromWBMP(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::WBMP_tag()); // read a monchrome WBMP file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, WBMP_tag)
+ :im(0) {
+ CreateFromWBMP(size, data);
+ }
+
+#ifdef HAVE_LIBJPEG
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, Jpeg_tag)
+ :im(0) {
+ CreateFromJpeg(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Jpeg_tag)
+ :im(0) {
+ CreateFromJpeg(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, Jpeg_tag)
+ :im(0) {
+ CreateFromJpeg(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::Jpeg_tag()); // read a jpeg file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, Jpeg_tag)
+ :im(0) {
+ CreateFromJpeg(size, data);
+ }
+#endif
+
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, Gd_tag)
+ :im(0) {
+ CreateFromGd(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Gd_tag)
+ :im(0) {
+ CreateFromGd(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, Gd_tag)
+ :im(0) {
+ CreateFromGd(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::Gd_tag()); // read a gd file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, Gd_tag)
+ :im(0) {
+ CreateFromGd(size, data);
+ }
+
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input
+ \param[in] in The stream containing the image data
+ */
+ Image(std::istream & in, Gd2_tag)
+ :im(0) {
+ CreateFromGd2(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Gd2_tag)
+ :im(0) {
+ CreateFromGd2(in);
+ }
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input
+ \param[in] in The io context from which to read the image data
+ */
+ Image(gdIOCtx * in, Gd2_tag)
+ :im(0) {
+ CreateFromGd2(in);
+ }
+ /** Construct an image by reading from memory block \p data.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(sz, dat, GD::Gd2_tag()); // read a gd2 file from dat
+ \param[in] size The byte count of the memory block
+ \param[in] data Pointer to the memory block
+ */
+ Image(int size, void * data, Gd2_tag)
+ :im(0) {
+ CreateFromGd2(size, data);
+ }
+
+ /** Construct an image by reading from \p in.
+ The tag is an empty struct which simply tells the compiler which image read function to use.
+ e.g. GD::Image img(input, GD::Xbm_tag()); // read an xbm file from input
+ \param[in] in An opened FILE * handle to a file containing the image data
+ */
+ Image(FILE * in, Xbm_tag)
+ :im(0) {
+ CreateFromXbm(in);
+ }
+
+ ~Image() {
+ clear();
+ }
+
+ /** Assignment Operator. Make this a copy of the GD::Image provided.
+ \param[in] src Reference to the image to be copied
+ */
+ GD::Image & operator=(const GD::Image & src) {
+ Copy(src);
+ return (* this);
+ }
+ /** Make this an exact copy of the GD::Image provided. Any existing iamge data is discarded.
+ \param[in] src Reference to the image to be copied
+ */
+ 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);
+ }
+ /** Check to see if this appears to be a valid image
+ */
+ bool good() const {
+ return (im != 0);
+ }
+ // Creation:
+ /**
+ Create a palette-based image, with no more than 256 colors.
+ \param sx Width of the desired image
+ \param sy Height of the desired image
+ \return true if it worked, else false
+ */
+ bool Create(int sx, int sy) {
+ clear();
+ return ((im = gdImageCreate(sx, sy)) != 0);
+ }
+ /**
+ Create a truecolor image.
+ \param sx Width of the desired image
+ \param sy Height of the desired image
+ \return true if it worked, else false
+ */
+ bool CreateTrueColor(int sx, int sy) {
+ clear();
+ return ((im = gdImageCreateTrueColor(sx, sy)) != 0);
+ }
+ /**
+ Create a palette-based image, with no more than 256 colors.
+ \param s Width and height of the desired image
+ \return true if it worked, else false
+ */
+ bool Create(const Size & s) {
+ return Create(s.W(), s.H());
+ }
+ /**
+ Create a truecolor image.
+ \param s Width and height of the desired image
+ \return true if it worked, else false
+ */
+ bool CreateTrueColor(const Size & s) {
+ return CreateTrueColor(s.W(), s.H());
+ }
+ // Create, determining the image format from the data
+ /// Read an image from an open FILE * handle, after determining the image format
+ bool CreateFrom(FILE * in);
+ /// Read an image from an open standard library input stream, after determining the image format
+ bool CreateFrom(std::istream & in);
+ /// Read an image from a memory block, after determining the image format
+ bool CreateFrom(int size, void * data);
+
+#ifdef HAVE_LIBPNG
+ // Png
+ bool CreateFromPng(FILE * in) {
+ clear();
+ return ((im = gdImageCreateFromPng(in)) != 0);
+ }
+ bool CreateFromPng(gdIOCtx * 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);
+ }
+#endif
+
+ // Gif
+ bool CreateFromGif(FILE * in) {
+ clear();
+ return ((im = gdImageCreateFromGif(in)) != 0);
+ }
+ bool CreateFromGif(gdIOCtx * 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(gdIOCtx * 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);
+ }
+
+#ifdef HAVE_LIBJPEG
+ // Jpeg
+ /**
+ Load a truecolor image from a JPEG format file.
+ Invoke CreateFromJpeg with an already opened
+ pointer to a file containing the desired image.
+ CreateFromJpeg does not close the file.
+ \return true for success, or false if unable to load the image (most often because
+ the file is corrupt or does not contain a JPEG image).
+ You can call Width() and Height() member functions of the image to determine its
+ size. The returned image is always a truecolor image.
+ */
+ bool CreateFromJpeg(FILE * in) {
+ clear();
+ return ((im = gdImageCreateFromJpeg(in)) != 0);
+ }
+ /**
+ Load a truecolor image from a JPEG format file.
+ Invoke CreateFromJpeg with an already opened
+ pointer to a file containing the desired image.
+ CreateFromJpeg does not close the file.
+ \return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image).
+ You can call Width() and Height() member functions of the image to determine its
+ size. The returned image is always a truecolor image.
+ */
+ bool CreateFromJpeg(gdIOCtx * in) {
+ clear();
+ return ((im = gdImageCreateFromJpegCtx(in)) != 0);
+ }
+ /**
+ Load a truecolor image from a JPEG format file.
+ Invoke CreateFromJpeg with an already opened
+ pointer to a file containing the desired image.
+ CreateFromJpeg does not close the file.
+ \return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image).
+ You can call Width() and Height() member functions of the image to determine its
+ size. The returned image is always a truecolor image.
+ */
+ bool CreateFromJpeg(int size, void * data) {
+ clear();
+ return ((im = gdImageCreateFromJpegPtr(size, data)) != 0);
+ }
+ /**
+ Load a truecolor image from a JPEG format file.
+ Invoke CreateFromJpeg with an image file in memory.
+ \return true for success, or false if unable to load the image (most often because the format is corrupt or does not contain a JPEG image).
+ You can call Width() and Height() member functions of the image to determine its
+ size. The returned image is always a truecolor image.
+ */
+ bool CreateFromJpeg(std::istream & in) {
+ clear();
+ istreamIOCtx _in_ctx(in);
+ return ((im = gdImageCreateFromJpegCtx( & _in_ctx)) != 0);
+ }
+#endif
+
+ // Gd
+ bool CreateFromGd(FILE * in) {
+ clear();
+ return ((im = gdImageCreateFromGd(in)) != 0);
+ }
+ bool CreateFromGd(gdIOCtx * 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(gdIOCtx * 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(gdIOCtx * 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(gdIOCtx * 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 (gdImageBoundsSafe(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);
+ }
+
+ /**
+ Write out this image in GIF file format to \p out.
+ \param out A FILE * handle
+ */
+ void Gif(FILE * out) const {
+ gdImageGif(im, out);
+ }
+ /**
+ Write out this image in GIF file format to \p out.
+ \param out A gdIOCtx * handle
+ */
+ void Gif(gdIOCtx * out) const {
+ gdImageGifCtx(im, out);
+ }
+ /**
+ Allocate sufficient memory, and write this image, in GIF file format, to that memory.
+ \param size A pointer for the allocated memory
+ \return A pointer to the allocated memory, containing the image GIF file formatted. Caller is responsible for freeing with gdFree().
+ */
+ void * Gif(int * size) const {
+ return gdImageGifPtr(im, size);
+ }
+ /**
+ Write out this image in GIF file format to \p out.
+ \param out An output stream, already opened.
+ */
+ void Gif(std::ostream & out) const {
+ ostreamIOCtx _out_ctx(out);
+ gdImageGifCtx(im, & _out_ctx);
+ }
+
+#ifdef HAVE_LIBPNG
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out A FILE * handle
+ */
+ void Png(FILE * out) const {
+ gdImagePng(im, out);
+ }
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out A gdIOCtx * handle
+ */
+ void Png(gdIOCtx * out) const {
+ gdImagePngCtx(im, out);
+ }
+ /**
+ Allocate sufficient memory, and write this image, in PNG file format, to that memory.
+ \param size A pointer for the allocated memory
+ \return A pointer to the allocated memory, containing the image PNG file formatted. Caller is responsible for freeing with gdFree().
+ */
+ void * Png(int * size) const {
+ return gdImagePngPtr(im, size);
+ }
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out An output stream, already opened.
+ */
+ void Png(std::ostream & out) const {
+ ostreamIOCtx _out_ctx(out);
+ gdImagePngCtx(im, & _out_ctx);
+ }
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out A FILE * handle
+ \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level
+ */
+ void Png(FILE * out, int level) const {
+ gdImagePngEx(im, out, level);
+ }
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out A gdIOCtx * handle
+ \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level
+ */
+ void Png(gdIOCtx * out, int level) const {
+ gdImagePngCtxEx(im, out, level);
+ }
+ /**
+ Allocate sufficient memory, and write this image, in PNG file format, to that memory.
+ \param size A pointer for the allocated memory
+ \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level
+ \return A pointer to the allocated memory, containing the image PNG file formatted. Caller is responsible for freeing with gdFree().
+ */
+ void * Png(int * size, int level) const {
+ return gdImagePngPtrEx(im, size, level);
+ }
+ /**
+ Write out this image in PNG file format to \p out.
+ \param out An output stream, already opened.
+ \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level
+ */
+ void Png(std::ostream & out, int level) const {
+ ostreamIOCtx _out_ctx(out);
+ gdImagePngCtxEx(im, & _out_ctx, level);
+ }
+#endif
+
+ /**
+ Write out this image in WBMP file format ( black and white only ) to \p out.
+ \param fg The color index of the foreground. All other pixels considered background.
+ \param out A FILE * handle
+ */
+ void WBMP(int fg, FILE * out) const {
+ gdImageWBMP(im, fg, out);
+ }
+ /**
+ Write out this image in WBMP file format ( black and white only ) to \p out.
+ \param fg The color index of the foreground. All other pixels considered background.
+ \param out A gdIOCtx * handle
+ */
+ void WBMP(int fg, gdIOCtx * out) const {
+ gdImageWBMPCtx(im, fg, out);
+ }
+ /**
+ Allocate sufficient memory, and write this image, in WBMP file format ( black and white only ), to that memory.
+ \param size A pointer for the allocated memory
+ \param fg The color index of the foreground. All other pixels considered background.
+ \return A pointer to the allocated memory, containing the image WBMP file formatted. Caller is responsible for freeing with gdFree().
+ */
+ void * WBMP(int * size, int fg) const {
+ return gdImageWBMPPtr(im, size, fg);
+ }
+ /**
+ Write out this image in WBMP file format ( black and white only ) to \p out.
+ \param fg The color index of the foreground. All other pixels considered background.
+ \param out An output stream, already opened.
+ */
+ void WBMP(int fg, std::ostream & out) const {
+ ostreamIOCtx _out_ctx(out);
+ gdImageWBMPCtx(im, fg, & _out_ctx);
+ }
+
+#ifdef HAVE_LIBJPEG
+ /**
+ Write out this image in JPEG file format to \p out.
+ \param out A FILE * handle
+ \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value".
+ */
+ void Jpeg(FILE * out, int quality = -1) const {
+ gdImageJpeg(im, out, quality);
+ }
+ /**
+ Write out this image in JPEG file format to \p out.
+ \param out A gdIOCtx * handle
+ \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value".
+ */
+ void Jpeg(gdIOCtx * out, int quality = -1) const {
+ gdImageJpegCtx(im, out, quality);
+ }
+ /**
+ Allocate sufficient memory, and write this image, in JPEG file format, to that memory.
+ \param size A pointer for the allocated memory
+ \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value".
+ \return A pointer to the allocated memory, containing the image JPEG file formatted. Caller is responsible for freeing with gdFree().
+ */
+ void * Jpeg(int * size, int quality = -1) const {
+ return gdImageJpegPtr(im, size, quality);
+ }
+ /**
+ Write out this image in JPEG file format to \p out.
+ \param out An output stream, already opened.
+ \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value".
+ */
+ void Jpeg(std::ostream & out, int quality = -1) const {
+ ostreamIOCtx _out_ctx(out);
+ gdImageJpegCtx(im, & _out_ctx, quality);
+ }
+#endif
+
+ 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(gdIOCtx * out, int GlobalCM, int Loops) const {
+ gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
+ }
+ void GifAnimAdd(gdIOCtx * 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(gdIOCtx * 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(gdIOCtx * 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);
+ }
+ /**
+ Draw a partial ellipse centered at the given point, with the specified width and height in pixels.
+ */
+ 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:
+ /// Free the internal image pointer
+ void clear() {
+ if (im)
+ gdImageDestroy(im);
+ im = 0;
+ }
+ gdImagePtr im;
+};
+} // namespace GD
+/// Read in an image from a standard library input stream
+std::istream & operator>> (std::istream & in, GD::Image & img);
+
+#endif /* _gdpp_h */
+#endif /* __cplusplus */