Anda di halaman 1dari 37

/*

* $Id: gdlib.txt 9279 2011-02-14 18:06:32Z druzus $


*/
/*
* The following parts are Copyright of the individual authors.
* www - http://www.xharbour.org http://www.harbour-project.org
*
* Copyright 2004-2005 Francesco Saverio Giudice <info@fsgiudice.com>
*
Documentation for GD Library wrapper functions and classes
*
* See doc/license.txt for licensing terms.
*
*/
/* $DOC$
* $FUNCNAME$
*
The GD Library
* $CATEGORY$
*
Document
* $ONELINER$
*
Read me file for GD Library
* $DESCRIPTION$
*
GDLIB is basically a wrapper of Thomas Boutell's GD Library version 2.0.
33.
*
GD Library is a powerfull graphic library very usefull expecially under
CGI environment.
*
*
GDLIB actually contains almost all GD functions, more a set of functions
that extends original
*
library and a set of classes that make easier to work with this library.
*
*
Thomas Boutell's GD library actually supports these graphic formats:
*
PNG, JPEG, GIF, Animated GIF, GD, GD2, WBMP, XBM, XPM
*
WBMP is Wireless Bitmap, not Windows Bitmap, and it is used for WAP. It
is a B&W bitmap.
*
*
GDLIB actually supports PNG, JPEG, GIF, GD, WBMP
*
The other Animated GIF, GD2, XBM and XPM are not wrapped actually.
*
*
Using this library you can, as a little example:
*
- create an image in memory, true color or with a 256 colors palette;
*
- load and save an image of above formats and convert it to another supp
orted format;
*
- draw dots, lines, dashed lines, polygons, rectangles, arcs, circles an
d ellipses;
*
- fill with colors;
*
- draw with brushes;
*
- check a point or part or full image with a lot of query functions;
*
- draw characters and words with internal fonts or using truetype fonts;
*
- write strings on a base line or on a circle line and with any angle de
gree;
*
- copy, resize and rotate part or full image;
*
*
and, over this, some functions to clone, crop, zoom, rotate outside and
inside.
*
*
The prefix for all functions is GD (i.e. gdImageCreate() )
*
*
You can use directly all API functions or TGD class.

*
*
NOTE: Not all functions are wrapped.
*
* $SEEALSO$
*
Alphabetical list of functions, Categorized list of functions, GDImage C
lass, GDChart Class.
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageCreate()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Create a palette-based image in memory with no more that 256 colors.
* $SYNTAX$
*
gdImageCreate( <nPixelWidth>, <nPixelHeight> ) --> <pImage>
* $ARGUMENTS$
*
<nPixelWidth> - image width
*
<nPixelHeight> - image height
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageCreate() creates an empty image in memory.
*
This image has no more than 256 colors.
*
*
gdImageCreate() returns an image pointer or NIL if unable to create the
image.
*
The image pointer must be destroyed using gdImageDestroy()
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageCreate( 64, 64 )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreateTrueColor()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageCreateTrueColor()
* $CATEGORY$
*
GDLibrary

* $ONELINER$
*
Create a true color image in memory.
* $SYNTAX$
*
gdImageCreateTrueColor( <nPixelWidth>, <nPixelHeight> ) --> <pImage>
* $ARGUMENTS$
*
<nPixelWidth> - image width
*
<nPixelHeight> - image height
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageCreateTrueColor() creates an empty image in memory.
*
This image has true colors.
*
*
gdImageCreateTrueColor() returns an image pointer or NIL if unable to cr
eate the image.
*
The image pointer must be destroyed using gdImageDestroy()
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageCreateTrueColor( 64, 64 )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageDestroy()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Free memory used from an image.
* $SYNTAX$
*
gdImageDestroy( <pImage> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageDestroy() frees memory used from an image.
*
It's important to use this function before exiting from a program.
*
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
pImage := gdImageCreateTrueColor( 64, 64 )
// Use here image
.........
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageCreate(), gdImageCreateTrueColor()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageFromJpeg()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Load a JPEG image file.
* $SYNTAX$
*
gdImageFromJpeg( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> <pI
mage>
* $ARGUMENTS$
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<pPointer>
- Memory image pointer
*
<nSize>
- Image size
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageFromJpeg() creates a JPEG image from a file or a handle or anothe
r image in memory.
*
*
You can use one of 3 syntax:
*
*
pImage := gdImageFromJpeg( "myimage.jpg" )
*
*
or
*
*
pImage := gdImageFromJpeg( nFileHandle, nSize )
*
*
or
*
*
pImage := gdImageFromJpeg( pMemoryImagePtr, nSize )
*
*
the pImage pointer returned will be not NIL if successfull and will cont
ains a memory pointer

*
to the jpeg image.
*
*
Remember to free memory with gdImageDestroy() before exit from applicati
on.
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromJpeg( "myimage.jpg" )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageCreate(), gdImageCreateTrueColor(), gdImageDestroy(), gdImageFrom
Gif(), gdImageFromPng(), gdImageFromGD(), gdImageFromWBmp()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageFromGif()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Load a Gif image file.
* $SYNTAX$
*
gdImageFromGif( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> <pIm
age>
* $ARGUMENTS$
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<pPointer>
- Memory image pointer
*
<nSize>
- Image size
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageFromGif() creates a GIF image from a file or a handle or another
image in memory.
*
*
You can use one of 3 syntax:
*
*
pImage := gdImageFromGif( "myimage.gif" )
*
*
or
*
*
pImage := gdImageFromGif( nFileHandle, nSize )

*
*
or
*
*
pImage := gdImageFromGif( pMemoryImagePtr, nSize )
*
*
the pImage pointer returned will be not NIL if successfull and will cont
ains a memory pointer
*
to the gif image.
*
*
Remember to free memory with gdImageDestroy() before exit from applicati
on.
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromGif( "myimage.gif" )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageCreate(), gdImageCreateTrueColor(), gdImageDestroy(), gdImageFrom
Jpeg(), gdImageFromPng(), gdImageFromGD(), gdImageFromWBmp()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageFromPng()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Load a PNG image file.
* $SYNTAX$
*
gdImageFromPng( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> <pIm
age>
* $ARGUMENTS$
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<pPointer>
- Memory image pointer
*
<nSize>
- Image size
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageFromPng() creates a PNG image from a file or a handle or another
image in memory.
*

*
You can use one of 3 syntax:
*
*
pImage := gdImageFromPng( "myimage.png" )
*
*
or
*
*
pImage := gdImageFromPng( nFileHandle, nSize )
*
*
or
*
*
pImage := gdImageFromPng( pMemoryImagePtr, nSize )
*
*
the pImage pointer returned will be not NIL if successfull and will cont
ains a memory pointer
*
to the png image.
*
*
Remember to free memory with gdImageDestroy() before exit from applicati
on.
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromPng( "myimage.png" )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageCreate(), gdImageCreateTrueColor(), gdImageDestroy(), gdImageFrom
Jpeg(), gdImageFromGif(), gdImageFromGD(), gdImageFromWBmp()
* $END$
*/
/*
*
*
*
*
*
*
*
*
ge>
*
*
*
*

$DOC$
$FUNCNAME$
gdImageFromGD()
$CATEGORY$
GDLibrary
$ONELINER$
Load a GD image file.
$SYNTAX$
gdImageFromGD( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> <pIma
$ARGUMENTS$
<cFile>
<nHandle>
<pPointer>

- Image file name


- File handle
- Memory image pointer

*
<nSize>
- Image size
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageFromGD() creates a GD image from a file or a handle or another im
age in memory.
*
*
You can use one of 3 syntax:
*
*
pImage := gdImageFromGD( "myimage.gd" )
*
*
or
*
*
pImage := gdImageFromGD( nFileHandle, nSize )
*
*
or
*
*
pImage := gdImageFromGD( pMemoryImagePtr, nSize )
*
*
the pImage pointer returned will be not NIL if successfull and will cont
ains a memory pointer
*
to the GD image.
*
*
Remember to free memory with gdImageDestroy() before exit from applicati
on.
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromGD( "myimage.gd" )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageCreate(), gdImageCreateTrueColor(), gdImageDestroy(), gdImageFrom
Jpeg(), gdImageFromGif(), gdImageFromPng(), gdImageFromWBmp()
* $END$
*/
/*
*
*
*
*
*
*

$DOC$
$FUNCNAME$
gdImageFromWBmp()
$CATEGORY$
GDLibrary
$ONELINER$
Load a WBmp image file.

* $SYNTAX$
*
gdImageFromWBmp( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> <pI
mage>
* $ARGUMENTS$
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<pPointer>
- Memory image pointer
*
<nSize>
- Image size
* $RETURNS$
*
<pImage>
- Image pointer
* $DESCRIPTION$
*
gdImageFromWBmp() creates a WBmp image from a file or a handle or anothe
r image in memory.
*
*
You can use one of 3 syntax:
*
*
pImage := gdImageFromWBmp( "myimage.wbmp" )
*
*
or
*
*
pImage := gdImageFromWBmp( nFileHandle, nSize )
*
*
or
*
*
pImage := gdImageFromWBmp( pMemoryImagePtr, nSize )
*
*
the pImage pointer returned will be not NIL if successfull and will cont
ains a memory pointer
*
to the WBmp image.
*
*
Remember to free memory with gdImageDestroy() before exit from applicati
on.
*
GDLibrary uses it's own memory to manage an image, so it is important to
use this function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromWBmp( "myimage.wbmp" )
*
// Use here image
*
.........
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageCreate(), gdImageCreateTrueColor(), gdImageDestroy(), gdImageFrom
Jpeg(), gdImageFromGif(), gdImageFromPng(), gdImageFromGD()
* $END$
*/

/* $DOC$
* $FUNCNAME$
*
gdImageJpeg()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Save a JPEG image.
* $SYNTAX$
*
gdImageJpeg( <pImage>, <cFile> | <nHandle> [, <nCompressionLevel> ] ) -> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<nCompressionLevel> - a numeric value between 0=max compression and 95=m
in compression (best quality)
*
default is -1=auto
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageJpeg() saves a JPEG image to a file or a handle.
*
*
You can use one of 2 syntax:
*
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
or
*
*
gdImageJpeg( pImage, nFileHandle )
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromGif( "myimage.gif" )
*
*
// Image conversion
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageFromGif()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageGif()
* $CATEGORY$

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

GDLibrary
$ONELINER$
Save a GIF image.
$SYNTAX$
gdImageGif( <pImage>, <cFile> | <nHandle> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<cFile>
- Image file name
<nHandle>
- File handle
$RETURNS$
NIL
$DESCRIPTION$
gdImageGif() saves a GIF image to a file or a handle.
You can use one of 2 syntax:
gdImageGif( pImage, "myimage.gif" )
or
gdImageGif( pImage, nFileHandle )
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
pImage := gdImageFromJpeg( "myimage.jpg" )
// Image conversion
gdImageGif( pImage, "myimage.gif" )
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageFromJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImagePng()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Save a PNG image.
* $SYNTAX$
*
gdImagePng( <pImage>, <cFile> | <nHandle> [, <nCompressionLevel> ] ) -->
NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer

*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<nCompressionLevel> - a numeric value between 0=no compression and 9=max
compression
*
default is -1=auto
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImagePng() saves a PNG image to a file or a handle.
*
*
You can use one of 2 syntax:
*
*
gdImagePng( pImage, "myimage.png" )
*
*
or
*
*
gdImagePng( pImage, nFileHandle )
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
*
pImage := gdImageFromGif( "myimage.gif" )
*
*
// Image conversion
*
gdImagePng( pImage, "myimage.png" )
*
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageFromGif()
* $END$
*/
/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

$DOC$
$FUNCNAME$
gdImageGD()
$CATEGORY$
GDLibrary
$ONELINER$
Save a GD image.
$SYNTAX$
gdImageGd( <pImage>, <cFile> | <nHandle> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<cFile>
- Image file name
<nHandle>
- File handle
$RETURNS$
NIL
$DESCRIPTION$

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

gdImageGd() saves a GD image to a file or a handle.


You can use one of 2 syntax:
gdImageGd( pImage, "myimage.gd" )
or
gdImageGd( pImage, nFileHandle )
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
pImage := gdImageFromGif( "myimage.gif" )
// Image conversion
gdImageGd( pImage, "myimage.gd" )
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageFromGif()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageWBmp()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Save a WBMP image.
* $SYNTAX$
*
gdImageWBmp( <pImage>, <cFile> | <nHandle> [, <nFGcolor> ] ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<cFile>
- Image file name
*
<nHandle>
- File handle
*
<nFGcolor>
- foreground color value to be used as foreground, the ot
hers are background
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageWBmp() saves a WBMP image to a file or a handle.
*
*
You can use one of 2 syntax:
*
*
gdImageWBmp( pImage, "myimage.wbmp", nColor )
*

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

or
gdImagePng( pImage, nFileHandle, nColor )
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL white, black
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate background
white := gdImageColorAllocate(pImage, 255, 255, 255)
// Allocate drawing color
black := gdImageColorAllocate(pImage, 0, 0, 0)
// Draw a rectangle
gdImageRectangle(pImage, 0, 0, 99, 99, black)
// Save the image with black as foreground color
gdImageWBmp( pImage, "myimage.wbmp", black )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageRectangle(), gdColorAllocate()
$END$
$DOC$
$FUNCNAME$
gdImageSetPixel()
$CATEGORY$
GDLibrary
$ONELINER$
Set a pixel to a particular color index.
$SYNTAX$
gdImageSetPixel( <pImage>, <x>, <y>, <nColor> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<x>
- Horizontal position
<y>
- Vertical position
<nColor>
- Color index
$RETURNS$
NIL
$DESCRIPTION$
gdImageSetPixel() sets a pixel to a particular color index.

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

To set the color index you have to use gdImageColorAllocate() function.


$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL white
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
white := gdImageColorAllocate(pImage, 255, 255, 255)
// Draw a pixel
gdImageSetPixel(pImage, 50, 50, white)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageLine()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Draws a line between two end points (x1, y1 and x2, y2) with a particula
r color index.
* $SYNTAX$
*
gdImageLine( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<x1>
- 1st point horizontal position
*
<y1>
- 1st point vertical position
*
<x2>
- 2nd point horizontal position
*
<y2>
- 2nd point vertical position
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageLine() Draws a line between two end points (x1, y1 and x2, y2)
*
with a particular color index.

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

To set the color index you have to use gdImageColorAllocate() function.


$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw a line
gdImageLine(pImage, 10, 10, 90, 90, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageDashedLine()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Draws a dashed line between two end points (x1, y1 and x2, y2) with a pa
rticular color index.
* $SYNTAX$
*
gdImageDashedLine( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<x1>
- 1st point horizontal position
*
<y1>
- 1st point vertical position
*
<x2>
- 2nd point horizontal position
*
<y2>
- 2nd point vertical position
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageDashedLine() Draws a dashed line between two end points (x1, y1 a
nd x2, y2)

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
*
or
*
*
*
*
*
*
*
*
*
*
*
*
a

with a particular color index.


To set the color index you have to use gdImageColorAllocate() function.
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw a dashed line
gdImageDashedLine(pImage, 10, 10, 90, 90, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$
$DOC$
$FUNCNAME$
gdImagePolygon()
$CATEGORY$
GDLibrary
$ONELINER$
Draws a closed polygon with verticies (at least 3) with a particular col
index.
$SYNTAX$
gdImagePolygon( <pImage>, <aVerticies>, <nColor> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<aVerticies> - Array of point array { <x>, <y> } where
<x> is horizontal position
<y> is vertical position
<nColor>
- Color index
$RETURNS$
NIL
$DESCRIPTION$
gdImagePolygon() Draws a closed polygon with verticies (at least 3) with

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

particular color index.


To set the color index you have to use gdImageColorAllocate() function.
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
LOCAL aVerticies := { ;
{ 50, 0 } ,;
{ 99, 99 } ,;
{ 0, 99 } ;
}
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw a polygon
gdImagePolygon(pImage, aVerticies, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageOpenPolygon()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Draws an open polygon with verticies (at least 3) with a particular colo
r index.
* $SYNTAX$
*
gdImageOpenPolygon( <pImage>, <aVerticies>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<aVerticies> - Array of point array { <x>, <y> } where
*
<x> is horizontal position
*
<y> is vertical position
*
<nColor>
- Color index

* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageOpenPolygon() Draws an open polygon with verticies (at least 3) w
ith a
*
particular color index. Unlike gdImagePolygon() the endpoints of the lin
e sequence
*
are not connected to close the polygon.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue
*
LOCAL aVerticies := { ;
*
{ 50, 0 } ,;
*
{ 99, 99 } ,;
*
{ 0, 99 } ;
*
}
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
*
// Draws an open polygon
*
gdImageOpenPolygon(pImage, aVerticies, blue)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
* $END$
*/
/*
*
*
*
*
*
*
*
*

$DOC$
$FUNCNAME$
gdImageRectangle()
$CATEGORY$
GDLibrary
$ONELINER$
Draws a rectangle with a particular color index.
$SYNTAX$
gdImageRectangle( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
*
or
*
*

$ARGUMENTS$
<pImage>
- Image pointer
<x1>
- upper left point horizontal position
<y1>
- upper left point vertical position
<x2>
- lower right point horizontal position
<y2>
- lower right point vertical position
<nColor>
- Color index
$RETURNS$
NIL
$DESCRIPTION$
gdImageRectangle() draws a rectangle between 2 points with a
particular color index.
To set the color index you have to use gdImageColorAllocate() function.
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw a rectangle
gdImageRectangle(pImage, 10, 10, 50, 50, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$
$DOC$
$FUNCNAME$
gdImageFilledPolygon()
$CATEGORY$
GDLibrary
$ONELINER$
Draws a filled polygon with verticies (at least 3) with a particular col
index.
$SYNTAX$
gdImageFilledPolygon( <pImage>, <aVerticies>, <nColor> ) --> NIL

* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<aVerticies> - Array of point array { <x>, <y> } where
*
<x> is horizontal position
*
<y> is vertical position
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFilledPolygon() Draws a filled polygon with verticies (at least 3
) with a
*
particular color index.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue
*
LOCAL aVerticies := { ;
*
{ 50, 0 } ,;
*
{ 99, 99 } ,;
*
{ 0, 99 } ;
*
}
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
*
// Draw a filled polygon
*
gdImageFilledPolygon(pImage, aVerticies, blue)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageFilledRectangle()
* $CATEGORY$
*
GDLibrary

* $ONELINER$
*
Draws a filled rectangle with a particular color index.
* $SYNTAX$
*
gdImageFilledRectangle( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) -->
NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<x1>
- upper left point horizontal position
*
<y1>
- upper left point vertical position
*
<x2>
- lower right point horizontal position
*
<y2>
- lower right point vertical position
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFilledRectangle() draws a filled rectangle between 2 points with
a
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

particular color index.


To set the color index you have to use gdImageColorAllocate() function.
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw a filled rectangle
gdImageFilledRectangle(pImage, 10, 10, 50, 50, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageArc()
* $CATEGORY$

*
GDLibrary
* $ONELINER$
*
Draws a partial ellipse centered at a given point.
* $SYNTAX$
*
gdImageArc( <pImage>, <cx>, <cy>, <w>, <h>, <s>, <e>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<cx>
- center point horizontal position
*
<cy>
- center point vertical position
*
<w>
- width
*
<h>
- height
*
<s>
- start degree
*
<e>
- end degree
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageArc() is used to draw a partial ellipse centered at the given poi
nt,
*
with the specified width and height in pixels. The arc begins at the pos
ition
*
in degrees specified by s and ends at the position specified by e.
*
The arc is drawn in the color specified by the last argument. A circle c
an be drawn
*
by beginning from 0 degrees and ending at 360 degrees, with width and he
ight being equal.
*
<e> must be greater than <s>. Values greater than 360 are interpreted mo
dulo 360.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
*
// Draw an ellipse
*
gdImageArc(pImage, 50, 25, 98, 48, 0, 360, blue)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$

*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageFilledArc()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Draws a partial filled ellipse centered at a given point.
* $SYNTAX$
*
gdImageArc( <pImage>, <cx>, <cy>, <w>, <h>, <s>, <e>, <nColor>, <nStyle>
) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<cx>
- center point horizontal position
*
<cy>
- center point vertical position
*
<w>
- width
*
<h>
- height
*
<s>
- start degree
*
<e>
- end degree
*
<nColor>
- Color index
*
<nStyle>
- fill style
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFilledArc() is used to draw a partial ellipse centered at the giv
en point,
*
with the specified width and height in pixels. The arc begins at the pos
ition
*
in degrees specified by s and ends at the position specified by e.
*
The arc is drawn in the color specified by the last argument. A circle c
an be drawn
*
by beginning from 0 degrees and ending at 360 degrees, with width and he
ight being equal.
*
<e> must be greater than <s>. Values greater than 360 are interpreted mo
dulo 360.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
*
Last parameter <nStyle> is a bitwise OR of the following possibilities:
*
gdArc
*
gdChord
*
gdPie (synonym for gdArc)
*
gdNoFill
*
gdEdged
*
*
gdArc and gdChord are mutually exclusive;
*
gdChord just connects the starting and ending angles with a straight lin
e,
*
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 e
nding
*
angles should be connected to the center; this is a good way to outline
*
(rather than fill) a 'pie slice'
*

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

these constants are defined in gd.ch


$EXAMPLES$
#include "gd.ch"
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw an ellipse
gdImageFilledArc(pImage, 50, 25, 98, 48, 0, 360, blue, gdArc)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageFilledEllipse()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
Draws a filled ellipse centered at a given point.
* $SYNTAX$
*
gdImageFilledEllipse( <pImage>, <cx>, <cy>, <w>, <h>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<cx>
- center point horizontal position
*
<cy>
- center point vertical position
*
<w>
- width
*
<h>
- height
*
<nColor>
- Color index
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFilledEllipse() is used to draw a filled ellipse centered at the
given point,

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

with the specified width and height in pixels.


To set the color index you have to use gdImageColorAllocate() function.
$EXAMPLES$
PROCEDURE Main()
LOCAL pImage
LOCAL blue
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color
blue := gdImageColorAllocate(pImage, 0, 0, 255)
// Draw an ellipse
gdImageFilledEllipse(pImage, 50, 25, 98, 48, blue)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
$END$

/* $DOC$
* $FUNCNAME$
*
gdImageFillToBorder()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
floods a portion of the image with the specified color.
* $SYNTAX$
*
gdImageFillToBorder( <pImage>, <x>, <y>, <nBorder>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<x>
- start point horizontal position
*
<y>
- start point vertical position
*
<nBorder>
- Color index where fill stops
*
<nColor>
- Color index of filling color
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFillToBorder() floods a portion of the image with the specified c
olor,
*
beginning at the specified point and stopping at the specified border co

lor. For a way of


*
flooding an area defined by the color of the starting point, see gdImage
Fill().
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue, red
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
red := gdImageColorAllocate(pImage, 255, 0, 0)
*
*
// Draw an ellipse
*
gdImageArc(pImage, 50, 25, 98, 48, 0, 360, blue)
*
*
// Fill the ellipse
*
gdImageFillToBorder(pImage, 50, 50, blue, red)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageArc()
* $END$
*/
/*
*
*
*
*
*
*
*
*
*
*
*
*
*

$DOC$
$FUNCNAME$
gdImageFill()
$CATEGORY$
GDLibrary
$ONELINER$
floods a portion of the image with the specified color.
$SYNTAX$
gdImageFill( <pImage>, <x>, <y>, <nColor> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<x>
- start point horizontal position
<y>
- start point vertical position
<nColor>
- Color index of filling color

* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageFill() floods a portion of the image with the specified color, be
ginning at the
*
specified point and flooding the surrounding region of the same color as
the starting point.
*
For a way of flooding a region defined by a specific border color rather
than by its interior
*
color, see gdImageFillToBorder().
*
The fill color can be gdTiled, resulting in a tile fill using another im
age as the tile.
*
However, the tile image cannot be transparent. If the image you wish to
fill with has a
*
transparent color index, call gdImageTransparent on the tile image and s
et the transparent
*
color index to -1 to turn off its transparency.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue, red
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
red := gdImageColorAllocate(pImage, 255, 0, 0)
*
*
// Draw an ellipse
*
gdImageArc(pImage, 50, 25, 98, 48, 0, 360, blue)
*
*
// Fill the ellipse
*
gdImageFill(pImage, 50, 50, red)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageArc()
* $END$
*/

/* $DOC$
* $FUNCNAME$
*
gdImageSetAntiAliased()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
specify the actual foreground color to be used when drawing antialiased
lines.
* $SYNTAX$
*
gdImageSetAntiAliased( <pImage>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<nColor>
- Color index of filling color
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
"Antialiasing" is a process by which jagged edges associated with line d
rawing
*
can be reduced by blending the foreground color with an appropriate perc
entage of
*
the background, depending on how much of the pixel in question is actual
ly within
*
the boundaries of the line being drawn. All line-drawing functions, such
as gdImageLine(),
*
gdImageOpenPolygon() and gdImagePolygon(), will draw antialiased lines i
f the special "color"
*
gdAntiAliased constant is used when calling them.
*
*
gdImageSetAntiAliased is used to specify the actual foreground color to
be used when drawing
*
antialiased lines. You may set any color to be the foreground, however a
s of version 2.0.12
*
an alpha channel component is not supported.
*
*
Antialiased lines can be drawn on both truecolor and palette-based image
s. However,
*
attempts to draw antialiased lines on highly complex palette-based backg
rounds may not give
*
satisfactory results, due to the limited number of colors available in t
he palette. Antialiased
*
line-drawing on simple backgrounds should work well with palette-based i
mages; otherwise create
*
or fetch a truecolor image instead.
*
*
You need not take any special action when you are finished with antialis
ed line drawing.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*
* $EXAMPLES$
*
*
#include "gd.ch"
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL blue, red
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

// Allocate color
/* Background color (first allocated) */
blue := gdImageColorAllocate(pImage, 0, 0, 255)
red := gdImageColorAllocate(pImage, 255, 0, 0)
gdImageSetAntiAliased(pImage, blue)
// Draw a smooth line
gdImageLine(pImage, 0, 0, 99, 9, gdAntiAliased)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )

RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageLine(), gdAntiAliased, gdSetAntiAliasedDontBlend()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdSetAntiAliasedDontBlend()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
indicate the special color that the foreground should stand out more cle
arly against.
* $SYNTAX$
*
gdSetAntiAliasedDontBlend( <pImage>, <nColor> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<nColor>
- Color index of filling color
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
Normally, when drawing lines with the special gdAntiAliased "color," ble
nding with
*
the background to reduce jagged edges is the desired behavior. However,
when it is
*
desired that lines not be blended with one particular color when it is e
ncountered
*
in the background, the gdImageSetAntiAliasedDontBlend() function can be
used to indicate
*
the special color that the foreground should stand out more clearly agai
nst.
*
*
To set the color index you have to use gdImageColorAllocate() function.
*

* $EXAMPLES$
*
*
#include "gd.ch"
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL black, white, blue
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color
*
/* Background color (first allocated) */
*
black := gdImageColorAllocate(pImage, 0, 0, 0)
*
white := gdImageColorAllocate(pImage, 255, 255, 255)
*
blue := gdImageColorAllocate(pImage, 0, 0, 255)
*
*
gdImageSetAntiAliased(pImage, blue)
*
*
// The portion of the line that crosses this white rectangle will not
be blended smoothly
*
gdImageSetAntiAliasedDontBlend(pImage, white)
*
*
// Draw a smooth line
*
gdImageLine(pImage, 0, 0, 99, 9, gdAntiAliased)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageLine(), gdAntiAliased, gdSetAntiAlias()
* $END$
*/
/*
*
*
*
*
*
*
.
*
*
*
*
*

$DOC$
$FUNCNAME$
gdImageSetBrush()
$CATEGORY$
GDLibrary
$ONELINER$
A "brush" is an image used to draw wide, shaped strokes in another image
$SYNTAX$
gdImageSetBrush( <pImage>, <pBrush> ) --> NIL
$ARGUMENTS$
<pImage>
- Image pointer
<pBrush>
- Brush Image pointer

* $RETURNS$
*
NIL
* $DESCRIPTION$
*
A "brush" is an image used to draw wide, shaped strokes in another image
.
*
Just as a paintbrush is not a single point, a brush image need not be a
single pixel.
*
Any gd image can be used as a brush, and by setting the transparent colo
r index of the
*
brush image with gdImageColorTransparent, a brush of any shape can be cr
eated.
*
All line-drawing functions, such as gdImageLine, gdImageOpenPolygon and
gdImagePolygon,
*
will use the current brush if the special "color" gdBrushed or gdStyledB
rushed is used
*
when calling them.
*
gdImageSetBrush is used to specify the brush to be used in a particular
image.
*
You can set any image to be the brush. If the brush image does not have
the same color
*
map as the first image, any colors missing from the first image will be
allocated.
*
If not enough colors can be allocated, the closest colors already availa
ble will be used.
*
This allows arbitrary PNGs to be used as brush images. It also means, ho
wever, that you
*
should not set a brush unless you will actually use it; if you set a rap
id succession of
*
different brush images, you can quickly fill your color map, and the res
ults will not be
*
optimal.
*
*
You need not take any special action when you are finished with a brush.
As for any other image,
*
if you will not be using the brush image for any further purpose, you sh
ould call gdImageDestroy.
*
You must not use the color gdBrushed if the current brush has been destr
oyed; you can of course
*
set a new brush to replace it.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage, pBrush
*
LOCAL blue, red
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Open the brush PNG. For best results, portions of the brush that sh
ould be transparent
*
// (ie, not part of the brush shape) should have the transparent color
index.
*
pBrush := gdImageCreateFromPng( "mybrush.png" )
*
*
// Allocate color (background color is the first allocate)
*
black := gdImageColorAllocate(pImage, 0, 0, 0)
*
*
// Set the brush
*
gdImageSetBrush(pImage, pBrush)

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

// Draw a line from the upper left corner to the lower


// right corner using the brush.
gdImageLine(pImage, 0, 0, 99, 99, gdBrushed)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )
// Destroy the brush image
gdImageDestroy( pBrush )

RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageLine()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageSetTile()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
A "tile" is an image used to fill an area with a repeated pattern.
* $SYNTAX$
*
gdImageSetTile( <pImage>, <pTile> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<pTile>
- Tile Image pointer
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
A "tile" is an image used to fill an area with a repeated pattern.
*
Any gd image can be used as a tile, and by setting the transparent color
index of
*
the tile image with gdImageColorTransparent, a tile that allows certain
parts of
*
the underlying area to shine through can be created. All region-filling
functions,
*
such as gdImageFill and gdImageFilledPolygon, will use the current tile
if the special
*
"color" gdTiled is used when calling them.
*
*
gdImageSetTile is used to specify the tile to be used in a particular im
age. You can
*
set any image to be the tile. If the tile image does not have the same c
olor map as
*
the first image, any colors missing from the first image will be allocat

ed. If not
*
enough colors can be allocated, the closest colors already available wil
l be used.
*
This allows arbitrary PNGs to be used as tile images. It also means, how
ever, that you
*
should not set a tile unless you will actually use it; if you set a rapi
d succession of
*
different tile images, you can quickly fill your color map, and the resu
lts will not be optimal.
*
*
You need not take any special action when you are finished with a tile.
As for any other
*
image, if you will not be using the tile image for any further purpose,
you should call
*
gdImageDestroy. You must not use the color gdTiled if the current tile h
as been destroyed;
*
you can of course set a new tile to replace it.
*
* $EXAMPLES$
*
*
PROCEDURE Main()
*
LOCAL pImage, pTile
*
LOCAL blue, red
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Open the tile PNG. For best results, portions of the
*
// tile that should be transparent (ie, allowing the
*
// background to shine through) should have the transparent
*
// color index.
*
pTile := gdImageCreateFromPng( "mytile.png" )
*
*
// Allocate color (background color is the first allocate)
*
black := gdImageColorAllocate(pImage, 0, 0, 0)
*
*
// Set the tile
*
gdImageSetTile(pImage, pTile)
*
*
// Fill an area using the tile
*
gdImageFilledRectangle(pImage, 25, 25, 75, 75, gdTiled)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
// Destroy the tile image
*
gdImageDestroy( pTile )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c

* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageFilledRectangle()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageSetStyle()
* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
set any desired series of colors to be repeated during the drawing of a
line.
* $SYNTAX$
*
gdImageSetStyle( <pImage>, <aStyle> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<aStyle>
- Array of colors and special colors used to "style" a li
ne
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
It is often desirable to draw dashed lines, dotted lines, and other vari
ations
*
on a broken line. gdImageSetStyle can be used to set any desired series
of colors,
*
including a special color that leaves the background intact, to be repea
ted during
*
the drawing of a line.
*
To use gdImageSetStyle, create an array of integers and assign them the
desired series
*
of color values to be repeated. You can assign the special color value g
dTransparent
*
to indicate that the existing color should be left unchanged for that pa
rticular pixel
*
(allowing a dashed line to be attractively drawn over an existing image)
.
*
*
Then, to draw a line using the style, use the normal gdImageLine functio
n with the
*
special color value gdStyled.
*
*
The style array is copied when you set the style, so you need not be con
cerned with
*
keeping the array around indefinitely. This should not break existing co
de that assumes
*
styles are not copied.
*
*
You can also combine styles and brushes to draw the brush image at inter
vals instead of
*
in a continuous stroke. When creating a style for use with a brush, the
style values are
*
interpreted differently: zero (0) indicates pixels at which the brush sh
ould not be drawn,
*
while one (1) indicates pixels at which the brush should be drawn. To dr
aw a styled,
*
brushed line, you must use the special color value gdStyledBrushed.
*
* $EXAMPLES$

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

#include "gd.ch"
PROCEDURE Main()
LOCAL pImage, aStyleDotted := {}, aStyleDashed := {}
LOCAL black, red
// Create an image in memory
pImage := gdImageCreate( 100, 100 )
// Allocate color (background color is the first allocate)
black := gdImageColorAllocate(pImage, 0, 0, 0)
red := gdImageColorAllocate(pImage, 255, 0, 0)
// Set up dotted style. Leave every other pixel alone.
aAdd( aStyleDotted, red )
aAdd( aStyleDotted, gdTransparent )
// Set up dashed style. Three on,
aAdd( aStyleDashed, red )
aAdd( aStyleDashed, red )
aAdd( aStyleDashed, red )
aAdd( aStyleDashed, gdTransparent
aAdd( aStyleDashed, gdTransparent
aAdd( aStyleDashed, gdTransparent

three off.

)
)
)

// Set dotted style.


gdImageSetStyle(pImage, aStyleDotted)
// Draw a line from the upper left corner to the lower right corner.
gdImageLine(pImage, 0, 0, 99, 99, gdStyled)
// Now the dashed line.
gdImageSetStyle(pImage, aStyleDashed)
gdImageLine(pimage, 0, 99, 0, 99, gdStyled)
// Save the image
gdImageJpeg( pImage, "myimage.jpg" )
// Destroy the image
gdImageDestroy( pImage )

RETURN
$STATUS$
R
$COMPLIANCE$
GD Library
$PLATFORMS$
All
$FILES$
tgd/source/gdwrp.c
$SEEALSO$
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageLine()
* $END$
*/
/* $DOC$
* $FUNCNAME$
*
gdImageSetThickness()

* $CATEGORY$
*
GDLibrary
* $ONELINER$
*
determines the width of lines drawn in pixels.
* $SYNTAX$
*
gdImageSetThickness( <pImage>, <nThickness> ) --> NIL
* $ARGUMENTS$
*
<pImage>
- Image pointer
*
<nThickness> - width of line in pixel
* $RETURNS$
*
NIL
* $DESCRIPTION$
*
gdImageSetThickness determines the width of lines drawn by the gdImageLi
ne,
*
gdImagePolygon, gdImageOpenPolygon and related functions, in pixels.
*
* $EXAMPLES$
*
*
#include "gd.ch"
*
*
PROCEDURE Main()
*
LOCAL pImage
*
LOCAL black, white
*
*
// Create an image in memory
*
pImage := gdImageCreate( 100, 100 )
*
*
// Allocate color (background color is the first allocate)
*
black := gdImageColorAllocate(pImage, 0, 0, 0)
*
white := gdImageColorAllocate(pImage, 255, 255, 255)
*
*
// Set thickness.
*
gdImageSetThickness(pImage, 4)
*
*
// Draw a fat line from the upper left corner to the lower right corne
r.
*
gdImageLine(pImage, 0, 0, 99, 99, white)
*
*
// Save the image
*
gdImageJpeg( pImage, "myimage.jpg" )
*
*
// Destroy the image
*
gdImageDestroy( pImage )
*
*
RETURN
* $STATUS$
*
R
* $COMPLIANCE$
*
GD Library
* $PLATFORMS$
*
All
* $FILES$
*
tgd/source/gdwrp.c
* $SEEALSO$
*
gdImageDestroy(), gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()
, gdImageLine()
* $END$
*/

Anda mungkin juga menyukai