ansilove

ANSI and ASCII art to PNG converter in C
Log | Files | Refs | README | LICENSE

commit 52c42cdea17a6d0ed5461296970aaa43812be193
parent 159ef135cef5a6e63411b5b4bb0a3e71884e030c
Author: ByteProject <stefan.vogt@byteproject.net>
Date:   Tue,  4 Mar 2014 22:35:47 +0100

upgrading bundled libgd binary for OS X to 2.1

Diffstat:
Mlib/MacOSX/libgd/include/entities.h | 514++++++++++++++++++++++++++++++++++++++++----------------------------------------
Mlib/MacOSX/libgd/include/gd.h | 1124++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------
Alib/MacOSX/libgd/include/gd_color_map.h | 30++++++++++++++++++++++++++++++
Alib/MacOSX/libgd/include/gd_errors.h | 46++++++++++++++++++++++++++++++++++++++++++++++
Mlib/MacOSX/libgd/include/gd_io.h | 71++++++++++++++++++++++++++++++++++-------------------------------------
Mlib/MacOSX/libgd/include/gdcache.h | 143++++++++++++++++++++++++++++++++++++++-----------------------------------------
Mlib/MacOSX/libgd/include/gdfontg.h | 14++------------
Mlib/MacOSX/libgd/include/gdfontl.h | 14++------------
Mlib/MacOSX/libgd/include/gdfontmb.h | 14++------------
Mlib/MacOSX/libgd/include/gdfonts.h | 14++------------
Mlib/MacOSX/libgd/include/gdfontt.h | 14++------------
Mlib/MacOSX/libgd/include/gdfx.h | 58++++++++++++++++++++++++++++------------------------------
Alib/MacOSX/libgd/include/gdpp.h | 1497+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Dlib/MacOSX/libgd/libgd.2.0.0.dylib | 0
Alib/MacOSX/libgd/libgd.3.dylib | 0
15 files changed, 2684 insertions(+), 869 deletions(-)

diff --git a/lib/MacOSX/libgd/include/entities.h b/lib/MacOSX/libgd/include/entities.h @@ -11,263 +11,263 @@ extern "C" { #endif -static struct entities_s { - char *name; - int value; -} entities[] = { - {"AElig", 198}, - {"Aacute", 193}, - {"Acirc", 194}, - {"Agrave", 192}, - {"Alpha", 913}, - {"Aring", 197}, - {"Atilde", 195}, - {"Auml", 196}, - {"Beta", 914}, - {"Ccedil", 199}, - {"Chi", 935}, - {"Dagger", 8225}, - {"Delta", 916}, - {"ETH", 208}, - {"Eacute", 201}, - {"Ecirc", 202}, - {"Egrave", 200}, - {"Epsilon", 917}, - {"Eta", 919}, - {"Euml", 203}, - {"Gamma", 915}, - {"Iacute", 205}, - {"Icirc", 206}, - {"Igrave", 204}, - {"Iota", 921}, - {"Iuml", 207}, - {"Kappa", 922}, - {"Lambda", 923}, - {"Mu", 924}, - {"Ntilde", 209}, - {"Nu", 925}, - {"OElig", 338}, - {"Oacute", 211}, - {"Ocirc", 212}, - {"Ograve", 210}, - {"Omega", 937}, - {"Omicron", 927}, - {"Oslash", 216}, - {"Otilde", 213}, - {"Ouml", 214}, - {"Phi", 934}, - {"Pi", 928}, - {"Prime", 8243}, - {"Psi", 936}, - {"Rho", 929}, - {"Scaron", 352}, - {"Sigma", 931}, - {"THORN", 222}, - {"Tau", 932}, - {"Theta", 920}, - {"Uacute", 218}, - {"Ucirc", 219}, - {"Ugrave", 217}, - {"Upsilon", 933}, - {"Uuml", 220}, - {"Xi", 926}, - {"Yacute", 221}, - {"Yuml", 376}, - {"Zeta", 918}, - {"aacute", 225}, - {"acirc", 226}, - {"acute", 180}, - {"aelig", 230}, - {"agrave", 224}, - {"alefsym", 8501}, - {"alpha", 945}, - {"amp", 38}, - {"and", 8743}, - {"ang", 8736}, - {"aring", 229}, - {"asymp", 8776}, - {"atilde", 227}, - {"auml", 228}, - {"bdquo", 8222}, - {"beta", 946}, - {"brvbar", 166}, - {"bull", 8226}, - {"cap", 8745}, - {"ccedil", 231}, - {"cedil", 184}, - {"cent", 162}, - {"chi", 967}, - {"circ", 710}, - {"clubs", 9827}, - {"cong", 8773}, - {"copy", 169}, - {"crarr", 8629}, - {"cup", 8746}, - {"curren", 164}, - {"dArr", 8659}, - {"dagger", 8224}, - {"darr", 8595}, - {"deg", 176}, - {"delta", 948}, - {"diams", 9830}, - {"divide", 247}, - {"eacute", 233}, - {"ecirc", 234}, - {"egrave", 232}, - {"empty", 8709}, - {"emsp", 8195}, - {"ensp", 8194}, - {"epsilon", 949}, - {"equiv", 8801}, - {"eta", 951}, - {"eth", 240}, - {"euml", 235}, - {"euro", 8364}, - {"exist", 8707}, - {"fnof", 402}, - {"forall", 8704}, - {"frac12", 189}, - {"frac14", 188}, - {"frac34", 190}, - {"frasl", 8260}, - {"gamma", 947}, - {"ge", 8805}, - {"gt", 62}, - {"hArr", 8660}, - {"harr", 8596}, - {"hearts", 9829}, - {"hellip", 8230}, - {"iacute", 237}, - {"icirc", 238}, - {"iexcl", 161}, - {"igrave", 236}, - {"image", 8465}, - {"infin", 8734}, - {"int", 8747}, - {"iota", 953}, - {"iquest", 191}, - {"isin", 8712}, - {"iuml", 239}, - {"kappa", 954}, - {"lArr", 8656}, - {"lambda", 955}, - {"lang", 9001}, - {"laquo", 171}, - {"larr", 8592}, - {"lceil", 8968}, - {"ldquo", 8220}, - {"le", 8804}, - {"lfloor", 8970}, - {"lowast", 8727}, - {"loz", 9674}, - {"lrm", 8206}, - {"lsaquo", 8249}, - {"lsquo", 8216}, - {"lt", 60}, - {"macr", 175}, - {"mdash", 8212}, - {"micro", 181}, - {"middot", 183}, - {"minus", 8722}, - {"mu", 956}, - {"nabla", 8711}, - {"nbsp", 160}, - {"ndash", 8211}, - {"ne", 8800}, - {"ni", 8715}, - {"not", 172}, - {"notin", 8713}, - {"nsub", 8836}, - {"ntilde", 241}, - {"nu", 957}, - {"oacute", 243}, - {"ocirc", 244}, - {"oelig", 339}, - {"ograve", 242}, - {"oline", 8254}, - {"omega", 969}, - {"omicron", 959}, - {"oplus", 8853}, - {"or", 8744}, - {"ordf", 170}, - {"ordm", 186}, - {"oslash", 248}, - {"otilde", 245}, - {"otimes", 8855}, - {"ouml", 246}, - {"para", 182}, - {"part", 8706}, - {"permil", 8240}, - {"perp", 8869}, - {"phi", 966}, - {"pi", 960}, - {"piv", 982}, - {"plusmn", 177}, - {"pound", 163}, - {"prime", 8242}, - {"prod", 8719}, - {"prop", 8733}, - {"psi", 968}, - {"quot", 34}, - {"rArr", 8658}, - {"radic", 8730}, - {"rang", 9002}, - {"raquo", 187}, - {"rarr", 8594}, - {"rceil", 8969}, - {"rdquo", 8221}, - {"real", 8476}, - {"reg", 174}, - {"rfloor", 8971}, - {"rho", 961}, - {"rlm", 8207}, - {"rsaquo", 8250}, - {"rsquo", 8217}, - {"sbquo", 8218}, - {"scaron", 353}, - {"sdot", 8901}, - {"sect", 167}, - {"shy", 173}, - {"sigma", 963}, - {"sigmaf", 962}, - {"sim", 8764}, - {"spades", 9824}, - {"sub", 8834}, - {"sube", 8838}, - {"sum", 8721}, - {"sup", 8835}, - {"sup1", 185}, - {"sup2", 178}, - {"sup3", 179}, - {"supe", 8839}, - {"szlig", 223}, - {"tau", 964}, - {"there4", 8756}, - {"theta", 952}, - {"thetasym", 977}, - {"thinsp", 8201}, - {"thorn", 254}, - {"tilde", 732}, - {"times", 215}, - {"trade", 8482}, - {"uArr", 8657}, - {"uacute", 250}, - {"uarr", 8593}, - {"ucirc", 251}, - {"ugrave", 249}, - {"uml", 168}, - {"upsih", 978}, - {"upsilon", 965}, - {"uuml", 252}, - {"weierp", 8472}, - {"xi", 958}, - {"yacute", 253}, - {"yen", 165}, - {"yuml", 255}, - {"zeta", 950}, - {"zwj", 8205}, - {"zwnj", 8204}, -}; + static struct entities_s { + char *name; + int value; + } entities[] = { + {"AElig", 198}, + {"Aacute", 193}, + {"Acirc", 194}, + {"Agrave", 192}, + {"Alpha", 913}, + {"Aring", 197}, + {"Atilde", 195}, + {"Auml", 196}, + {"Beta", 914}, + {"Ccedil", 199}, + {"Chi", 935}, + {"Dagger", 8225}, + {"Delta", 916}, + {"ETH", 208}, + {"Eacute", 201}, + {"Ecirc", 202}, + {"Egrave", 200}, + {"Epsilon", 917}, + {"Eta", 919}, + {"Euml", 203}, + {"Gamma", 915}, + {"Iacute", 205}, + {"Icirc", 206}, + {"Igrave", 204}, + {"Iota", 921}, + {"Iuml", 207}, + {"Kappa", 922}, + {"Lambda", 923}, + {"Mu", 924}, + {"Ntilde", 209}, + {"Nu", 925}, + {"OElig", 338}, + {"Oacute", 211}, + {"Ocirc", 212}, + {"Ograve", 210}, + {"Omega", 937}, + {"Omicron", 927}, + {"Oslash", 216}, + {"Otilde", 213}, + {"Ouml", 214}, + {"Phi", 934}, + {"Pi", 928}, + {"Prime", 8243}, + {"Psi", 936}, + {"Rho", 929}, + {"Scaron", 352}, + {"Sigma", 931}, + {"THORN", 222}, + {"Tau", 932}, + {"Theta", 920}, + {"Uacute", 218}, + {"Ucirc", 219}, + {"Ugrave", 217}, + {"Upsilon", 933}, + {"Uuml", 220}, + {"Xi", 926}, + {"Yacute", 221}, + {"Yuml", 376}, + {"Zeta", 918}, + {"aacute", 225}, + {"acirc", 226}, + {"acute", 180}, + {"aelig", 230}, + {"agrave", 224}, + {"alefsym", 8501}, + {"alpha", 945}, + {"amp", 38}, + {"and", 8743}, + {"ang", 8736}, + {"aring", 229}, + {"asymp", 8776}, + {"atilde", 227}, + {"auml", 228}, + {"bdquo", 8222}, + {"beta", 946}, + {"brvbar", 166}, + {"bull", 8226}, + {"cap", 8745}, + {"ccedil", 231}, + {"cedil", 184}, + {"cent", 162}, + {"chi", 967}, + {"circ", 710}, + {"clubs", 9827}, + {"cong", 8773}, + {"copy", 169}, + {"crarr", 8629}, + {"cup", 8746}, + {"curren", 164}, + {"dArr", 8659}, + {"dagger", 8224}, + {"darr", 8595}, + {"deg", 176}, + {"delta", 948}, + {"diams", 9830}, + {"divide", 247}, + {"eacute", 233}, + {"ecirc", 234}, + {"egrave", 232}, + {"empty", 8709}, + {"emsp", 8195}, + {"ensp", 8194}, + {"epsilon", 949}, + {"equiv", 8801}, + {"eta", 951}, + {"eth", 240}, + {"euml", 235}, + {"euro", 8364}, + {"exist", 8707}, + {"fnof", 402}, + {"forall", 8704}, + {"frac12", 189}, + {"frac14", 188}, + {"frac34", 190}, + {"frasl", 8260}, + {"gamma", 947}, + {"ge", 8805}, + {"gt", 62}, + {"hArr", 8660}, + {"harr", 8596}, + {"hearts", 9829}, + {"hellip", 8230}, + {"iacute", 237}, + {"icirc", 238}, + {"iexcl", 161}, + {"igrave", 236}, + {"image", 8465}, + {"infin", 8734}, + {"int", 8747}, + {"iota", 953}, + {"iquest", 191}, + {"isin", 8712}, + {"iuml", 239}, + {"kappa", 954}, + {"lArr", 8656}, + {"lambda", 955}, + {"lang", 9001}, + {"laquo", 171}, + {"larr", 8592}, + {"lceil", 8968}, + {"ldquo", 8220}, + {"le", 8804}, + {"lfloor", 8970}, + {"lowast", 8727}, + {"loz", 9674}, + {"lrm", 8206}, + {"lsaquo", 8249}, + {"lsquo", 8216}, + {"lt", 60}, + {"macr", 175}, + {"mdash", 8212}, + {"micro", 181}, + {"middot", 183}, + {"minus", 8722}, + {"mu", 956}, + {"nabla", 8711}, + {"nbsp", 160}, + {"ndash", 8211}, + {"ne", 8800}, + {"ni", 8715}, + {"not", 172}, + {"notin", 8713}, + {"nsub", 8836}, + {"ntilde", 241}, + {"nu", 957}, + {"oacute", 243}, + {"ocirc", 244}, + {"oelig", 339}, + {"ograve", 242}, + {"oline", 8254}, + {"omega", 969}, + {"omicron", 959}, + {"oplus", 8853}, + {"or", 8744}, + {"ordf", 170}, + {"ordm", 186}, + {"oslash", 248}, + {"otilde", 245}, + {"otimes", 8855}, + {"ouml", 246}, + {"para", 182}, + {"part", 8706}, + {"permil", 8240}, + {"perp", 8869}, + {"phi", 966}, + {"pi", 960}, + {"piv", 982}, + {"plusmn", 177}, + {"pound", 163}, + {"prime", 8242}, + {"prod", 8719}, + {"prop", 8733}, + {"psi", 968}, + {"quot", 34}, + {"rArr", 8658}, + {"radic", 8730}, + {"rang", 9002}, + {"raquo", 187}, + {"rarr", 8594}, + {"rceil", 8969}, + {"rdquo", 8221}, + {"real", 8476}, + {"reg", 174}, + {"rfloor", 8971}, + {"rho", 961}, + {"rlm", 8207}, + {"rsaquo", 8250}, + {"rsquo", 8217}, + {"sbquo", 8218}, + {"scaron", 353}, + {"sdot", 8901}, + {"sect", 167}, + {"shy", 173}, + {"sigma", 963}, + {"sigmaf", 962}, + {"sim", 8764}, + {"spades", 9824}, + {"sub", 8834}, + {"sube", 8838}, + {"sum", 8721}, + {"sup", 8835}, + {"sup1", 185}, + {"sup2", 178}, + {"sup3", 179}, + {"supe", 8839}, + {"szlig", 223}, + {"tau", 964}, + {"there4", 8756}, + {"theta", 952}, + {"thetasym", 977}, + {"thinsp", 8201}, + {"thorn", 254}, + {"tilde", 732}, + {"times", 215}, + {"trade", 8482}, + {"uArr", 8657}, + {"uacute", 250}, + {"uarr", 8593}, + {"ucirc", 251}, + {"ugrave", 249}, + {"uml", 168}, + {"upsih", 978}, + {"upsilon", 965}, + {"uuml", 252}, + {"weierp", 8472}, + {"xi", 958}, + {"yacute", 253}, + {"yen", 165}, + {"yuml", 255}, + {"zeta", 950}, + {"zwj", 8205}, + {"zwnj", 8204}, + }; #define ENTITY_NAME_LENGTH_MAX 8 #define NR_OF_ENTITIES 252 diff --git a/lib/MacOSX/libgd/include/gd.h b/lib/MacOSX/libgd/include/gd.h @@ -6,75 +6,62 @@ extern "C" { #define GD_H 1 #define GD_MAJOR_VERSION 2 -#define GD_MINOR_VERSION 0 -#define GD_RELEASE_VERSION 36 -#define GD_EXTRA_VERSION "" -#define GD_VERSION_STRING "2.0.36" - +#define GD_MINOR_VERSION 1 +#define GD_RELEASE_VERSION 0 +#define GD_EXTRA_VERSION "alpha" +#define GD_VERSION_STRING "2.1.0-alpha" /* Do the DLL dance: dllexport when building the DLL, - dllimport when importing from it, nothing when - not on Silly Silly Windows (tm Aardman Productions). */ + dllimport when importing from it, nothing when + not on Silly Silly Windows (tm Aardman Productions). */ /* 2.0.20: for headers */ -/* 2.0.24: __stdcall also needed for Visual BASIC - and other languages. This breaks ABI compatibility - with previous DLL revs, but it's necessary. */ +/* 2.0.24: __stdcall also needed for Visual BASIC + and other languages. This breaks ABI compatibility + with previous DLL revs, but it's necessary. */ /* 2.0.29: WIN32 programmers can declare the NONDLL macro if they - wish to build gd as a static library or by directly including - the gd sources in a project. */ - -#ifndef WIN32 -#define NONDLL 1 -#endif /* WIN32 */ - -#ifdef NONDLL -#define BGD_DECLARE(rt) extern rt -#else -#ifdef BGDWIN32 -#define BGD_DECLARE(rt) __declspec(dllexport) rt __stdcall -#else -#define BGD_DECLARE(rt) __declspec(dllimport) rt _stdcall -#endif /* BGDWIN32 */ -#endif /* NONDLL */ - -/* 2.0.20: for actual storage of exported data, functions don't need this, - currently needed only for font pointers */ -#ifdef NONDLL -/* 2.0.25: bring back extern */ -#define BGD_EXPORT_DATA_PROT extern -#define BGD_EXPORT_DATA_IMPL + wish to build gd as a static library or by directly including + the gd sources in a project. */ + +/* http://gcc.gnu.org/wiki/Visibility */ +#if defined(_WIN32) || defined(CYGWIN) || defined(_WIN32_WCE) +# ifdef BGDWIN32 +# ifdef NONDLL +# define BGD_EXPORT_DATA_PROT +# else +# ifdef __GNUC__ +# define BGD_EXPORT_DATA_PROT __attribute__ ((dllexport)) +# else +# define BGD_EXPORT_DATA_PROT __declspec(dllexport) +# endif +# endif +# else +# ifdef __GNUC__ +# define BGD_EXPORT_DATA_PROT __attribute__ ((dllimport)) +# else +# define BGD_EXPORT_DATA_PROT __declspec(dllimport) +# endif +# endif +# define BGD_STDCALL __stdcall +# define BGD_EXPORT_DATA_IMPL #else -#ifdef BGDWIN32 -#define BGD_EXPORT_DATA_PROT __declspec(dllexport) extern -#define BGD_EXPORT_DATA_IMPL __declspec(dllexport) -#else -#define BGD_EXPORT_DATA_PROT __declspec(dllimport) extern -#define BGD_EXPORT_DATA_IMPL __declspec(dllimport) -#endif /* BGDWIN32 */ -#endif /* NONDLL */ - -#ifdef __cplusplus -extern "C" -{ +# ifdef HAVE_VISIBILITY +# define BGD_EXPORT_DATA_PROT __attribute__ ((visibility ("default"))) +# define BGD_EXPORT_DATA_IMPL __attribute__ ((visibility ("hidden"))) +# else +# define BGD_EXPORT_DATA_PROT +# define BGD_EXPORT_DATA_IMPL +# endif +# define BGD_STDCALL #endif -/* some might want to set DEFAULT_FONTPATH from configure in config.h */ -#ifdef NETWARE -/* default fontpath for netware systems, could probably be handled in configure for 2.1 */ -#define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf;." -#define PATHSEPARATOR ";" -#endif +#define BGD_DECLARE(rt) BGD_EXPORT_DATA_PROT rt BGD_STDCALL -/* 2.0.23: more Type 1 fonts */ -#ifndef DEFAULT_FONTPATH -/* default fontpath for unix systems - whatever happened to standards ! */ -#define DEFAULT_FONTPATH "/usr/X11R6/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/truetype:/usr/X11R6/lib/X11/fonts/TTF:/usr/share/fonts/TrueType:/usr/share/fonts/truetype:/usr/openwin/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/Type1:/usr/lib/X11/fonts/Type1:/usr/openwin/lib/X11/fonts/Type1" -#endif -#ifndef PATHSEPARATOR -#define PATHSEPARATOR ":" +#ifdef __cplusplus + extern "C" + { #endif /* gd.h: declarations file for the graphic-draw module. @@ -83,41 +70,42 @@ extern "C" * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation. This software is provided "AS IS." Thomas Boutell and - * Boutell.Com, Inc. disclaim all warranties, either express or implied, - * including but not limited to implied warranties of merchantability and + * Boutell.Com, Inc. disclaim all warranties, either express or implied, + * including but not limited to implied warranties of merchantability and * fitness for a particular purpose, with respect to this code and accompanying * documentation. */ /* stdio is needed for file I/O. */ #include <stdio.h> +#include <stdarg.h> #include "gd_io.h" /* The maximum number of palette entries in palette-based images. - In the wonderful new world of gd 2.0, you can of course have - many more colors when using truecolor mode. */ + In the wonderful new world of gd 2.0, you can of course have + many more colors when using truecolor mode. */ #define gdMaxColors 256 /* Image type. See functions below; you will not need to change - the elements directly. Use the provided macros to - access sx, sy, the color table, and colorsTotal for - read-only purposes. */ - -/* If 'truecolor' is set true, the image is truecolor; - pixels are represented by integers, which - must be 32 bits wide or more. - - True colors are repsented as follows: - - ARGB - - Where 'A' (alpha channel) occupies only the - LOWER 7 BITS of the MSB. This very small - loss of alpha channel resolution allows gd 2.x - to keep backwards compatibility by allowing - signed integers to be used to represent colors, - and negative numbers to represent special cases, - just as in gd 1.x. */ + the elements directly. Use the provided macros to + access sx, sy, the color table, and colorsTotal for + read-only purposes. */ + +/* If 'truecolor' is set true, the image is truecolor; + pixels are represented by integers, which + must be 32 bits wide or more. + + True colors are repsented as follows: + + ARGB + + Where 'A' (alpha channel) occupies only the + LOWER 7 BITS of the MSB. This very small + loss of alpha channel resolution allows gd 2.x + to keep backwards compatibility by allowing + signed integers to be used to represent colors, + and negative numbers to represent special cases, + just as in gd 1.x. */ #define gdAlphaMax 127 #define gdAlphaOpaque 0 @@ -129,119 +117,244 @@ extern "C" #define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16) #define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8) #define gdTrueColorGetBlue(c) ((c) & 0x0000FF) +#define gdEffectReplace 0 +#define gdEffectAlphaBlend 1 +#define gdEffectNormal 2 +#define gdEffectOverlay 3 -/* This function accepts truecolor pixel values only. The - source color is composited with the destination color - based on the alpha channel value of the source color. - The resulting color is opaque. */ +#define GD_TRUE 1 +#define GD_FALSE 0 + +#define GD_EPSILON 1e-6 +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +/* This function accepts truecolor pixel values only. The + source color is composited with the destination color + based on the alpha channel value of the source color. + The resulting color is opaque. */ BGD_DECLARE(int) gdAlphaBlend (int dest, int src); - typedef struct gdImageStruct - { - /* Palette-based image pixels */ - unsigned char **pixels; - int sx; - int sy; - /* These are valid in palette images only. See also - 'alpha', which appears later in the structure to - preserve binary backwards compatibility */ - int colorsTotal; - int red[gdMaxColors]; - int green[gdMaxColors]; - int blue[gdMaxColors]; - int open[gdMaxColors]; - /* For backwards compatibility, this is set to the - first palette entry with 100% transparency, - and is also set and reset by the - gdImageColorTransparent function. Newer - applications can allocate palette entries - with any desired level of transparency; however, - bear in mind that many viewers, notably - many web browsers, fail to implement - full alpha channel for PNG and provide - support for full opacity or transparency only. */ - int transparent; - int *polyInts; - int polyAllocated; - struct gdImageStruct *brush; - struct gdImageStruct *tile; - int brushColorMap[gdMaxColors]; - int tileColorMap[gdMaxColors]; - int styleLength; - int stylePos; - int *style; - int interlace; - /* New in 2.0: thickness of line. Initialized to 1. */ - int thick; - /* New in 2.0: alpha channel for palettes. Note that only - Macintosh Internet Explorer and (possibly) Netscape 6 - really support multiple levels of transparency in - palettes, to my knowledge, as of 2/15/01. Most - common browsers will display 100% opaque and - 100% transparent correctly, and do something - unpredictable and/or undesirable for levels - in between. TBB */ - int alpha[gdMaxColors]; - /* Truecolor flag and pixels. New 2.0 fields appear here at the - end to minimize breakage of existing object code. */ - int trueColor; - int **tpixels; - /* Should alpha channel be copied, or applied, each time a - pixel is drawn? This applies to truecolor images only. - No attempt is made to alpha-blend in palette images, - even if semitransparent palette entries exist. - To do that, build your image as a truecolor image, - then quantize down to 8 bits. */ - int alphaBlendingFlag; - /* Should the alpha channel of the image be saved? This affects - PNG at the moment; other future formats may also - have that capability. JPEG doesn't. */ - int saveAlphaFlag; - - /* There should NEVER BE ACCESSOR MACROS FOR ITEMS BELOW HERE, so this - part of the structure can be safely changed in new releases. */ - - /* 2.0.12: anti-aliased globals. 2.0.26: just a few vestiges after - switching to the fast, memory-cheap implementation from PHP-gd. */ - int AA; - int AA_color; - int AA_dont_blend; - - /* 2.0.12: simple clipping rectangle. These values - must be checked for safety when set; please use - gdImageSetClip */ - int cx1; - int cy1; - int cx2; - int cy2; - } - gdImage; - - typedef gdImage *gdImagePtr; - - typedef struct - { - /* # of characters in font */ - int nchars; - /* First character is numbered... (usually 32 = space) */ - int offset; - /* Character width and height */ - int w; - int h; - /* Font data; array of characters, one row after another. - Easily included in code, also easily loaded from - data files. */ - char *data; - } - gdFont; +enum gdPaletteQuantizationMethod { + GD_QUANT_DEFAULT = 0, + GD_QUANT_JQUANT = 1, /* libjpeg's old median cut. Fast, but only uses 16-bit color. */ + GD_QUANT_NEUQUANT = 2, /* neuquant - approximation using kohonen neural network. */ + GD_QUANT_LIQ = 3 /* combination of algorithms used in libimagequant/pngquant2 aiming for highest quality at cost of speed */ +}; + +/** + * Group: Transform + * + * Constants: gdInterpolationMethod + + * GD_BELL - Bell + * GD_BESSEL - Bessel + * GD_BILINEAR_FIXED - fixed point bilinear + * GD_BICUBIC - Bicubic + * GD_BICUBIC_FIXED - fixed point bicubic integer + * GD_BLACKMAN - Blackman + * GD_BOX - Box + * GD_BSPLINE - BSpline + * GD_CATMULLROM - Catmullrom + * GD_GAUSSIAN - Gaussian + * GD_GENERALIZED_CUBIC - Generalized cubic + * GD_HERMITE - Hermite + * GD_HAMMING - Hamming + * GD_HANNING - Hannig + * GD_MITCHELL - Mitchell + * GD_NEAREST_NEIGHBOUR - Nearest neighbour interpolation + * GD_POWER - Power + * GD_QUADRATIC - Quadratic + * GD_SINC - Sinc + * GD_TRIANGLE - Triangle + * GD_WEIGHTED4 - 4 pixels weighted bilinear interpolation + * + * See also: + * <gdSetInterpolationMethod> + **/ +typedef enum { + GD_DEFAULT = 0, + GD_BELL, + GD_BESSEL, + GD_BILINEAR_FIXED, + GD_BICUBIC, + GD_BICUBIC_FIXED, + GD_BLACKMAN, + GD_BOX, + GD_BSPLINE, + GD_CATMULLROM, + GD_GAUSSIAN, + GD_GENERALIZED_CUBIC, + GD_HERMITE, + GD_HAMMING, + GD_HANNING, + GD_MITCHELL, + GD_NEAREST_NEIGHBOUR, + GD_POWER, + GD_QUADRATIC, + GD_SINC, + GD_TRIANGLE, + GD_WEIGHTED4, + GD_METHOD_COUNT = 21 +} gdInterpolationMethod; + +/* define struct with name and func ptr and add it to gdImageStruct gdInterpolationMethod interpolation; */ + +/* Interpolation function ptr */ +typedef double (* interpolation_method )(double); + +typedef struct gdImageStruct { + /* Palette-based image pixels */ + unsigned char **pixels; + int sx; + int sy; + /* These are valid in palette images only. See also + 'alpha', which appears later in the structure to + preserve binary backwards compatibility */ + int colorsTotal; + int red[gdMaxColors]; + int green[gdMaxColors]; + int blue[gdMaxColors]; + int open[gdMaxColors]; + /* For backwards compatibility, this is set to the + first palette entry with 100% transparency, + and is also set and reset by the + gdImageColorTransparent function. Newer + applications can allocate palette entries + with any desired level of transparency; however, + bear in mind that many viewers, notably + many web browsers, fail to implement + full alpha channel for PNG and provide + support for full opacity or transparency only. */ + int transparent; + int *polyInts; + int polyAllocated; + struct gdImageStruct *brush; + struct gdImageStruct *tile; + int brushColorMap[gdMaxColors]; + int tileColorMap[gdMaxColors]; + int styleLength; + int stylePos; + int *style; + int interlace; + /* New in 2.0: thickness of line. Initialized to 1. */ + int thick; + /* New in 2.0: alpha channel for palettes. Note that only + Macintosh Internet Explorer and (possibly) Netscape 6 + really support multiple levels of transparency in + palettes, to my knowledge, as of 2/15/01. Most + common browsers will display 100% opaque and + 100% transparent correctly, and do something + unpredictable and/or undesirable for levels + in between. TBB */ + int alpha[gdMaxColors]; + /* Truecolor flag and pixels. New 2.0 fields appear here at the + end to minimize breakage of existing object code. */ + int trueColor; + int **tpixels; + /* Should alpha channel be copied, or applied, each time a + pixel is drawn? This applies to truecolor images only. + No attempt is made to alpha-blend in palette images, + even if semitransparent palette entries exist. + To do that, build your image as a truecolor image, + then quantize down to 8 bits. */ + int alphaBlendingFlag; + /* Should the alpha channel of the image be saved? This affects + PNG at the moment; other future formats may also + have that capability. JPEG doesn't. */ + int saveAlphaFlag; + + /* There should NEVER BE ACCESSOR MACROS FOR ITEMS BELOW HERE, so this + part of the structure can be safely changed in new releases. */ + + /* 2.0.12: anti-aliased globals. 2.0.26: just a few vestiges after + switching to the fast, memory-cheap implementation from PHP-gd. */ + int AA; + int AA_color; + int AA_dont_blend; + + /* 2.0.12: simple clipping rectangle. These values + must be checked for safety when set; please use + gdImageSetClip */ + int cx1; + int cy1; + int cx2; + int cy2; + + /* 2.1.0: allows to specify resolution in dpi */ + unsigned int res_x; + unsigned int res_y; + + /* Selects quantization method, see gdImageTrueColorToPaletteSetMethod() and gdPaletteQuantizationMethod enum. */ + int paletteQuantizationMethod; + /* speed/quality trade-off. 1 = best quality, 10 = best speed. 0 = method-specific default. + Applicable to GD_QUANT_LIQ and GD_QUANT_NEUQUANT. */ + int paletteQuantizationSpeed; + /* Image will remain true-color if conversion to palette cannot achieve given quality. + Value from 1 to 100, 1 = ugly, 100 = perfect. Applicable to GD_QUANT_LIQ.*/ + int paletteQuantizationMinQuality; + /* Image will use minimum number of palette colors needed to achieve given quality. Must be higher than paletteQuantizationMinQuality + Value from 1 to 100, 1 = ugly, 100 = perfect. Applicable to GD_QUANT_LIQ.*/ + int paletteQuantizationMaxQuality; + gdInterpolationMethod interpolation_id; + interpolation_method interpolation; +} +gdImage; + +typedef gdImage *gdImagePtr; + + +/* Point type for use in polygon drawing. */ + +/** + * Group: Types + * + * typedef: gdPointF + * Defines a point in a 2D coordinate system using floating point + * values. + * x - Floating point position (increase from left to right) + * y - Floating point Row position (increase from top to bottom) + * + * typedef: gdPointFPtr + * Pointer to a <gdPointF> + * + * See also: + * <gdImageCreate>, <gdImageCreateTrueColor>, + **/ +typedef struct +{ + double x, y; +} +gdPointF, *gdPointFPtr; + +typedef struct { + /* # of characters in font */ + int nchars; + /* First character is numbered... (usually 32 = space) */ + int offset; + /* Character width and height */ + int w; + int h; + /* Font data; array of characters, one row after another. + Easily included in code, also easily loaded from + data files. */ + char *data; +} +gdFont; /* Text functions take these. */ - typedef gdFont *gdFontPtr; +typedef gdFont *gdFontPtr; + +typedef void(*gdErrorMethod)(int, const char *, va_list); + +BGD_DECLARE(void) gdSetErrorMethod(gdErrorMethod); +BGD_DECLARE(void) gdClearErrorMethod(void); /* For backwards compatibility only. Use gdImageSetStyle() - for MUCH more flexible line drawing. Also see - gdImageSetBrush(). */ + for MUCH more flexible line drawing. Also see + gdImageSetBrush(). */ #define gdDashSize 4 /* Special colors. */ @@ -252,7 +365,7 @@ BGD_DECLARE(int) gdAlphaBlend (int dest, int src); #define gdTiled (-5) /* NOT the same as the transparent color index. - This is used in line styles only. */ + This is used in line styles only. */ #define gdTransparent (-6) #define gdAntiAliased (-7) @@ -269,10 +382,10 @@ BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy); BGD_DECLARE(gdImagePtr) gdImageCreateTrueColor (int sx, int sy); /* Creates an image from various file types. These functions - return a palette or truecolor image based on the - nature of the file being loaded. Truecolor PNG - stays truecolor; palette PNG stays palette-based; - JPEG is always truecolor. */ + return a palette or truecolor image based on the + nature of the file being loaded. Truecolor PNG + stays truecolor; palette PNG stays palette-based; + JPEG is always truecolor. */ BGD_DECLARE(gdImagePtr) gdImageCreateFromPng (FILE * fd); BGD_DECLARE(gdImagePtr) gdImageCreateFromPngCtx (gdIOCtxPtr in); BGD_DECLARE(gdImagePtr) gdImageCreateFromPngPtr (int size, void *data); @@ -285,22 +398,39 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP (FILE * inFile); BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx (gdIOCtx * infile); BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr (int size, void *data); BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg (FILE * infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegEx (FILE * infile, int ignore_warning); BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx (gdIOCtx * infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtxEx (gdIOCtx * infile, int ignore_warning); BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtrEx (int size, void *data, int ignore_warning); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp (FILE * inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtx *infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTga( FILE * fp ); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* ctx); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp (FILE * inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpCtx (gdIOCtxPtr infile); /* A custom data source. */ /* The source function must return -1 on error, otherwise the number - of bytes fetched. 0 is EOF, not an error! */ + of bytes fetched. 0 is EOF, not an error! */ /* context will be passed to your source function. */ - typedef struct - { - int (*source) (void *context, char *buffer, int len); - void *context; - } - gdSource, *gdSourcePtr; +typedef struct { + int (*source) (void *context, char *buffer, int len); + void *context; +} +gdSource, *gdSourcePtr; - /* Deprecated in favor of gdImageCreateFromPngCtx */ +/* Deprecated in favor of gdImageCreateFromPngCtx */ BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr in); BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * in); @@ -312,25 +442,26 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in); BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ptr (int size, void *data); BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Part (FILE * in, int srcx, int srcy, int w, - int h); + int h); BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartCtx (gdIOCtxPtr in, int srcx, int srcy, - int w, int h); + int w, int h); BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, - int w, int h); - /* 2.0.10: prototype was missing */ + int w, int h); +/* 2.0.10: prototype was missing */ BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm (FILE * in); +BGD_DECLARE(void) gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out); - /* NOTE: filename, not FILE */ +/* NOTE: filename, not FILE */ BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm (char *filename); BGD_DECLARE(void) gdImageDestroy (gdImagePtr im); /* Replaces or blends with the background depending on the - most recent call to gdImageAlphaBlending and the - alpha channel value of 'color'; default is to overwrite. - Tiling and line styling are also implemented - here. All other gd drawing functions pass through this call, - allowing for many useful effects. */ + most recent call to gdImageAlphaBlending and the + alpha channel value of 'color'; default is to overwrite. + Tiling and line styling are also implemented + here. All other gd drawing functions pass through this call, + allowing for many useful effects. */ BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color); /* FreeType 2 text output with hook to extra flags */ @@ -343,92 +474,91 @@ BGD_DECLARE(void) gdImageAABlend (gdImagePtr im); BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color); /* For backwards compatibility only. Use gdImageSetStyle() - for much more flexible line drawing. */ + for much more flexible line drawing. */ BGD_DECLARE(void) gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, - int color); + int color); /* Corners specified (not width and height). Upper left first, lower right - second. */ + second. */ BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, - int color); + int color); /* Solid bar. Upper left corner first, lower right corner second. */ BGD_DECLARE(void) gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, - int color); + int color); BGD_DECLARE(void) gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2); BGD_DECLARE(void) gdImageGetClip(gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P); +BGD_DECLARE(void) gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y); BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y); BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, - int color); + int color); BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, - int color); + int color); BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, - unsigned char *s, int color); + unsigned char *s, int color); BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, - unsigned char *s, int color); + unsigned char *s, int color); BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y, - unsigned short *s, int color); + unsigned short *s, int color); BGD_DECLARE(void) gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y, - unsigned short *s, int color); + unsigned short *s, int color); /* 2.0.16: for thread-safe use of gdImageStringFT and friends, - call this before allowing any thread to call gdImageStringFT. - Otherwise it is invoked by the first thread to invoke - gdImageStringFT, with a very small but real risk of a race condition. - Return 0 on success, nonzero on failure to initialize freetype. */ + call this before allowing any thread to call gdImageStringFT. + Otherwise it is invoked by the first thread to invoke + gdImageStringFT, with a very small but real risk of a race condition. + Return 0 on success, nonzero on failure to initialize freetype. */ BGD_DECLARE(int) gdFontCacheSetup (void); -/* Optional: clean up after application is done using fonts in -BGD_DECLARE( ) - gdImageStringFT(). */ +/* Optional: clean up after application is done using fonts in + gdImageStringFT(). */ BGD_DECLARE(void) gdFontCacheShutdown (void); /* 2.0.20: for backwards compatibility. A few applications did start calling - this function when it first appeared although it was never documented. - Simply invokes gdFontCacheShutdown. */ + this function when it first appeared although it was never documented. + Simply invokes gdFontCacheShutdown. */ BGD_DECLARE(void) gdFreeFontCache (void); /* Calls gdImageStringFT. Provided for backwards compatibility only. */ BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist, - double ptsize, double angle, int x, int y, - char *string); + double ptsize, double angle, int x, int y, + char *string); /* FreeType 2 text output */ BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist, - double ptsize, double angle, int x, int y, - char *string); + double ptsize, double angle, int x, int y, + char *string); /* 2.0.5: provides an extensible way to pass additional parameters. - Thanks to Wez Furlong, sorry for the delay. */ + Thanks to Wez Furlong, sorry for the delay. */ - typedef struct - { - int flags; /* Logical OR of gdFTEX_ values */ - double linespacing; /* fine tune line spacing for '\n' */ - int charmap; /* TBB: 2.0.12: may be gdFTEX_Unicode, +typedef struct { + int flags; /* Logical OR of gdFTEX_ values */ + double linespacing; /* fine tune line spacing for '\n' */ + int charmap; /* TBB: 2.0.12: may be gdFTEX_Unicode, gdFTEX_Shift_JIS, gdFTEX_Big5, or gdFTEX_Adobe_Custom; when not specified, maps are searched for in the above order. */ - int hdpi; /* if (flags & gdFTEX_RESOLUTION) */ - int vdpi; /* if (flags & gdFTEX_RESOLUTION) */ - char *xshow; /* if (flags & gdFTEX_XSHOW) - then, on return, xshow is a malloc'ed - string contining xshow position data for - the last string. - - NB. The caller is responsible for gdFree'ing - the xshow string. - */ - char *fontpath; /* if (flags & gdFTEX_RETURNFONTPATHNAME) - then, on return, fontpath is a malloc'ed - string containing the actual font file path name - used, which can be interesting when fontconfig - is in use. - - The caller is responsible for gdFree'ing the - fontpath string. - */ - - } - gdFTStringExtra, *gdFTStringExtraPtr; + int hdpi; /* if (flags & gdFTEX_RESOLUTION) */ + int vdpi; /* if (flags & gdFTEX_RESOLUTION) */ + char *xshow; /* if (flags & gdFTEX_XSHOW) + then, on return, xshow is a malloc'ed + string containing xshow position data for + the last string. + + NB. The caller is responsible for gdFree'ing + the xshow string. + */ + char *fontpath; /* if (flags & gdFTEX_RETURNFONTPATHNAME) + then, on return, fontpath is a malloc'ed + string containing the actual font file path name + used, which can be interesting when fontconfig + is in use. + + The caller is responsible for gdFree'ing the + fontpath string. + */ + +} +gdFTStringExtra, *gdFTStringExtraPtr; #define gdFTEX_LINESPACE 1 #define gdFTEX_CHARMAP 2 @@ -436,58 +566,64 @@ BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fon #define gdFTEX_DISABLE_KERNING 8 #define gdFTEX_XSHOW 16 /* The default unless gdFTUseFontConfig(1); has been called: - fontlist is a full or partial font file pathname or list thereof - (i.e. just like before 2.0.29) */ + fontlist is a full or partial font file pathname or list thereof + (i.e. just like before 2.0.29) */ #define gdFTEX_FONTPATHNAME 32 /* Necessary to use fontconfig patterns instead of font pathnames - as the fontlist argument, unless gdFTUseFontConfig(1); has - been called. New in 2.0.29 */ + as the fontlist argument, unless gdFTUseFontConfig(1); has + been called. New in 2.0.29 */ #define gdFTEX_FONTCONFIG 64 /* Sometimes interesting when fontconfig is used: the fontpath - element of the structure above will contain a gdMalloc'd string - copy of the actual font file pathname used, if this flag is set + element of the structure above will contain a gdMalloc'd string + copy of the actual font file pathname used, if this flag is set when the call is made */ #define gdFTEX_RETURNFONTPATHNAME 128 -/* If flag is nonzero, the fontlist parameter to gdImageStringFT - and gdImageStringFTEx shall be assumed to be a fontconfig font pattern - if fontconfig was compiled into gd. This function returns zero - if fontconfig is not available, nonzero otherwise. */ +/* If flag is nonzero, the fontlist parameter to gdImageStringFT + and gdImageStringFTEx shall be assumed to be a fontconfig font pattern + if fontconfig was compiled into gd. This function returns zero + if fontconfig is not available, nonzero otherwise. */ BGD_DECLARE(int) gdFTUseFontConfig(int flag); /* These are NOT flags; set one in 'charmap' if you set the - gdFTEX_CHARMAP bit in 'flags'. */ + gdFTEX_CHARMAP bit in 'flags'. */ #define gdFTEX_Unicode 0 #define gdFTEX_Shift_JIS 1 #define gdFTEX_Big5 2 #define gdFTEX_Adobe_Custom 3 BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist, - double ptsize, double angle, int x, int y, - char *string, gdFTStringExtraPtr strex); + double ptsize, double angle, int x, int y, + char *string, gdFTStringExtraPtr strex); /* Point type for use in polygon drawing. */ - typedef struct - { - int x, y; - } - gdPoint, *gdPointPtr; +typedef struct { + int x, y; +} +gdPoint, *gdPointPtr; + +typedef struct { + int x, y; + int width, height; +} +gdRect, *gdRectPtr; + BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c); BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c); BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c); -/* These functions still work with truecolor images, - for which they never return error. */ +/* These functions still work with truecolor images, + for which they never return error. */ BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b); /* gd 2.0: palette entries with non-opaque transparency are permitted. */ BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a); /* Assumes opaque is the preferred alpha channel value */ BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b); /* Closest match taking all four parameters into account. - A slightly different color with the same transparency - beats the exact same color with radically different - transparency */ + A slightly different color with the same transparency + beats the exact same color with radically different + transparency */ BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a); /* An alternate method */ BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b); @@ -501,93 +637,143 @@ BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b); BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a); /* A simpler way to obtain an opaque truecolor value for drawing on a - truecolor image. Not for use with palette images! */ + truecolor image. Not for use with palette images! */ #define gdTrueColor(r, g, b) (((r) << 16) + \ - ((g) << 8) + \ - (b)) + ((g) << 8) + \ + (b)) /* Returns a truecolor value with an alpha channel component. - gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely - opaque. */ + gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely + opaque. */ #define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + \ - ((r) << 16) + \ - ((g) << 8) + \ - (b)) + ((r) << 16) + \ + ((g) << 8) + \ + (b)) BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color); /* Converts a truecolor image to a palette-based image, - using a high-quality two-pass quantization routine - which attempts to preserve alpha channel information - as well as R/G/B color information when creating - a palette. If ditherFlag is set, the image will be - dithered to approximate colors better, at the expense - of some obvious "speckling." colorsWanted can be - anything up to 256. If the original source image - includes photographic information or anything that - came out of a JPEG, 256 is strongly recommended. - - Better yet, don't use these function -- write real - truecolor PNGs and JPEGs. The disk space gain of - conversion to palette is not great (for small images - it can be negative) and the quality loss is ugly. - - DIFFERENCES: gdImageCreatePaletteFromTrueColor creates and - returns a new image. gdImageTrueColorToPalette modifies - an existing image, and the truecolor pixels are discarded. */ + using a high-quality two-pass quantization routine + which attempts to preserve alpha channel information + as well as R/G/B color information when creating + a palette. If ditherFlag is set, the image will be + dithered to approximate colors better, at the expense + of some obvious "speckling." colorsWanted can be + anything up to 256. If the original source image + includes photographic information or anything that + came out of a JPEG, 256 is strongly recommended. + + Better yet, don't use these function -- write real + truecolor PNGs and JPEGs. The disk space gain of + conversion to palette is not great (for small images + it can be negative) and the quality loss is ugly. + + DIFFERENCES: gdImageCreatePaletteFromTrueColor creates and + returns a new image. gdImageTrueColorToPalette modifies + an existing image, and the truecolor pixels are discarded. + + gdImageTrueColorToPalette() returns TRUE on success, FALSE on failure. +*/ BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int ditherFlag, - int colorsWanted); + int colorsWanted); + +BGD_DECLARE(int) gdImageTrueColorToPalette (gdImagePtr im, int ditherFlag, + int colorsWanted); + +BGD_DECLARE(int) gdImagePaletteToTrueColor(gdImagePtr src); + +/* An attempt at getting the results of gdImageTrueColorToPalette to + * look a bit more like the original (im1 is the original and im2 is + * the palette version */ -BGD_DECLARE(void) gdImageTrueColorToPalette (gdImagePtr im, int ditherFlag, - int colorsWanted); +BGD_DECLARE(int) gdImageColorMatch(gdImagePtr im1, gdImagePtr im2); + +/* Selects quantization method used for subsequent gdImageTrueColorToPalette calls. + See gdPaletteQuantizationMethod enum (e.g. GD_QUANT_NEUQUANT, GD_QUANT_LIQ). + Speed is from 1 (highest quality) to 10 (fastest). + Speed 0 selects method-specific default (recommended). + + Returns FALSE if the given method is invalid or not available. +*/ +BGD_DECLARE(int) gdImageTrueColorToPaletteSetMethod (gdImagePtr im, int method, int speed); + +/* + Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for. + Min and max quality is in range 1-100 (1 = ugly, 100 = perfect). Max must be higher than min. + If palette cannot represent image with at least min_quality, then image will remain true-color. + If palette can represent image with quality better than max_quality, then lower number of colors will be used. + This function has effect only when GD_QUANT_LIQ method has been selected and the source image is true-color. +*/ +BGD_DECLARE(void) gdImageTrueColorToPaletteSetQuality (gdImagePtr im, int min_quality, int max_quality); /* Specifies a color index (if a palette image) or an - RGB color (if a truecolor image) which should be - considered 100% transparent. FOR TRUECOLOR IMAGES, - THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING - SAVED. Use gdImageSaveAlpha(im, 0); to - turn off the saving of a full alpha channel in - a truecolor image. Note that gdImageColorTransparent - is usually compatible with older browsers that - do not understand full alpha channels well. TBB */ + RGB color (if a truecolor image) which should be + considered 100% transparent. FOR TRUECOLOR IMAGES, + THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING + SAVED. Use gdImageSaveAlpha(im, 0); to + turn off the saving of a full alpha channel in + a truecolor image. Note that gdImageColorTransparent + is usually compatible with older browsers that + do not understand full alpha channels well. TBB */ BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color); BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr dst, gdImagePtr src); + +typedef int (*gdCallbackImageColor)(gdImagePtr im, int src); + +BGD_DECLARE(int) gdImageColorReplace(gdImagePtr im, int src, int dst); +BGD_DECLARE(int) gdImageColorReplaceThreshold(gdImagePtr im, int src, int dst, float threshold); +BGD_DECLARE(int) gdImageColorReplaceArray(gdImagePtr im, int len, int *src, int *dst); +BGD_DECLARE(int) gdImageColorReplaceCallback(gdImagePtr im, gdCallbackImageColor callback); + BGD_DECLARE(void) gdImageGif (gdImagePtr im, FILE * out); BGD_DECLARE(void) gdImagePng (gdImagePtr im, FILE * out); BGD_DECLARE(void) gdImagePngCtx (gdImagePtr im, gdIOCtx * out); BGD_DECLARE(void) gdImageGifCtx (gdImagePtr im, gdIOCtx * out); +BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile); +BGD_DECLARE(void *) gdImageTiffPtr(gdImagePtr im, int *size); +BGD_DECLARE(void) gdImageTiffCtx(gdImagePtr image, gdIOCtx *out); + +BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression); +BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression); +BGD_DECLARE(void) gdImageBmpCtx(gdImagePtr im, gdIOCtxPtr out, int compression); /* 2.0.12: Compression level: 0-9 or -1, where 0 is NO COMPRESSION at all, - 1 is FASTEST but produces larger files, 9 provides the best - compression (smallest files) but takes a long time to compress, and - -1 selects the default compiled into the zlib library. */ + 1 is FASTEST but produces larger files, 9 provides the best + compression (smallest files) but takes a long time to compress, and + -1 selects the default compiled into the zlib library. */ BGD_DECLARE(void) gdImagePngEx (gdImagePtr im, FILE * out, int level); BGD_DECLARE(void) gdImagePngCtxEx (gdImagePtr im, gdIOCtx * out, int level); BGD_DECLARE(void) gdImageWBMP (gdImagePtr image, int fg, FILE * out); BGD_DECLARE(void) gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out); -/* Guaranteed to correctly free memory returned - by the gdImage*Ptr functions */ +/* Guaranteed to correctly free memory returned by the gdImage*Ptr + functions */ BGD_DECLARE(void) gdFree (void *m); /* Best to free this memory with gdFree(), not free() */ BGD_DECLARE(void *) gdImageWBMPPtr (gdImagePtr im, int *size, int fg); /* 100 is highest quality (there is always a little loss with JPEG). - 0 is lowest. 10 is about the lowest useful setting. */ + 0 is lowest. 10 is about the lowest useful setting. */ BGD_DECLARE(void) gdImageJpeg (gdImagePtr im, FILE * out, int quality); BGD_DECLARE(void) gdImageJpegCtx (gdImagePtr im, gdIOCtx * out, int quality); /* Best to free this memory with gdFree(), not free() */ BGD_DECLARE(void *) gdImageJpegPtr (gdImagePtr im, int *size, int quality); +BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quantization); +BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile); +BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size); +BGD_DECLARE(void *) gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization); +BGD_DECLARE(void) gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quantization); + /* Legal values for Disposal. gdDisposalNone is always used by - the built-in optimizer if previm is passed. */ + the built-in optimizer if previm is passed. */ enum { gdDisposalUnknown, @@ -606,17 +792,16 @@ BGD_DECLARE(void *) gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalC BGD_DECLARE(void *) gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm); BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size); -/* A custom data sink. For backwards compatibility. Use - gdIOCtx instead. */ -/* The sink function must return -1 on error, otherwise the number - of bytes written, which must be equal to len. */ -/* context will be passed to your sink function. */ - typedef struct - { - int (*sink) (void *context, const char *buffer, int len); - void *context; - } - gdSink, *gdSinkPtr; +/* A custom data sink. For backwards compatibility. Use gdIOCtx + instead. The sink function must return -1 on error, otherwise the + number of bytes written, which must be equal to len. Context will + be passed to your sink function. +*/ +typedef struct { + int (*sink) (void *context, const char *buffer, int len); + void *context; +} +gdSink, *gdSinkPtr; BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr out); @@ -636,20 +821,17 @@ BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size); /* Best to free this memory with gdFree(), not free() */ BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size); -BGD_DECLARE(void) gdImageEllipse (gdImagePtr im, int cx, int cy, int w, int h, - int color); - /* Style is a bitwise OR ( | operator ) of these. - gdArc and gdChord are mutually exclusive; - gdChord just connects the starting and ending - angles with a straight line, while gdArc produces - a rounded edge. gdPie is a synonym for gdArc. - gdNoFill indicates that the arc or chord should be - outlined, not filled. gdEdged, used together with - gdNoFill, indicates that the beginning and ending - angles should be connected to the center; this is - a good way to outline (rather than fill) a - 'pie slice'. */ + gdArc and gdChord are mutually exclusive; + gdChord just connects the starting and ending + angles with a straight line, while gdArc produces + a rounded edge. gdPie is a synonym for gdArc. + gdNoFill indicates that the arc or chord should be + outlined, not filled. gdEdged, used together with + gdNoFill, indicates that the beginning and ending + angles should be connected to the center; this is + a good way to outline (rather than fill) a + 'pie slice'. */ #define gdArc 0 #define gdPie gdArc #define gdChord 1 @@ -657,116 +839,153 @@ BGD_DECLARE(void) gdImageEllipse (gdImagePtr im, int cx, int cy, int w, int h, #define gdEdged 4 BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, - int e, int color, int style); + int e, int color, int style); BGD_DECLARE(void) gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, - int color); + int color); BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color); BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, - int color); + int color); BGD_DECLARE(void) gdImageFillToBorder (gdImagePtr im, int x, int y, int border, - int color); + int color); BGD_DECLARE(void) gdImageFill (gdImagePtr im, int x, int y, int color); BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, - int srcX, int srcY, int w, int h); + int srcX, int srcY, int w, int h); BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, - int srcX, int srcY, int w, int h, int pct); + int srcX, int srcY, int w, int h, int pct); BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, - int dstY, int srcX, int srcY, int w, int h, - int pct); + int dstY, int srcX, int srcY, int w, int h, + int pct); /* Stretches or shrinks to fit, as needed. Does NOT attempt - to average the entire set of source pixels that scale down onto the - destination pixel. */ + to average the entire set of source pixels that scale down onto the + destination pixel. */ BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, - int srcX, int srcY, int dstW, int dstH, int srcW, - int srcH); + int srcX, int srcY, int dstW, int dstH, int srcW, + int srcH); /* gd 2.0: stretches or shrinks to fit, as needed. When called with a - truecolor destination image, this function averages the - entire set of source pixels that scale down onto the - destination pixel, taking into account what portion of the - destination pixel each source pixel represents. This is a - floating point operation, but this is not a performance issue - on modern hardware, except for some embedded devices. If the - destination is a palette image, gdImageCopyResized is - substituted automatically. */ + truecolor destination image, this function averages the + entire set of source pixels that scale down onto the + destination pixel, taking into account what portion of the + destination pixel each source pixel represents. This is a + floating point operation, but this is not a performance issue + on modern hardware, except for some embedded devices. If the + destination is a palette image, gdImageCopyResized is + substituted automatically. */ BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, - int dstY, int srcX, int srcY, int dstW, int dstH, - int srcW, int srcH); + int dstY, int srcX, int srcY, int dstW, int dstH, + int srcW, int srcH); /* gd 2.0.8: gdImageCopyRotated is added. Source - is a rectangle, with its upper left corner at - srcX and srcY. Destination is the *center* of - the rotated copy. Angle is in degrees, same as - gdImageArc. Floating point destination center - coordinates allow accurate rotation of - objects of odd-numbered width or height. */ + is a rectangle, with its upper left corner at + srcX and srcY. Destination is the *center* of + the rotated copy. Angle is in degrees, same as + gdImageArc. Floating point destination center + coordinates allow accurate rotation of + objects of odd-numbered width or height. */ BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst, - gdImagePtr src, - double dstX, double dstY, - int srcX, int srcY, - int srcWidth, int srcHeight, int angle); + gdImagePtr src, + double dstX, double dstY, + int srcX, int srcY, + int srcWidth, int srcHeight, int angle); + +BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src); BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush); BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile); BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c); BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend); BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels); -/* Line thickness (defaults to 1). Affects lines, ellipses, - rectangles, polygons and so forth. */ +/* Line thickness (defaults to 1). Affects lines, ellipses, + rectangles, polygons and so forth. */ BGD_DECLARE(void) gdImageSetThickness (gdImagePtr im, int thickness); /* On or off (1 or 0) for all three of these. */ BGD_DECLARE(void) gdImageInterlace (gdImagePtr im, int interlaceArg); BGD_DECLARE(void) gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg); BGD_DECLARE(void) gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg); +BGD_DECLARE(gdImagePtr) gdImageNeuQuant(gdImagePtr im, const int max_color, int sample_factor); + +enum gdPixelateMode { + GD_PIXELATE_UPPERLEFT, + GD_PIXELATE_AVERAGE +}; + +BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode); + +typedef struct { + int sub; + int plus; + unsigned int num_colors; + int *colors; + unsigned int seed; +} gdScatter, *gdScatterPtr; + +BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus); +BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int colors[], unsigned int num_colors); +BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr s); +BGD_DECLARE(int) gdImageSmooth(gdImagePtr im, float weight); +BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im); +BGD_DECLARE(int) gdImageEmboss(gdImagePtr im); +BGD_DECLARE(int) gdImageGaussianBlur(gdImagePtr im); +BGD_DECLARE(int) gdImageEdgeDetectQuick(gdImagePtr src); +BGD_DECLARE(int) gdImageSelectiveBlur( gdImagePtr src); +BGD_DECLARE(int) gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset); +BGD_DECLARE(int) gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha); +BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast); +BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness); +BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src); +BGD_DECLARE(int) gdImageNegate(gdImagePtr src); + /* Macros to access information about images. */ /* Returns nonzero if the image is a truecolor image, - zero for a palette image. */ - + zero for a palette image. */ #define gdImageTrueColor(im) ((im)->trueColor) #define gdImageSX(im) ((im)->sx) #define gdImageSY(im) ((im)->sy) #define gdImageColorsTotal(im) ((im)->colorsTotal) #define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : \ - (im)->red[(c)]) + (im)->red[(c)]) #define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : \ - (im)->green[(c)]) + (im)->green[(c)]) #define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : \ - (im)->blue[(c)]) + (im)->blue[(c)]) #define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : \ - (im)->alpha[(c)]) + (im)->alpha[(c)]) #define gdImageGetTransparent(im) ((im)->transparent) #define gdImageGetInterlaced(im) ((im)->interlace) /* These macros provide direct access to pixels in - palette-based and truecolor images, respectively. - If you use these macros, you must perform your own - bounds checking. Use of the macro for the correct type - of image is also your responsibility. */ + palette-based and truecolor images, respectively. + If you use these macros, you must perform your own + bounds checking. Use of the macro for the correct type + of image is also your responsibility. */ #define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)] #define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)] +#define gdImageResolutionX(im) (im)->res_x +#define gdImageResolutionY(im) (im)->res_y + /* I/O Support routines. */ BGD_DECLARE(gdIOCtx *) gdNewFileCtx (FILE *); - /* If data is null, size is ignored and an initial data buffer is - allocated automatically. NOTE: this function assumes gd has the right - to free or reallocate "data" at will! Also note that gd will free - "data" when the IO context is freed. If data is not null, it must point - to memory allocated with gdMalloc, or by a call to gdImage[something]Ptr. - If not, see gdNewDynamicCtxEx for an alternative. */ +/* If data is null, size is ignored and an initial data buffer is + allocated automatically. NOTE: this function assumes gd has the right + to free or reallocate "data" at will! Also note that gd will free + "data" when the IO context is freed. If data is not null, it must point + to memory allocated with gdMalloc, or by a call to gdImage[something]Ptr. + If not, see gdNewDynamicCtxEx for an alternative. */ BGD_DECLARE(gdIOCtx *) gdNewDynamicCtx (int size, void *data); - /* 2.0.21: if freeFlag is nonzero, gd will free and/or reallocate "data" as - needed as described above. If freeFlag is zero, gd will never free - or reallocate "data," which means that the context should only be used - for *reading* an image from a memory buffer, or writing an image to a - memory buffer which is already large enough. If the memory buffer is - not large enough and an image write is attempted, the write operation - will fail. Those wishing to write an image to a buffer in memory have - a much simpler alternative in the gdImage[something]Ptr functions. */ +/* 2.0.21: if freeFlag is nonzero, gd will free and/or reallocate "data" as + needed as described above. If freeFlag is zero, gd will never free + or reallocate "data", which means that the context should only be used + for *reading* an image from a memory buffer, or writing an image to a + memory buffer which is already large enough. If the memory buffer is + not large enough and an image write is attempted, the write operation + will fail. Those wishing to write an image to a buffer in memory have + a much simpler alternative in the gdImage[something]Ptr functions. */ BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx (int size, void *data, int freeFlag); BGD_DECLARE(gdIOCtx *) gdNewSSCtx (gdSourcePtr in, gdSinkPtr out); BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size); @@ -784,6 +1003,89 @@ BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size); /* Image comparison definitions */ BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2); +BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im); +BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im); +BGD_DECLARE(void) gdImageFlipBoth(gdImagePtr im); + +#define GD_FLIP_HORINZONTAL 1 +#define GD_FLIP_VERTICAL 2 +#define GD_FLIP_BOTH 3 + +/** + * Group: Crop + * + * Constants: gdCropMode + * GD_CROP_DEFAULT - Default crop mode (4 corners or background) + * GD_CROP_TRANSPARENT - Crop using the transparent color + * GD_CROP_BLACK - Crop black borders + * GD_CROP_WHITE - Crop white borders + * GD_CROP_SIDES - Crop using colors of the 4 corners + * + * See also: + * <gdImageAutoCrop> + **/ +enum gdCropMode { + GD_CROP_DEFAULT = 0, + GD_CROP_TRANSPARENT, + GD_CROP_BLACK, + GD_CROP_WHITE, + GD_CROP_SIDES, + GD_CROP_THRESHOLD +}; + +BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop); +BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode); +BGD_DECLARE(gdImagePtr) gdImageCropThreshold(gdImagePtr im, const unsigned int color, const float threshold); + +BGD_DECLARE(int) gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMethod id); + +gdImagePtr gdImageScaleBilinear(gdImagePtr im, const unsigned int new_width, const unsigned int new_height); +gdImagePtr gdImageScaleBicubic(gdImagePtr src_img, const unsigned int new_width, const unsigned int new_height); +gdImagePtr gdImageScaleBicubicFixed(gdImagePtr src, const unsigned int width, const unsigned int height); +gdImagePtr gdImageScaleNearestNeighbour(gdImagePtr im, const unsigned int width, const unsigned int height); +gdImagePtr gdImageScaleTwoPass(const gdImagePtr pOrigImage, const unsigned int uOrigWidth, const unsigned int uOrigHeight, const unsigned int uNewWidth, const unsigned int uNewHeight); +BGD_DECLARE(gdImagePtr) gdImageScale(const gdImagePtr src, const unsigned int new_width, const unsigned int new_height); + +gdImagePtr gdImageRotate90(gdImagePtr src, int ignoretransparent); +gdImagePtr gdImageRotate180(gdImagePtr src, int ignoretransparent); +gdImagePtr gdImageRotate270(gdImagePtr src, int ignoretransparent); +gdImagePtr gdImageRotateNearestNeighbour(gdImagePtr src, const float degrees, const int bgColor); +gdImagePtr gdImageRotateBilinear(gdImagePtr src, const float degrees, const int bgColor); +gdImagePtr gdImageRotateBicubicFixed(gdImagePtr src, const float degrees, const int bgColor); +gdImagePtr gdImageRotateGeneric(gdImagePtr src, const float degrees, const int bgColor); +BGD_DECLARE(gdImagePtr) gdImageRotateInterpolated(const gdImagePtr src, const float angle, int bgcolor); + +typedef enum { + GD_AFFINE_TRANSLATE = 0, + GD_AFFINE_SCALE, + GD_AFFINE_ROTATE, + GD_AFFINE_SHEAR_HORIZONTAL, + GD_AFFINE_SHEAR_VERTICAL +} gdAffineStandardMatrix; + +BGD_DECLARE(int) gdAffineApplyToPointF (gdPointFPtr dst, const gdPointFPtr src, const double affine[6]); +BGD_DECLARE(int) gdAffineInvert (double dst[6], const double src[6]); +BGD_DECLARE(int) gdAffineFlip (double dst_affine[6], const double src_affine[6], const int flip_h, const int flip_v); +BGD_DECLARE(int) gdAffineConcat (double dst[6], const double m1[6], const double m2[6]); + +BGD_DECLARE(int) gdAffineIdentity (double dst[6]); +BGD_DECLARE(int) gdAffineScale (double dst[6], const double scale_x, const double scale_y); +BGD_DECLARE(int) gdAffineRotate (double dst[6], const double angle); +BGD_DECLARE(int) gdAffineShearHorizontal (double dst[6], const double angle); +BGD_DECLARE(int) gdAffineShearVertical(double dst[6], const double angle); +BGD_DECLARE(int) gdAffineTranslate (double dst[6], const double offset_x, const double offset_y); +BGD_DECLARE(double) gdAffineExpansion (const double src[6]); +BGD_DECLARE(int) gdAffineRectilinear (const double src[6]); +BGD_DECLARE(int) gdAffineEqual (const double matrix1[6], const double matrix2[6]); +BGD_DECLARE(int) gdTransformAffineGetImage(gdImagePtr *dst, const gdImagePtr src, gdRectPtr src_area, const double affine[6]); +BGD_DECLARE(int) gdTransformAffineCopy(gdImagePtr dst, int dst_x, int dst_y, const gdImagePtr src, gdRectPtr src_region, const double affine[6]); +/* +gdTransformAffineCopy(gdImagePtr dst, int x0, int y0, int x1, int y1, + const gdImagePtr src, int src_width, int src_height, + const double affine[6]); +*/ +BGD_DECLARE(int) gdTransformAffineBoundingBox(gdRectPtr src, const double affine[6], gdRectPtr bbox); + #define GD_CMP_IMAGE 1 /* Actual image IS different */ #define GD_CMP_NUM_COLORS 2 /* Number of Colours in pallette differ */ #define GD_CMP_COLOR 4 /* Image colours differ */ @@ -795,7 +1097,7 @@ BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2); #define GD_CMP_TRUECOLOR 256 /* Truecolor vs palette differs */ /* resolution affects ttf font rendering, particularly hinting */ -#define GD_RESOLUTION 96 /* pixels per inch */ +#define GD_RESOLUTION 96 /* pixels per inch */ #ifdef __cplusplus } diff --git a/lib/MacOSX/libgd/include/gd_color_map.h b/lib/MacOSX/libgd/include/gd_color_map.h @@ -0,0 +1,30 @@ +#ifndef GD_COLOR_MAP_H +#define GD_COLOR_MAP_H 1 + +#include "gd.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + char *color_name; + int red; + int green; + int blue; +} gdColorMapEntry; + +typedef struct { + int num_entries; + gdColorMapEntry *entries; +} gdColorMap; + +extern BGD_EXPORT_DATA_PROT gdColorMap GD_COLOR_MAP_X11; + +BGD_DECLARE(int) gdColorMapLookup(const gdColorMap color_map, const char *color_name, int *r, int *g, int *b); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/MacOSX/libgd/include/gd_errors.h b/lib/MacOSX/libgd/include/gd_errors.h @@ -0,0 +1,46 @@ +#ifndef GD_ERRORS_H +#define GD_ERRORS_H + +#ifndef _WIN32 +# include <syslog.h> +#else +/* + * priorities/facilities are encoded into a single 32-bit quantity, where the + * bottom 3 bits are the priority (0-7) and the top 28 bits are the facility + * (0-big number). Both the priorities and the facilities map roughly + * one-to-one to strings in the syslogd(8) source code. This mapping is + * included in this file. + * + * priorities (these are ordered) + */ +# define LOG_EMERG 0 /* system is unusable */ +# define LOG_ALERT 1 /* action must be taken immediately */ +# define LOG_CRIT 2 /* critical conditions */ +# define LOG_ERR 3 /* error conditions */ +# define LOG_WARNING 4 /* warning conditions */ +# define LOG_NOTICE 5 /* normal but significant condition */ +# define LOG_INFO 6 /* informational */ +# define LOG_DEBUG 7 /* debug-level messages */ +#endif + +/* +LOG_EMERG system is unusable +LOG_ALERT action must be taken immediately +LOG_CRIT critical conditions +LOG_ERR error conditions +LOG_WARNING warning conditions +LOG_NOTICE normal, but significant, condition +LOG_INFO informational message +LOG_DEBUG debug-level message +*/ + +#define GD_ERROR LOG_ERR +#define GD_WARNING LOG_WARNING +#define GD_NOTICE LOG_NOTICE +#define GD_INFO LOG_INFO +#define GD_DEBUG LOG_DEBUG + +void gd_error(const char *format, ...); +void gd_error_ex(int priority, const char *format, ...); + +#endif diff --git a/lib/MacOSX/libgd/include/gd_io.h b/lib/MacOSX/libgd/include/gd_io.h @@ -8,45 +8,42 @@ extern "C" { #include <stdio.h> #ifdef VMS -#define Putchar gdPutchar +# define Putchar gdPutchar #endif -typedef struct gdIOCtx -{ - int (*getC) (struct gdIOCtx *); - int (*getBuf) (struct gdIOCtx *, void *, int); - - void (*putC) (struct gdIOCtx *, int); - int (*putBuf) (struct gdIOCtx *, const void *, int); - - /* seek must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! */ - int (*seek) (struct gdIOCtx *, const int); - - long (*tell) (struct gdIOCtx *); - - void (*gd_free) (struct gdIOCtx *); - -} -gdIOCtx; - -typedef struct gdIOCtx *gdIOCtxPtr; - -void Putword (int w, gdIOCtx * ctx); -void Putchar (int c, gdIOCtx * ctx); - - void gdPutC (const unsigned char c, gdIOCtx * ctx); - int gdPutBuf (const void *, int, gdIOCtx *); - void gdPutWord (int w, gdIOCtx * ctx); - void gdPutInt (int w, gdIOCtx * ctx); - - int gdGetC (gdIOCtx * ctx); - int gdGetBuf (void *, int, gdIOCtx *); - int gdGetByte (int *result, gdIOCtx * ctx); - int gdGetWord (int *result, gdIOCtx * ctx); - int gdGetInt (int *result, gdIOCtx * ctx); - - int gdSeek (gdIOCtx * ctx, const int offset); - long gdTell (gdIOCtx * ctx); + typedef struct gdIOCtx { + int (*getC)(struct gdIOCtx *); + int (*getBuf)(struct gdIOCtx *, void *, int); + void (*putC)(struct gdIOCtx *, int); + int (*putBuf)(struct gdIOCtx *, const void *, int); + /* seek must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! */ + int (*seek)(struct gdIOCtx *, const int); + long (*tell)(struct gdIOCtx *); + void (*gd_free)(struct gdIOCtx *); + void *data; + } + gdIOCtx; + + typedef struct gdIOCtx *gdIOCtxPtr; + + void Putword(int w, gdIOCtx *ctx); + void Putchar(int c, gdIOCtx *ctx); + + void gdPutC(const unsigned char c, gdIOCtx *ctx); + int gdPutBuf(const void *, int, gdIOCtx *); + void gdPutWord(int w, gdIOCtx *ctx); + void gdPutInt(int w, gdIOCtx *ctx); + + int gdGetC(gdIOCtx *ctx); + int gdGetBuf(void *, int, gdIOCtx *); + int gdGetByte(int *result, gdIOCtx *ctx); + int gdGetWord(int *result, gdIOCtx *ctx); + int gdGetWordLSB(signed short int *result, gdIOCtx *ctx); + int gdGetInt(int *result, gdIOCtx *ctx); + int gdGetIntLSB(signed int *result, gdIOCtx *ctx); + + int gdSeek(gdIOCtx *ctx, const int offset); + long gdTell(gdIOCtx *ctx); #endif diff --git a/lib/MacOSX/libgd/include/gdcache.h b/lib/MacOSX/libgd/include/gdcache.h @@ -2,91 +2,86 @@ extern "C" { #endif -/* - * gdcache.h - * - * Caches of pointers to user structs in which the least-recently-used - * element is replaced in the event of a cache miss after the cache has - * reached a given size. - * - * John Ellson (ellson@graphviz.org) Oct 31, 1997 - * - * Test this with: - * gcc -o gdcache -g -Wall -DTEST gdcache.c - * - * The cache is implemented by a singly-linked list of elements - * each containing a pointer to a user struct that is being managed by - * the cache. - * - * The head structure has a pointer to the most-recently-used - * element, and elements are moved to this position in the list each - * time they are used. The head also contains pointers to three - * user defined functions: - * - a function to test if a cached userdata matches some keydata - * - a function to provide a new userdata struct to the cache - * if there has been a cache miss. - * - a function to release a userdata struct when it is - * no longer being managed by the cache - * - * In the event of a cache miss the cache is allowed to grow up to - * a specified maximum size. After the maximum size is reached then - * the least-recently-used element is discarded to make room for the - * new. The most-recently-returned value is always left at the - * beginning of the list after retrieval. - * - * In the current implementation the cache is traversed by a linear - * search from most-recent to least-recent. This linear search - * probably limits the usefulness of this implementation to cache - * sizes of a few tens of elements. - */ + /* + * gdcache.h + * + * Caches of pointers to user structs in which the least-recently-used + * element is replaced in the event of a cache miss after the cache has + * reached a given size. + * + * John Ellson (ellson@graphviz.org) Oct 31, 1997 + * + * Test this with: + * gcc -o gdcache -g -Wall -DTEST gdcache.c + * + * The cache is implemented by a singly-linked list of elements + * each containing a pointer to a user struct that is being managed by + * the cache. + * + * The head structure has a pointer to the most-recently-used + * element, and elements are moved to this position in the list each + * time they are used. The head also contains pointers to three + * user defined functions: + * - a function to test if a cached userdata matches some keydata + * - a function to provide a new userdata struct to the cache + * if there has been a cache miss. + * - a function to release a userdata struct when it is + * no longer being managed by the cache + * + * In the event of a cache miss the cache is allowed to grow up to + * a specified maximum size. After the maximum size is reached then + * the least-recently-used element is discarded to make room for the + * new. The most-recently-returned value is always left at the + * beginning of the list after retrieval. + * + * In the current implementation the cache is traversed by a linear + * search from most-recent to least-recent. This linear search + * probably limits the usefulness of this implementation to cache + * sizes of a few tens of elements. + */ -/*********************************************************/ -/* header */ -/*********************************************************/ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif + /*********************************************************/ + /* header */ + /*********************************************************/ #include <stdlib.h> #ifndef NULL -#define NULL (void *)0 +# define NULL (void *)0 #endif -/* user defined function templates */ -typedef int (*gdCacheTestFn_t) (void *userdata, void *keydata); -typedef void *(*gdCacheFetchFn_t) (char **error, void *keydata); -typedef void (*gdCacheReleaseFn_t) (void *userdata); + /* user defined function templates */ + typedef int (*gdCacheTestFn_t)(void *userdata, void *keydata); + typedef void *(*gdCacheFetchFn_t)(char **error, void *keydata); + typedef void (*gdCacheReleaseFn_t)(void *userdata); -/* element structure */ -typedef struct gdCache_element_s gdCache_element_t; -struct gdCache_element_s -{ - gdCache_element_t *next; - void *userdata; -}; + /* element structure */ + typedef struct gdCache_element_s gdCache_element_t; + struct gdCache_element_s { + gdCache_element_t *next; + void *userdata; + }; -/* head structure */ -typedef struct gdCache_head_s gdCache_head_t; -struct gdCache_head_s -{ - gdCache_element_t *mru; - int size; - char *error; - gdCacheTestFn_t gdCacheTest; - gdCacheFetchFn_t gdCacheFetch; - gdCacheReleaseFn_t gdCacheRelease; -}; + /* head structure */ + typedef struct gdCache_head_s gdCache_head_t; + struct gdCache_head_s { + gdCache_element_t *mru; + int size; + char *error; + gdCacheTestFn_t gdCacheTest; + gdCacheFetchFn_t gdCacheFetch; + gdCacheReleaseFn_t gdCacheRelease; + }; -/* function templates */ -gdCache_head_t *gdCacheCreate (int size, - gdCacheTestFn_t gdCacheTest, - gdCacheFetchFn_t gdCacheFetch, - gdCacheReleaseFn_t gdCacheRelease); + /* function templates */ + gdCache_head_t *gdCacheCreate(int size, + gdCacheTestFn_t gdCacheTest, + gdCacheFetchFn_t gdCacheFetch, + gdCacheReleaseFn_t gdCacheRelease + ); -void gdCacheDelete (gdCache_head_t * head); + void gdCacheDelete(gdCache_head_t *head); -void *gdCacheGet (gdCache_head_t * head, void *keydata); + void *gdCacheGet(gdCache_head_t *head, void *keydata); #ifdef __cplusplus } diff --git a/lib/MacOSX/libgd/include/gdfontg.h b/lib/MacOSX/libgd/include/gdfontg.h @@ -1,8 +1,3 @@ -#ifdef __cplusplus -extern "C" { -#endif - - #ifndef _GDFONTG_H_ #define _GDFONTG_H_ 1 @@ -21,18 +16,13 @@ extern "C" "Libor Skarvada, libor@informatics.muni.cz" */ - #include "gd.h" - BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant; - BGD_DECLARE(gdFontPtr) gdFontGetGiant(void); +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant; +BGD_DECLARE(gdFontPtr) gdFontGetGiant(void); #ifdef __cplusplus } #endif #endif - -#ifdef __cplusplus -} -#endif diff --git a/lib/MacOSX/libgd/include/gdfontl.h b/lib/MacOSX/libgd/include/gdfontl.h @@ -1,8 +1,3 @@ -#ifdef __cplusplus -extern "C" { -#endif - - #ifndef _GDFONTL_H_ #define _GDFONTL_H_ 1 @@ -22,18 +17,13 @@ extern "C" "Libor Skarvada, libor@informatics.muni.cz" */ - #include "gd.h" - BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge; - BGD_DECLARE(gdFontPtr) gdFontGetLarge(void); +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge; +BGD_DECLARE(gdFontPtr) gdFontGetLarge(void); #ifdef __cplusplus } #endif #endif - -#ifdef __cplusplus -} -#endif diff --git a/lib/MacOSX/libgd/include/gdfontmb.h b/lib/MacOSX/libgd/include/gdfontmb.h @@ -1,8 +1,3 @@ -#ifdef __cplusplus -extern "C" { -#endif - - #ifndef _GDFONTMB_H_ #define _GDFONTMB_H_ 1 @@ -20,18 +15,13 @@ extern "C" No copyright info was found in the original bdf. */ - #include "gd.h" - BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold; - BGD_DECLARE(gdFontPtr) gdFontGetMediumBold(void); +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold; +BGD_DECLARE(gdFontPtr) gdFontGetMediumBold(void); #ifdef __cplusplus } #endif #endif - -#ifdef __cplusplus -} -#endif diff --git a/lib/MacOSX/libgd/include/gdfonts.h b/lib/MacOSX/libgd/include/gdfonts.h @@ -1,8 +1,3 @@ -#ifdef __cplusplus -extern "C" { -#endif - - #ifndef _GDFONTS_H_ #define _GDFONTS_H_ 1 @@ -20,18 +15,13 @@ extern "C" No copyright info was found in the original bdf. */ - #include "gd.h" - BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall; - BGD_DECLARE(gdFontPtr) gdFontGetSmall(void); +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall; +BGD_DECLARE(gdFontPtr) gdFontGetSmall(void); #ifdef __cplusplus } #endif #endif - -#ifdef __cplusplus -} -#endif diff --git a/lib/MacOSX/libgd/include/gdfontt.h b/lib/MacOSX/libgd/include/gdfontt.h @@ -1,8 +1,3 @@ -#ifdef __cplusplus -extern "C" { -#endif - - #ifndef _GDFONTT_H_ #define _GDFONTT_H_ 1 @@ -21,18 +16,13 @@ extern "C" "Libor Skarvada, libor@informatics.muni.cz" */ - #include "gd.h" - BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny; - BGD_DECLARE(gdFontPtr) gdFontGetTiny(void); +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny; +BGD_DECLARE(gdFontPtr) gdFontGetTiny(void); #ifdef __cplusplus } #endif #endif - -#ifdef __cplusplus -} -#endif diff --git a/lib/MacOSX/libgd/include/gdfx.h b/lib/MacOSX/libgd/include/gdfx.h @@ -5,15 +5,13 @@ extern "C" { #ifndef GDFX_H #define GDFX_H 1 -#include "gd.h" - -/* im MUST be square, but can have any size. Returns a new image +/* im MUST be square, but can have any size. Returns a new image of width and height radius * 2, in which the X axis of the original has been remapped to theta (angle) and the Y axis of the original has been remapped to rho (distance from center). This is known as a "polar coordinate transform." */ - BGD_DECLARE(gdImagePtr) gdImageSquareToCircle(gdImagePtr im, int radius); +BGD_DECLARE(gdImagePtr) gdImageSquareToCircle(gdImagePtr im, int radius); /* Draws the text 'top' and 'bottom' on 'im', curved along the edge of a circle of radius 'radius', with its @@ -32,38 +30,38 @@ extern "C" { the size of the text is determined by radius, textRadius, and fillPortion, you should pass a point size that 'hints' appropriately -- if you know the text will be - large, pass a large point size such as 24.0 to get the + large, pass a large point size such as 24.0 to get the best results. 'fgcolor' can be any color, and may have - an alpha component, do blending, etc. + an alpha component, do blending, etc. - Returns 0 on success, or an error string. */ + Returns 0 on success, or an error string. */ BGD_DECLARE(char *) gdImageStringFTCircle( - gdImagePtr im, - int cx, - int cy, - double radius, - double textRadius, - double fillPortion, - char *font, - double points, - char *top, - char *bottom, - int fgcolor); + gdImagePtr im, + int cx, + int cy, + double radius, + double textRadius, + double fillPortion, + char *font, + double points, + char *top, + char *bottom, + int fgcolor); - /* 2.0.16: - * Sharpen function added on 2003-11-19 - * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org) - * Simple 3x3 convolution kernel - * Makes use of seperability - * Faster, but less flexible, than full-blown unsharp masking - * pct is sharpening percentage, and can be greater than 100 - * Silently does nothing to non-truecolor images - * Silently does nothing for pct<0, as not a useful blurring function - * Leaves transparency/alpha-channel untouched - */ +/* 2.0.16: + * Sharpen function added on 2003-11-19 + * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org) + * Simple 3x3 convolution kernel + * Makes use of seperability + * Faster, but less flexible, than full-blown unsharp masking + * pct is sharpening percentage, and can be greater than 100 + * Silently does nothing to non-truecolor images + * Silently does nothing for pct<0, as not a useful blurring function + * Leaves transparency/alpha-channel untouched + */ - BGD_DECLARE(void) gdImageSharpen (gdImagePtr im, int pct); +BGD_DECLARE(void) gdImageSharpen (gdImagePtr im, int pct); #endif /* GDFX_H */ diff --git a/lib/MacOSX/libgd/include/gdpp.h b/lib/MacOSX/libgd/include/gdpp.h @@ -0,0 +1,1497 @@ +/* ***************************************************************************** +** $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 + +#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 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 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 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 Png_tag {}; +struct Gif_tag {}; +struct WBMP_tag {}; +struct Jpeg_tag {}; +struct Gd_tag {}; +struct Gd2_tag {}; +struct 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_IMPL 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); + } +#if HAVE_PNG + /** 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); + } + +#if HAVE_JPEG + /** 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); + +#if HAVE_PNG + // 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); + } + +#if HAVE_JPEG + // 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); + } + +#if HAVE_PNG + /** + 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); + } + +#if HAVE_JPEG + /** + 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 { + 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 { + 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); + } + + 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); + } + + 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 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); + } + + 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(); + } + 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 */ diff --git a/lib/MacOSX/libgd/libgd.2.0.0.dylib b/lib/MacOSX/libgd/libgd.2.0.0.dylib Binary files differ. diff --git a/lib/MacOSX/libgd/libgd.3.dylib b/lib/MacOSX/libgd/libgd.3.dylib Binary files differ.