
#
# GENERATED WITH PDL::PP! Don't modify!
#
package PDL::IO::GD;

our @EXPORT_OK = qw(PDL::PP write_png PDL::PP write_png_ex PDL::PP write_true_png PDL::PP write_true_png_ex  write_png_best write_true_png_best  recompress_png_best  load_lut read_png read_true_png PDL::PP _read_true_png PDL::PP _read_png PDL::PP _gd_image_to_pdl_true PDL::PP _gd_image_to_pdl PDL::PP _pdl_to_gd_image_true PDL::PP _pdl_to_gd_image_lut  read_png_lut PDL::PP _read_png_lut PDL::PP _gdImageColorAllocates PDL::PP _gdImageColorAllocateAlphas PDL::PP _gdImageSetPixels PDL::PP _gdImageLines PDL::PP _gdImageDashedLines PDL::PP _gdImageRectangles PDL::PP _gdImageFilledRectangles PDL::PP _gdImageFilledArcs PDL::PP _gdImageArcs PDL::PP _gdImageFilledEllipses  gdAlphaBlend   gdTrueColor   gdTrueColorAlpha   gdFree   gdFontGetLarge   gdFontGetSmall   gdFontGetMediumBold   gdFontGetGiant   gdFontGetTiny  );
our %EXPORT_TAGS = (Func=>[@EXPORT_OK]);

use PDL::Core;
use PDL::Exporter;
use DynaLoader;



   
   our @ISA = ( 'PDL::Exporter','DynaLoader' );
   push @PDL::Core::PP, __PACKAGE__;
   bootstrap PDL::IO::GD ;




=head1 NAME

PDL::IO::GD - Interface to the GD image library.

=head1 SYNOPSIS

 my $pdl = sequence(byte, 30, 30);
 write_png($pdl, load_lut($lutfile), "test.png");

 write_true_png(sequence(100, 100, 3), "test_true.png");

 my $image = read_png("test.png");

 my $image = read_true_png("test_true_read.png");
 write_true_png($image, "test_true_read.out.png");

 my $lut = read_png_lut("test.png");

 $pdl = sequence(byte, 30, 30);
 write_png_ex($pdl, load_lut($lutfile), "test_nocomp.png", 0);
 write_png_ex($pdl, load_lut($lutfile), "test_bestcomp1.png", 9);
 write_png_best($pdl, load_lut($lutfile), "test_bestcomp2.png");

 $pdl = sequence(100, 100, 3);
 write_true_png_ex($pdl, "test_true_nocomp.png", 0);
 write_true_png_ex($pdl, "test_true_bestcomp1.png", 9);
 write_true_png_best($pdl, "test_true_bestcomp2.png");

 recompress_png_best("test_recomp_best.png");

=head1 DESCRIPTION

This is the "General Interface" for the PDL::IO::GD library, and is actually several
years old at this point (read: stable). If you're feeling frisky, try the new OO 
interface described below.

The general version just provides several image IO utility functions you can use with
piddle variables. It's deceptively useful, however.

=cut








=head1 FUNCTIONS



=cut






=head2 write_png

=for sig

  Signature: (byte img(x,y); byte lut(i,j); char* filename)

Writes a 2-d PDL variable out to a PNG file, using the supplied color look-up-table piddle
(hereafter referred to as a LUT).

The LUT contains a line for each value 0-255 with a corresponding R, G, and B value.


=for bad

write_png does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.


=cut






*write_png = \&PDL::write_png;





=head2 write_png_ex

=for sig

  Signature: (img(x,y); lut(i,j); char* filename; int level)

=for ref

Same as write_png(), except you can specify the compression level (0-9) as the last argument.


=for bad

write_png_ex does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.


=cut






*write_png_ex = \&PDL::write_png_ex;





=head2 write_true_png

=for sig

  Signature: (img(x,y,z); char* filename)

Writes an (x, y, z(3)) PDL variable out to a PNG file, using a true color format.

This means a larger file on disk, but can contain more than 256 colors.


=for bad

write_true_png does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.


=cut






*write_true_png = \&PDL::write_true_png;





=head2 write_true_png_ex

=for sig

  Signature: (img(x,y,z); char* filename; int level)

=for ref

Same as write_true_png(), except you can specify the compression level (0-9) as the last argument.


=for bad

write_true_png_ex does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.


=cut






*write_true_png_ex = \&PDL::write_true_png_ex;




=head2 write_png_best

Like write_png(), but it assumes the best PNG compression (9).

=for example

  write_png_best( $img(piddle), $lut(piddle), $filename )

=cut


sub write_png_best
{
    my $img = shift;
    my $lut = shift;
    my $filename = shift;
    return write_png_ex( $img, $lut, $filename, 9 );
} # End of write_png_best()...

=head2 write_true_png_best

Like write_true_png(), but it assumes the best PNG compression (9).

=for example

  write_true_png_best( $img(piddle), $filename )

=cut


sub write_true_png_best
{
    my $img = shift;
    my $filename = shift;
    return write_true_png_ex( $img, $filename, 9 );
} # End of write_true_png_best()...






=head2 load_lut( $filename )

Loads a color look up table from an ASCII file. returns a piddle

=cut


sub load_lut
{
    return xchg(byte(cat(rcols(shift))), 0, 1);
} # end of load_lut()...

=head2 read_png( $filename )

Reads a (palette) PNG image into a (new) PDL variable.

=cut


sub read_png
{
    my $filename = shift;

    # Get the image dims...
    my $x = _get_png_xs($filename);
    my $y = _get_png_ys($filename);
    #print "\$x=$x\t\$y=$y\n";

    my $temp = zeroes(long, $x, $y);
    _read_png($temp, $filename);
    return byte($temp);
} # End of read_png()...

=head2 read_png_true( $filename )

Reads a true color PNG image into a (new) PDL variable.

=cut


sub read_true_png
{
    my $filename = shift;

    # Get the image dims...
    my $x = _get_png_xs($filename);
    my $y = _get_png_ys($filename);
    #print "\$x=$x\t\$y=$y\n";


    my $temp = zeroes(long, $x, $y, 3);
    _read_true_png($temp, $filename);
    return byte($temp);
} # End of read_png()...






*_read_true_png = \&PDL::_read_true_png;





*_read_png = \&PDL::_read_png;





*_gd_image_to_pdl_true = \&PDL::_gd_image_to_pdl_true;





*_gd_image_to_pdl = \&PDL::_gd_image_to_pdl;





*_pdl_to_gd_image_true = \&PDL::_pdl_to_gd_image_true;





*_pdl_to_gd_image_lut = \&PDL::_pdl_to_gd_image_lut;




=head2 read_png_lut( $filename )

Reads a color LUT from an already-existing palette PNG file.

=cut


sub read_png_lut
{
    my $filename = shift;
    my $lut = zeroes(byte, 3, 256);
    _read_png_lut($lut, $filename);
    return $lut;
} # End of read_png_lut()...




*_read_png_lut = \&PDL::_read_png_lut;





*_gdImageColorAllocates = \&PDL::_gdImageColorAllocates;





*_gdImageColorAllocateAlphas = \&PDL::_gdImageColorAllocateAlphas;





*_gdImageSetPixels = \&PDL::_gdImageSetPixels;





*_gdImageLines = \&PDL::_gdImageLines;





*_gdImageDashedLines = \&PDL::_gdImageDashedLines;





*_gdImageRectangles = \&PDL::_gdImageRectangles;





*_gdImageFilledRectangles = \&PDL::_gdImageFilledRectangles;





*_gdImageFilledArcs = \&PDL::_gdImageFilledArcs;





*_gdImageArcs = \&PDL::_gdImageArcs;





*_gdImageFilledEllipses = \&PDL::_gdImageFilledEllipses;



;


=head1 OO INTERFACE
 
Object Oriented interface to the GD image library.

=head1 SYNOPSIS

 # Open an existing file:
 # 
 my $gd = PDL::IO::GD->new( { filename => "test.png" } );
 
 # Query the x and y sizes:
 my $x = $gd->SX();
 my $y = $gd->SY();

 # Grab the PDL of the data:
 my $pdl = $gd->to_pdl();

 # Kill this thing:
 $gd->DESTROY();

 # Create a new object:
 # 
 my $im = PDL::IO::GD->new( { x => 300, y => 300 } );

 # Allocate some colors:
 #
 my $black = $im->ColorAllocate( 0, 0, 0 );
 my $red = $im->ColorAllocate( 255, 0, 0 );
 my $green = $im->ColorAllocate( 0, 255, 0 );
 my $blue = $im->ColorAllocate( 0, 0, 255 );

 # Draw a rectangle:
 $im->Rectangle( 10, 10, 290, 290, $red );

 # Add some text:
 $im->String( gdFontGetLarge(), 20, 20, "Test Large Font!", $green );

 # Write the output file:
 $im->write_Png( "test2.png" );

=head1 DESCRIPTION

This is the Object-Oriented interface from PDL to the GD image library.

See L<http://www.boutell.com/gd/> for more information on the GD library and how it works.

=head2 IMPLEMENTATION NOTES

Surprisingly enough, this interface has nothing to do with the other Perl->GD interface module, 
aka 'GD' (as in 'use GD;'). This is done from scratch over the years.

Requires at least version 2.0.22 of the GD library, but it's only been thoroughly tested with
gd-2.0.33, so it would be best to use that. The 2.0.22 requirement has to do with a change in
GD's font handling functions, so if you don't use those, then don't worry about it.

I should also add, the statement about "thoroughly tested" above is mostly a joke. This OO 
interface is very young, and it has I<barely> been tested at all, so if something 
breaks, email me and I'll get it fixed ASAP (for me).

Functions that manipulate and query the image objects generally have a 'gdImage' prefix on the
function names (ex: gdImageString()). I've created aliases here for all of those member 
functions so you don't have to keep typing 'gdImage' in your code, but the long version are in 
there as well.

=head1 METHODS

=cut

use PDL;
use PDL::Slices;
use PDL::IO::Misc;

#
# Some helper functions:
#
sub _pkg_name
    { return "PDL::IO::GD::" . (shift) . "()"; }

# ID a file type from it's filename:
sub _id_image_file
{
    my $filename = shift;
    
    return 'png'
        if( $filename =~ /\.png$/ );
    
    return 'jpg'
        if( $filename =~ /\.jpe?g$/ );
    
    return 'wbmp'
        if( $filename =~ /\.w?bmp$/ );
    
    return 'gd'
        if( $filename =~ /\.gd$/ );
    
    return 'gd2'
        if( $filename =~ /\.gd2$/ );
    
    return 'gif'
        if( $filename =~ /\.gif$/ );
    
    return 'xbm'
        if( $filename =~ /\.xbm$/ );
        
    return undef;
} # End of _id_image_file()...

# Load a new file up (don't read it yet):
sub _img_ptr_from_file
{
    my $filename = shift;
    my $type = shift;
    
    return _gdImageCreateFromPng( $filename )
        if( $type eq 'png' );
    
    return _gdImageCreateFromJpeg( $filename )
        if( $type eq 'jpg' );
        
    return _gdImageCreateFromWBMP( $filename )
        if( $type eq 'wbmp' );
        
    return _gdImageCreateFromGd( $filename )
        if( $type eq 'gd' );
    
    return _gdImageCreateFromGd2( $filename )
        if( $type eq 'gd2' );
    
    return _gdImageCreateFromGif( $filename )
        if( $type eq 'gif' );
            
    return _gdImageCreateFromXbm( $filename )
        if( $type eq 'xbm' );
    
    return undef;
} # End of _img_ptr_from_file()...

# ID a file type from it's "magic" header in the image data:
sub _id_image_data 
{
    my $data = shift;
    my $magic = substr($data,0,4);
    
    return 'png'
        if( $magic eq "\x89PNG" );
    
    return 'jpg'
        if( $magic eq "\377\330\377\340" );
    return 'jpg'
        if( $magic eq "\377\330\377\341" );
    return 'jpg'
        if( $magic eq "\377\330\377\356" );
        
    return 'gif'
        if( $magic eq "GIF8" );
    
    return 'gd2'
        if( $magic eq "gd2\000" );
        
    # Still need filters for WBMP and .gd!
    
    return undef;
} # End of _id_image_data()...


# Load a new data scalar up:
sub _img_ptr_from_data
{
    my $data = shift;
    my $type = shift;
    
    return _gdImageCreateFromPngPtr( $data )
        if( $type eq 'png' );
    
    return _gdImageCreateFromJpegPtr( $data )
        if( $type eq 'jpg' );
        
    return _gdImageCreateFromWBMPPtr( $data )
        if( $type eq 'wbmp' );
        
    return _gdImageCreateFromGdPtr( $data )
        if( $type eq 'gd' );
    
    return _gdImageCreateFromGd2Ptr( $data )
        if( $type eq 'gd2' );
    
    return _gdImageCreateFromGifPtr( $data )
        if( $type eq 'gif' );
    
    return undef;
} # End of _img_ptr_from_data()...


=head2 new

Creates a new PDL::IO::GD object.

Accepts a hash describing how to create the object. Accepts a single hash ( with
curly braces ), an inline hash (the same, but without the braces) or a single
string interpreted as a filename. Thus the following are all equivalent:

 PDL::IO::GD->new( {filename => 'image.png'} );
 PDL::IO::GD->new( filename => 'image.png' );
 PDL::IO::GD->new( 'image.png' );

If the hash has:

 pdl => $pdl_var (lut => $lut_piddle)
    Then a new GD is created from that PDL variable.

 filename => $file
    Then a new GD is created from the image file.
    
 x => $num, y => $num
    Then a new GD is created as a palette image, with size x, y
    
 x => $num, y => $num, true_color => 1
    Then a new GD is created as a true color image, with size x, y

 data => $scalar (type => $typename)
    Then a new GD is created from the file data stored in $scalar. 
    If no type is given, then it will try to guess the type of the data, but 
        this will not work for WBMP and gd image types. For those types, you 
        _must_ specify the type of the data, or the operation will fail.
    Valid types are: 'jpg', 'png', 'gif', 'gd', 'gd2', 'wbmp'.
    
Example:
 
 my $gd = PDL::IO::GD->new({ pdl => $pdl_var });
    
 my $gd = PDL::IO::GD->new({ pdl => $pdl_var, lut => $lut_piddle });
 
 my $gd = PDL::IO::GD->new({ filename => "image.png" });
 
 my $gd = PDL::IO::GD->new({ x => 100, y => 100 });
 
 my $gd = PDL::IO::GD->new({ x => 100, y => 100, true_color => 1 });
 
 my $gd = PDL::IO::GD->new({ data => $imageData });
 
 my $gd = PDL::IO::GD->new({ data => $imageData, type => 'wbmp' });

=cut

sub new
{
    my $proto = shift;
    my $class = ref($proto) || $proto;
    #my $self  = $class->SUPER::new( @_ );
    my $self = {};
    
    my $sub = _pkg_name( "new" );
    
    # Figure out our options:

    # I want a single hash. I handle several cases here
    my $options;
    if( @_ == 1 && ref $_[0] eq 'HASH' ) {
      # single hash argument. Just take it
      $options = shift;
    }
    elsif( @_ == 1 && ! ref $_[0] ) {
      # single scalar argument. Treat it as a filename by default
      my $filename = shift;
      $options = { filename => $filename };
    }
    else {
      # the only other acceptable option is an inline hash. This is valid if I
      # have an even number of arguments, and the even-indexed ones (the keys)
      # are scalars
      if( @_ % 2 == 0 ) {
        my @pairs = @_;
        my $Npairs = scalar(@pairs)/2;

        use List::MoreUtils 'none';
        if( List::MoreUtils::none { ref $pairs[2*$_] } 0..$Npairs-1 ) {
          # treat the arguments as a hash
          $options = { @pairs }
        }
      }
    }

    if( !defined $options ) {
      die <<EOF;
PDL::IO::GD::new couldn't parse its arguments.
Expected a hash-ref or an inline hash or just a filename
EOF
    }


    
    if( defined( $options->{pdl} ) )
    {   # Create it from a PDL variable:
        my $pdl = $options->{pdl};
        $pdl->make_physical();
        my $num_dims = scalar( $pdl->dims() );
        if( $num_dims == 2 )
        {
            if( defined( $options->{lut} ) )
            {
                my $ptr = zeroes( longlong, 1 );
                my $lut = $options->{lut};
                _pdl_to_gd_image_lut( $pdl, $lut, $ptr );
#		print STDERR "in new (with lut), setting IMG_PTR to " . $ptr->at(0) . "\n";
                $self->{IMG_PTR} = $ptr->at(0);
                $ptr = null;
                die "$sub: _pdl_to_gd_image_lut() failed!\n"
                    if( $self->{IMG_PTR} == 0 );
            }
            else
            {
                my $ptr = zeroes( longlong, 1 );
                my $lut = sequence(byte, 255)->slice("*3,:");
                _pdl_to_gd_image_lut( $pdl, $lut, $ptr );
#		print STDERR "in new (no lut), setting IMG_PTR to " . $ptr->at(0) . "\n";
                $self->{IMG_PTR} = $ptr->at(0);
                $ptr = null;
                die "$sub: _pdl_to_gd_image_lut() failed!\n"
                    if( $self->{IMG_PTR} == 0 );
            }
        }
        elsif( $num_dims == 3 )
        {
            my $ptr = zeroes( longlong, 1 );
            _pdl_to_gd_image_true( $pdl, $ptr );
#	    print STDERR "in new (ndims=3), setting IMG_PTR to " . $ptr->at(0) . "\n";
            $self->{IMG_PTR} = $ptr->at(0);
            $ptr = null;
            die "$sub: _pdl_to_gd_image_true() failed!\n"
                if( $self->{IMG_PTR} == 0 );
        }
        else
        {
            die "Can't create a PDL::IO::GD from a PDL with bad dims!\n";
        }
    }
    elsif( exists( $options->{filename} ) )
    {   # Create it from a file:

        if( !defined $options->{filename} ) {
          die "PDL::IO::GD::new got an undefined filename. Giving up.\n";
        }

        # Figure out what type of file it is:
        $self->{input_type} = _id_image_file( $options->{filename} )
            or die "$sub: Can't determine image type of filename => \'$options->{filename}\'!\n";
        
        # Read in the file:
        $self->{IMG_PTR} = _img_ptr_from_file( $options->{filename}, $self->{input_type} )
            or die "$sub: Can't read in the input file!\n";
    }
    elsif( defined( $options->{x} ) && defined( $options->{y} ) )
    {   # Create an empty image:
        my $done = 0;
        if( defined( $options->{true_color} ) )
        {
            if( $options->{true_color} )
            {   # Create an empty true color image:
                $self->{IMG_PTR} = _gdImageCreateTrueColor( $options->{x}, $options->{y} );
                die "$sub: _gdImageCreateTrueColor() failed!\n"
                    if( $self->{IMG_PTR} == 0 );
                $done = 1;
            }
        }
        unless( $done )
        {   # Create an empty palette image:
            $self->{IMG_PTR} = _gdImageCreatePalette( $options->{x}, $options->{y} );
            die "$sub: _gdImageCreatePalette() failed!\n"
                if( $self->{IMG_PTR} == 0 );
        }
    }
    elsif( defined( $options->{data} ) )
    {   # Create an image from the given image data:
    
        # Figure out what type of file it is:
        if( defined( $options->{type} ) && 
            (      $options->{type} eq 'jpg'
                || $options->{type} eq 'png'
                || $options->{type} eq 'gif'
                || $options->{type} eq 'wbmp'
                || $options->{type} eq 'gd'
                || $options->{type} eq 'gd2' ) )
        {
            $self->{input_type} = $options->{type};
        }
        else
        {
            $self->{input_type} = _id_image_data( $options->{data} )
                or die "$sub: Can't determine image type given data!\n";
        }
        
        # Load the data:
        $self->{IMG_PTR} = _img_ptr_from_data( $options->{data}, $self->{input_type} )
            or die "$sub: Can't load the input image data!\n";
    }
    
    # Bless and return:
    #
    bless ($self, $class);    
    return $self;
} # End of new()...

=head2 to_pdl

When you're done playing with your GDImage and want a piddle back, use this function to return one.

=cut


sub to_pdl
{
    my $self = shift;

    my $sub = _pkg_name( "to_pdl" );
    
    my $x = $self->gdImageSX();
    my $y = $self->gdImageSY();
    
    if( $self->gdImageTrueColor() )
    {
        my $pdl = zeroes(byte, $x, $y, 3);
        _gd_image_to_pdl_true( $pdl, $self->{IMG_PTR} );
        return $pdl;
    }
    
    my $pdl = zeroes(byte, $x, $y);
    _gd_image_to_pdl( $pdl, $self->{IMG_PTR} );
    return $pdl;
} # End of to_pdl()...

=head2 apply_lut( $lut(piddle) )

Does a $im->ColorAllocate() for and entire LUT piddle at once.

The LUT piddle format is the same as for the general interface above.

=cut


sub apply_lut
{
    my $self = shift;
    my $lut = shift;
    
    # Let the PDL threading engine sort this out:
    $self->ColorAllocates( $lut->slice("(0),:"), $lut->slice("(1),:"), $lut->slice("(2),:") );
} # End of apply_lut()...

sub DESTROY
{
    my $self = shift;
    my $sub = _pkg_name( "DESTROY" );
 
    #print STDERR sprintf("$sub: destroying gdImagePtr: 0x%p (%d) (%ld) (%lld)!\n", $self->{IMG_PTR}, $self->{IMG_PTR},$self->{IMG_PTR},$self->{IMG_PTR});
    
    if( defined( $self->{IMG_PTR} ) )
    {
        _gdImageDestroy( $self->{IMG_PTR} );
        delete( $self->{IMG_PTR} );
    }
} # End of DESTROY()...

=head2 WARNING:

All of the docs below this point are auto-generated (not to mention the actual code), 
so read with a grain of salt, and B<always> check the main GD documentation about how 
that function works and what it does.

=cut



=head2 write_Png

$image->write_Png( $filename )

=cut


sub write_Png
{
    my $self = shift;
    return _gdImagePng ( $self->{IMG_PTR}, @_ );
} # End of write_Png()...


=head2 write_PngEx

$image->write_PngEx( $filename, $level )

=cut


sub write_PngEx
{
    my $self = shift;
    return _gdImagePngEx ( $self->{IMG_PTR}, @_ );
} # End of write_PngEx()...


=head2 write_WBMP

$image->write_WBMP( $fg, $filename )

=cut


sub write_WBMP
{
    my $self = shift;
    return _gdImageWBMP ( $self->{IMG_PTR}, @_ );
} # End of write_WBMP()...


=head2 write_Jpeg

$image->write_Jpeg( $filename, $quality )

=cut


sub write_Jpeg
{
    my $self = shift;
    return _gdImageJpeg ( $self->{IMG_PTR}, @_ );
} # End of write_Jpeg()...


=head2 write_Gd

$image->write_Gd( $filename )

=cut


sub write_Gd
{
    my $self = shift;
    return _gdImageGd ( $self->{IMG_PTR}, @_ );
} # End of write_Gd()...


=head2 write_Gd2

$image->write_Gd2( $filename, $cs, $fmt )

=cut


sub write_Gd2
{
    my $self = shift;
    return _gdImageGd2 ( $self->{IMG_PTR}, @_ );
} # End of write_Gd2()...


=head2 write_Gif

$image->write_Gif( $filename )

=cut


sub write_Gif
{
    my $self = shift;
    return _gdImageGif ( $self->{IMG_PTR}, @_ );
} # End of write_Gif()...


=head2 get_Png_data

$image->get_Png_data(  )

=cut


sub get_Png_data
{
    my $self = shift;
    return _gdImagePngPtr ( $self->{IMG_PTR}, @_ );
} # End of get_Png_data()...


=head2 get_PngEx_data

$image->get_PngEx_data( $level )

=cut


sub get_PngEx_data
{
    my $self = shift;
    return _gdImagePngPtrEx ( $self->{IMG_PTR}, @_ );
} # End of get_PngEx_data()...


=head2 get_WBMP_data

$image->get_WBMP_data( $fg )

=cut


sub get_WBMP_data
{
    my $self = shift;
    return _gdImageWBMPPtr ( $self->{IMG_PTR}, @_ );
} # End of get_WBMP_data()...


=head2 get_Jpeg_data

$image->get_Jpeg_data( $quality )

=cut


sub get_Jpeg_data
{
    my $self = shift;
    return _gdImageJpegPtr ( $self->{IMG_PTR}, @_ );
} # End of get_Jpeg_data()...


=head2 get_Gd_data

$image->get_Gd_data(  )

=cut


sub get_Gd_data
{
    my $self = shift;
    return _gdImageGdPtr ( $self->{IMG_PTR}, @_ );
} # End of get_Gd_data()...


=head2 get_Gd2_data

$image->get_Gd2_data( $cs, $fmt )

=cut


sub get_Gd2_data
{
    my $self = shift;
    return _gdImageGd2Ptr ( $self->{IMG_PTR}, @_ );
} # End of get_Gd2_data()...


=head2 SetPixel

$image->SetPixel( $x, $y, $color )

Alias for gdImageSetPixel.

=cut


sub SetPixel
{
    return gdImageSetPixel ( @_ );
} # End of SetPixel()...


=head2 gdImageSetPixel

$image->gdImageSetPixel( $x, $y, $color )

=cut


sub gdImageSetPixel
{
    my $self = shift;
    return _gdImageSetPixel ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetPixel()...


=head2 GetPixel

$image->GetPixel( $x, $y )

Alias for gdImageGetPixel.

=cut


sub GetPixel
{
    return gdImageGetPixel ( @_ );
} # End of GetPixel()...


=head2 gdImageGetPixel

$image->gdImageGetPixel( $x, $y )

=cut


sub gdImageGetPixel
{
    my $self = shift;
    return _gdImageGetPixel ( $self->{IMG_PTR}, @_ );
} # End of gdImageGetPixel()...


=head2 AABlend

$image->AABlend(  )

Alias for gdImageAABlend.

=cut


sub AABlend
{
    return gdImageAABlend ( @_ );
} # End of AABlend()...


=head2 gdImageAABlend

$image->gdImageAABlend(  )

=cut


sub gdImageAABlend
{
    my $self = shift;
    return _gdImageAABlend ( $self->{IMG_PTR}, @_ );
} # End of gdImageAABlend()...


=head2 Line

$image->Line( $x1, $y1, $x2, $y2, $color )

Alias for gdImageLine.

=cut


sub Line
{
    return gdImageLine ( @_ );
} # End of Line()...


=head2 gdImageLine

$image->gdImageLine( $x1, $y1, $x2, $y2, $color )

=cut


sub gdImageLine
{
    my $self = shift;
    return _gdImageLine ( $self->{IMG_PTR}, @_ );
} # End of gdImageLine()...


=head2 DashedLine

$image->DashedLine( $x1, $y1, $x2, $y2, $color )

Alias for gdImageDashedLine.

=cut


sub DashedLine
{
    return gdImageDashedLine ( @_ );
} # End of DashedLine()...


=head2 gdImageDashedLine

$image->gdImageDashedLine( $x1, $y1, $x2, $y2, $color )

=cut


sub gdImageDashedLine
{
    my $self = shift;
    return _gdImageDashedLine ( $self->{IMG_PTR}, @_ );
} # End of gdImageDashedLine()...


=head2 Rectangle

$image->Rectangle( $x1, $y1, $x2, $y2, $color )

Alias for gdImageRectangle.

=cut


sub Rectangle
{
    return gdImageRectangle ( @_ );
} # End of Rectangle()...


=head2 gdImageRectangle

$image->gdImageRectangle( $x1, $y1, $x2, $y2, $color )

=cut


sub gdImageRectangle
{
    my $self = shift;
    return _gdImageRectangle ( $self->{IMG_PTR}, @_ );
} # End of gdImageRectangle()...


=head2 FilledRectangle

$image->FilledRectangle( $x1, $y1, $x2, $y2, $color )

Alias for gdImageFilledRectangle.

=cut


sub FilledRectangle
{
    return gdImageFilledRectangle ( @_ );
} # End of FilledRectangle()...


=head2 gdImageFilledRectangle

$image->gdImageFilledRectangle( $x1, $y1, $x2, $y2, $color )

=cut


sub gdImageFilledRectangle
{
    my $self = shift;
    return _gdImageFilledRectangle ( $self->{IMG_PTR}, @_ );
} # End of gdImageFilledRectangle()...


=head2 SetClip

$image->SetClip( $x1, $y1, $x2, $y2 )

Alias for gdImageSetClip.

=cut


sub SetClip
{
    return gdImageSetClip ( @_ );
} # End of SetClip()...


=head2 gdImageSetClip

$image->gdImageSetClip( $x1, $y1, $x2, $y2 )

=cut


sub gdImageSetClip
{
    my $self = shift;
    return _gdImageSetClip ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetClip()...


=head2 GetClip

$image->GetClip( $x1P, $y1P, $x2P, $y2P )

Alias for gdImageGetClip.

=cut


sub GetClip
{
    return gdImageGetClip ( @_ );
} # End of GetClip()...


=head2 gdImageGetClip

$image->gdImageGetClip( $x1P, $y1P, $x2P, $y2P )

=cut


sub gdImageGetClip
{
    my $self = shift;
    return _gdImageGetClip ( $self->{IMG_PTR}, @_ );
} # End of gdImageGetClip()...


=head2 BoundsSafe

$image->BoundsSafe( $x, $y )

Alias for gdImageBoundsSafe.

=cut


sub BoundsSafe
{
    return gdImageBoundsSafe ( @_ );
} # End of BoundsSafe()...


=head2 gdImageBoundsSafe

$image->gdImageBoundsSafe( $x, $y )

=cut


sub gdImageBoundsSafe
{
    my $self = shift;
    return _gdImageBoundsSafe ( $self->{IMG_PTR}, @_ );
} # End of gdImageBoundsSafe()...


=head2 Char

$image->Char( $f, $x, $y, $c, $color )

Alias for gdImageChar.

=cut


sub Char
{
    return gdImageChar ( @_ );
} # End of Char()...


=head2 gdImageChar

$image->gdImageChar( $f, $x, $y, $c, $color )

=cut


sub gdImageChar
{
    my $self = shift;
    return _gdImageChar ( $self->{IMG_PTR}, @_ );
} # End of gdImageChar()...


=head2 CharUp

$image->CharUp( $f, $x, $y, $c, $color )

Alias for gdImageCharUp.

=cut


sub CharUp
{
    return gdImageCharUp ( @_ );
} # End of CharUp()...


=head2 gdImageCharUp

$image->gdImageCharUp( $f, $x, $y, $c, $color )

=cut


sub gdImageCharUp
{
    my $self = shift;
    return _gdImageCharUp ( $self->{IMG_PTR}, @_ );
} # End of gdImageCharUp()...


=head2 String

$image->String( $f, $x, $y, $s, $color )

Alias for gdImageString.

=cut


sub String
{
    return gdImageString ( @_ );
} # End of String()...


=head2 gdImageString

$image->gdImageString( $f, $x, $y, $s, $color )

=cut


sub gdImageString
{
    my $self = shift;
    return _gdImageString ( $self->{IMG_PTR}, @_ );
} # End of gdImageString()...


=head2 StringUp

$image->StringUp( $f, $x, $y, $s, $color )

Alias for gdImageStringUp.

=cut


sub StringUp
{
    return gdImageStringUp ( @_ );
} # End of StringUp()...


=head2 gdImageStringUp

$image->gdImageStringUp( $f, $x, $y, $s, $color )

=cut


sub gdImageStringUp
{
    my $self = shift;
    return _gdImageStringUp ( $self->{IMG_PTR}, @_ );
} # End of gdImageStringUp()...


=head2 String16

$image->String16( $f, $x, $y, $s, $color )

Alias for gdImageString16.

=cut


sub String16
{
    return gdImageString16 ( @_ );
} # End of String16()...


=head2 gdImageString16

$image->gdImageString16( $f, $x, $y, $s, $color )

=cut


sub gdImageString16
{
    my $self = shift;
    return _gdImageString16 ( $self->{IMG_PTR}, @_ );
} # End of gdImageString16()...


=head2 StringUp16

$image->StringUp16( $f, $x, $y, $s, $color )

Alias for gdImageStringUp16.

=cut


sub StringUp16
{
    return gdImageStringUp16 ( @_ );
} # End of StringUp16()...


=head2 gdImageStringUp16

$image->gdImageStringUp16( $f, $x, $y, $s, $color )

=cut


sub gdImageStringUp16
{
    my $self = shift;
    return _gdImageStringUp16 ( $self->{IMG_PTR}, @_ );
} # End of gdImageStringUp16()...


=head2 Polygon

$image->Polygon( $p, $n, $c )

Alias for gdImagePolygon.

=cut


sub Polygon
{
    return gdImagePolygon ( @_ );
} # End of Polygon()...


=head2 gdImagePolygon

$image->gdImagePolygon( $p, $n, $c )

=cut


sub gdImagePolygon
{
    my $self = shift;
    return _gdImagePolygon ( $self->{IMG_PTR}, @_ );
} # End of gdImagePolygon()...


=head2 FilledPolygon

$image->FilledPolygon( $p, $n, $c )

Alias for gdImageFilledPolygon.

=cut


sub FilledPolygon
{
    return gdImageFilledPolygon ( @_ );
} # End of FilledPolygon()...


=head2 gdImageFilledPolygon

$image->gdImageFilledPolygon( $p, $n, $c )

=cut


sub gdImageFilledPolygon
{
    my $self = shift;
    return _gdImageFilledPolygon ( $self->{IMG_PTR}, @_ );
} # End of gdImageFilledPolygon()...


=head2 ColorAllocate

$image->ColorAllocate( $r, $g, $b )

Alias for gdImageColorAllocate.

=cut


sub ColorAllocate
{
    return gdImageColorAllocate ( @_ );
} # End of ColorAllocate()...


=head2 gdImageColorAllocate

$image->gdImageColorAllocate( $r, $g, $b )

=cut


sub gdImageColorAllocate
{
    my $self = shift;
    return _gdImageColorAllocate ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorAllocate()...


=head2 ColorAllocateAlpha

$image->ColorAllocateAlpha( $r, $g, $b, $a )

Alias for gdImageColorAllocateAlpha.

=cut


sub ColorAllocateAlpha
{
    return gdImageColorAllocateAlpha ( @_ );
} # End of ColorAllocateAlpha()...


=head2 gdImageColorAllocateAlpha

$image->gdImageColorAllocateAlpha( $r, $g, $b, $a )

=cut


sub gdImageColorAllocateAlpha
{
    my $self = shift;
    return _gdImageColorAllocateAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorAllocateAlpha()...


=head2 ColorClosest

$image->ColorClosest( $r, $g, $b )

Alias for gdImageColorClosest.

=cut


sub ColorClosest
{
    return gdImageColorClosest ( @_ );
} # End of ColorClosest()...


=head2 gdImageColorClosest

$image->gdImageColorClosest( $r, $g, $b )

=cut


sub gdImageColorClosest
{
    my $self = shift;
    return _gdImageColorClosest ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorClosest()...


=head2 ColorClosestAlpha

$image->ColorClosestAlpha( $r, $g, $b, $a )

Alias for gdImageColorClosestAlpha.

=cut


sub ColorClosestAlpha
{
    return gdImageColorClosestAlpha ( @_ );
} # End of ColorClosestAlpha()...


=head2 gdImageColorClosestAlpha

$image->gdImageColorClosestAlpha( $r, $g, $b, $a )

=cut


sub gdImageColorClosestAlpha
{
    my $self = shift;
    return _gdImageColorClosestAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorClosestAlpha()...


=head2 ColorClosestHWB

$image->ColorClosestHWB( $r, $g, $b )

Alias for gdImageColorClosestHWB.

=cut


sub ColorClosestHWB
{
    return gdImageColorClosestHWB ( @_ );
} # End of ColorClosestHWB()...


=head2 gdImageColorClosestHWB

$image->gdImageColorClosestHWB( $r, $g, $b )

=cut


sub gdImageColorClosestHWB
{
    my $self = shift;
    return _gdImageColorClosestHWB ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorClosestHWB()...


=head2 ColorExact

$image->ColorExact( $r, $g, $b )

Alias for gdImageColorExact.

=cut


sub ColorExact
{
    return gdImageColorExact ( @_ );
} # End of ColorExact()...


=head2 gdImageColorExact

$image->gdImageColorExact( $r, $g, $b )

=cut


sub gdImageColorExact
{
    my $self = shift;
    return _gdImageColorExact ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorExact()...


=head2 ColorExactAlpha

$image->ColorExactAlpha( $r, $g, $b, $a )

Alias for gdImageColorExactAlpha.

=cut


sub ColorExactAlpha
{
    return gdImageColorExactAlpha ( @_ );
} # End of ColorExactAlpha()...


=head2 gdImageColorExactAlpha

$image->gdImageColorExactAlpha( $r, $g, $b, $a )

=cut


sub gdImageColorExactAlpha
{
    my $self = shift;
    return _gdImageColorExactAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorExactAlpha()...


=head2 ColorResolve

$image->ColorResolve( $r, $g, $b )

Alias for gdImageColorResolve.

=cut


sub ColorResolve
{
    return gdImageColorResolve ( @_ );
} # End of ColorResolve()...


=head2 gdImageColorResolve

$image->gdImageColorResolve( $r, $g, $b )

=cut


sub gdImageColorResolve
{
    my $self = shift;
    return _gdImageColorResolve ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorResolve()...


=head2 ColorResolveAlpha

$image->ColorResolveAlpha( $r, $g, $b, $a )

Alias for gdImageColorResolveAlpha.

=cut


sub ColorResolveAlpha
{
    return gdImageColorResolveAlpha ( @_ );
} # End of ColorResolveAlpha()...


=head2 gdImageColorResolveAlpha

$image->gdImageColorResolveAlpha( $r, $g, $b, $a )

=cut


sub gdImageColorResolveAlpha
{
    my $self = shift;
    return _gdImageColorResolveAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorResolveAlpha()...


=head2 ColorDeallocate

$image->ColorDeallocate( $color )

Alias for gdImageColorDeallocate.

=cut


sub ColorDeallocate
{
    return gdImageColorDeallocate ( @_ );
} # End of ColorDeallocate()...


=head2 gdImageColorDeallocate

$image->gdImageColorDeallocate( $color )

=cut


sub gdImageColorDeallocate
{
    my $self = shift;
    return _gdImageColorDeallocate ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorDeallocate()...


=head2 TrueColorToPalette

$image->TrueColorToPalette( $ditherFlag, $colorsWanted )

Alias for gdImageTrueColorToPalette.

=cut


sub TrueColorToPalette
{
    return gdImageTrueColorToPalette ( @_ );
} # End of TrueColorToPalette()...


=head2 gdImageTrueColorToPalette

$image->gdImageTrueColorToPalette( $ditherFlag, $colorsWanted )

=cut


sub gdImageTrueColorToPalette
{
    my $self = shift;
    return _gdImageTrueColorToPalette ( $self->{IMG_PTR}, @_ );
} # End of gdImageTrueColorToPalette()...


=head2 ColorTransparent

$image->ColorTransparent( $color )

Alias for gdImageColorTransparent.

=cut


sub ColorTransparent
{
    return gdImageColorTransparent ( @_ );
} # End of ColorTransparent()...


=head2 gdImageColorTransparent

$image->gdImageColorTransparent( $color )

=cut


sub gdImageColorTransparent
{
    my $self = shift;
    return _gdImageColorTransparent ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorTransparent()...


=head2 FilledArc

$image->FilledArc( $cx, $cy, $w, $h, $s, $e, $color, $style )

Alias for gdImageFilledArc.

=cut


sub FilledArc
{
    return gdImageFilledArc ( @_ );
} # End of FilledArc()...


=head2 gdImageFilledArc

$image->gdImageFilledArc( $cx, $cy, $w, $h, $s, $e, $color, $style )

=cut


sub gdImageFilledArc
{
    my $self = shift;
    return _gdImageFilledArc ( $self->{IMG_PTR}, @_ );
} # End of gdImageFilledArc()...


=head2 Arc

$image->Arc( $cx, $cy, $w, $h, $s, $e, $color )

Alias for gdImageArc.

=cut


sub Arc
{
    return gdImageArc ( @_ );
} # End of Arc()...


=head2 gdImageArc

$image->gdImageArc( $cx, $cy, $w, $h, $s, $e, $color )

=cut


sub gdImageArc
{
    my $self = shift;
    return _gdImageArc ( $self->{IMG_PTR}, @_ );
} # End of gdImageArc()...


=head2 FilledEllipse

$image->FilledEllipse( $cx, $cy, $w, $h, $color )

Alias for gdImageFilledEllipse.

=cut


sub FilledEllipse
{
    return gdImageFilledEllipse ( @_ );
} # End of FilledEllipse()...


=head2 gdImageFilledEllipse

$image->gdImageFilledEllipse( $cx, $cy, $w, $h, $color )

=cut


sub gdImageFilledEllipse
{
    my $self = shift;
    return _gdImageFilledEllipse ( $self->{IMG_PTR}, @_ );
} # End of gdImageFilledEllipse()...


=head2 FillToBorder

$image->FillToBorder( $x, $y, $border, $color )

Alias for gdImageFillToBorder.

=cut


sub FillToBorder
{
    return gdImageFillToBorder ( @_ );
} # End of FillToBorder()...


=head2 gdImageFillToBorder

$image->gdImageFillToBorder( $x, $y, $border, $color )

=cut


sub gdImageFillToBorder
{
    my $self = shift;
    return _gdImageFillToBorder ( $self->{IMG_PTR}, @_ );
} # End of gdImageFillToBorder()...


=head2 Fill

$image->Fill( $x, $y, $color )

Alias for gdImageFill.

=cut


sub Fill
{
    return gdImageFill ( @_ );
} # End of Fill()...


=head2 gdImageFill

$image->gdImageFill( $x, $y, $color )

=cut


sub gdImageFill
{
    my $self = shift;
    return _gdImageFill ( $self->{IMG_PTR}, @_ );
} # End of gdImageFill()...


=head2 CopyRotated

$image->CopyRotated( $dstX, $dstY, $srcX, $srcY, $srcWidth, $srcHeight, $angle )

Alias for gdImageCopyRotated.

=cut


sub CopyRotated
{
    return gdImageCopyRotated ( @_ );
} # End of CopyRotated()...


=head2 gdImageCopyRotated

$image->gdImageCopyRotated( $dstX, $dstY, $srcX, $srcY, $srcWidth, $srcHeight, $angle )

=cut


sub gdImageCopyRotated
{
    my $self = shift;
    return _gdImageCopyRotated ( $self->{IMG_PTR}, @_ );
} # End of gdImageCopyRotated()...


=head2 SetBrush

$image->SetBrush(  )

Alias for gdImageSetBrush.

=cut


sub SetBrush
{
    return gdImageSetBrush ( @_ );
} # End of SetBrush()...


=head2 gdImageSetBrush

$image->gdImageSetBrush(  )

=cut


sub gdImageSetBrush
{
    my $self = shift;
    return _gdImageSetBrush ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetBrush()...


=head2 SetTile

$image->SetTile(  )

Alias for gdImageSetTile.

=cut


sub SetTile
{
    return gdImageSetTile ( @_ );
} # End of SetTile()...


=head2 gdImageSetTile

$image->gdImageSetTile(  )

=cut


sub gdImageSetTile
{
    my $self = shift;
    return _gdImageSetTile ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetTile()...


=head2 SetAntiAliased

$image->SetAntiAliased( $c )

Alias for gdImageSetAntiAliased.

=cut


sub SetAntiAliased
{
    return gdImageSetAntiAliased ( @_ );
} # End of SetAntiAliased()...


=head2 gdImageSetAntiAliased

$image->gdImageSetAntiAliased( $c )

=cut


sub gdImageSetAntiAliased
{
    my $self = shift;
    return _gdImageSetAntiAliased ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetAntiAliased()...


=head2 SetAntiAliasedDontBlend

$image->SetAntiAliasedDontBlend( $c, $dont_blend )

Alias for gdImageSetAntiAliasedDontBlend.

=cut


sub SetAntiAliasedDontBlend
{
    return gdImageSetAntiAliasedDontBlend ( @_ );
} # End of SetAntiAliasedDontBlend()...


=head2 gdImageSetAntiAliasedDontBlend

$image->gdImageSetAntiAliasedDontBlend( $c, $dont_blend )

=cut


sub gdImageSetAntiAliasedDontBlend
{
    my $self = shift;
    return _gdImageSetAntiAliasedDontBlend ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetAntiAliasedDontBlend()...


=head2 SetStyle

$image->SetStyle( $style, $noOfPixels )

Alias for gdImageSetStyle.

=cut


sub SetStyle
{
    return gdImageSetStyle ( @_ );
} # End of SetStyle()...


=head2 gdImageSetStyle

$image->gdImageSetStyle( $style, $noOfPixels )

=cut


sub gdImageSetStyle
{
    my $self = shift;
    return _gdImageSetStyle ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetStyle()...


=head2 SetThickness

$image->SetThickness( $thickness )

Alias for gdImageSetThickness.

=cut


sub SetThickness
{
    return gdImageSetThickness ( @_ );
} # End of SetThickness()...


=head2 gdImageSetThickness

$image->gdImageSetThickness( $thickness )

=cut


sub gdImageSetThickness
{
    my $self = shift;
    return _gdImageSetThickness ( $self->{IMG_PTR}, @_ );
} # End of gdImageSetThickness()...


=head2 Interlace

$image->Interlace( $interlaceArg )

Alias for gdImageInterlace.

=cut


sub Interlace
{
    return gdImageInterlace ( @_ );
} # End of Interlace()...


=head2 gdImageInterlace

$image->gdImageInterlace( $interlaceArg )

=cut


sub gdImageInterlace
{
    my $self = shift;
    return _gdImageInterlace ( $self->{IMG_PTR}, @_ );
} # End of gdImageInterlace()...


=head2 AlphaBlending

$image->AlphaBlending( $alphaBlendingArg )

Alias for gdImageAlphaBlending.

=cut


sub AlphaBlending
{
    return gdImageAlphaBlending ( @_ );
} # End of AlphaBlending()...


=head2 gdImageAlphaBlending

$image->gdImageAlphaBlending( $alphaBlendingArg )

=cut


sub gdImageAlphaBlending
{
    my $self = shift;
    return _gdImageAlphaBlending ( $self->{IMG_PTR}, @_ );
} # End of gdImageAlphaBlending()...


=head2 SaveAlpha

$image->SaveAlpha( $saveAlphaArg )

Alias for gdImageSaveAlpha.

=cut


sub SaveAlpha
{
    return gdImageSaveAlpha ( @_ );
} # End of SaveAlpha()...


=head2 gdImageSaveAlpha

$image->gdImageSaveAlpha( $saveAlphaArg )

=cut


sub gdImageSaveAlpha
{
    my $self = shift;
    return _gdImageSaveAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageSaveAlpha()...


=head2 TrueColor

$image->TrueColor(  )

Alias for gdImageTrueColor.

=cut


sub TrueColor
{
    return gdImageTrueColor ( @_ );
} # End of TrueColor()...


=head2 gdImageTrueColor

$image->gdImageTrueColor(  )

=cut


sub gdImageTrueColor
{
    my $self = shift;
    return _gdImageTrueColor ( $self->{IMG_PTR}, @_ );
} # End of gdImageTrueColor()...


=head2 ColorsTotal

$image->ColorsTotal(  )

Alias for gdImageColorsTotal.

=cut


sub ColorsTotal
{
    return gdImageColorsTotal ( @_ );
} # End of ColorsTotal()...


=head2 gdImageColorsTotal

$image->gdImageColorsTotal(  )

=cut


sub gdImageColorsTotal
{
    my $self = shift;
    return _gdImageColorsTotal ( $self->{IMG_PTR}, @_ );
} # End of gdImageColorsTotal()...


=head2 Red

$image->Red( $c )

Alias for gdImageRed.

=cut


sub Red
{
    return gdImageRed ( @_ );
} # End of Red()...


=head2 gdImageRed

$image->gdImageRed( $c )

=cut


sub gdImageRed
{
    my $self = shift;
    return _gdImageRed ( $self->{IMG_PTR}, @_ );
} # End of gdImageRed()...


=head2 Green

$image->Green( $c )

Alias for gdImageGreen.

=cut


sub Green
{
    return gdImageGreen ( @_ );
} # End of Green()...


=head2 gdImageGreen

$image->gdImageGreen( $c )

=cut


sub gdImageGreen
{
    my $self = shift;
    return _gdImageGreen ( $self->{IMG_PTR}, @_ );
} # End of gdImageGreen()...


=head2 Blue

$image->Blue( $c )

Alias for gdImageBlue.

=cut


sub Blue
{
    return gdImageBlue ( @_ );
} # End of Blue()...


=head2 gdImageBlue

$image->gdImageBlue( $c )

=cut


sub gdImageBlue
{
    my $self = shift;
    return _gdImageBlue ( $self->{IMG_PTR}, @_ );
} # End of gdImageBlue()...


=head2 Alpha

$image->Alpha( $c )

Alias for gdImageAlpha.

=cut


sub Alpha
{
    return gdImageAlpha ( @_ );
} # End of Alpha()...


=head2 gdImageAlpha

$image->gdImageAlpha( $c )

=cut


sub gdImageAlpha
{
    my $self = shift;
    return _gdImageAlpha ( $self->{IMG_PTR}, @_ );
} # End of gdImageAlpha()...


=head2 GetTransparent

$image->GetTransparent(  )

Alias for gdImageGetTransparent.

=cut


sub GetTransparent
{
    return gdImageGetTransparent ( @_ );
} # End of GetTransparent()...


=head2 gdImageGetTransparent

$image->gdImageGetTransparent(  )

=cut


sub gdImageGetTransparent
{
    my $self = shift;
    return _gdImageGetTransparent ( $self->{IMG_PTR}, @_ );
} # End of gdImageGetTransparent()...


=head2 GetInterlaced

$image->GetInterlaced(  )

Alias for gdImageGetInterlaced.

=cut


sub GetInterlaced
{
    return gdImageGetInterlaced ( @_ );
} # End of GetInterlaced()...


=head2 gdImageGetInterlaced

$image->gdImageGetInterlaced(  )

=cut


sub gdImageGetInterlaced
{
    my $self = shift;
    return _gdImageGetInterlaced ( $self->{IMG_PTR}, @_ );
} # End of gdImageGetInterlaced()...


=head2 SX

$image->SX(  )

Alias for gdImageSX.

=cut


sub SX
{
    return gdImageSX ( @_ );
} # End of SX()...


=head2 gdImageSX

$image->gdImageSX(  )

=cut


sub gdImageSX
{
    my $self = shift;
    return _gdImageSX ( $self->{IMG_PTR}, @_ );
} # End of gdImageSX()...


=head2 SY

$image->SY(  )

Alias for gdImageSY.

=cut


sub SY
{
    return gdImageSY ( @_ );
} # End of SY()...


=head2 gdImageSY

$image->gdImageSY(  )

=cut


sub gdImageSY
{
    my $self = shift;
    return _gdImageSY ( $self->{IMG_PTR}, @_ );
} # End of gdImageSY()...


=head2 ColorAllocates

$image->ColorAllocates( $r(pdl), $g(pdl), $b(pdl) )

Alias for gdImageColorAllocates.

=cut


sub ColorAllocates
{
    return gdImageColorAllocates ( @_ );
} # End of ColorAllocates()...


=head2 gdImageColorAllocates

$image->gdImageColorAllocates( $r(pdl), $g(pdl), $b(pdl) )

=cut


sub gdImageColorAllocates
{
    my $self = shift;
    return _gdImageColorAllocates ( @_, $self->{IMG_PTR} );
} # End of gdImageColorAllocates()...


=head2 ColorAllocateAlphas

$image->ColorAllocateAlphas( $r(pdl), $g(pdl), $b(pdl), $a(pdl) )

Alias for gdImageColorAllocateAlphas.

=cut


sub ColorAllocateAlphas
{
    return gdImageColorAllocateAlphas ( @_ );
} # End of ColorAllocateAlphas()...


=head2 gdImageColorAllocateAlphas

$image->gdImageColorAllocateAlphas( $r(pdl), $g(pdl), $b(pdl), $a(pdl) )

=cut


sub gdImageColorAllocateAlphas
{
    my $self = shift;
    return _gdImageColorAllocateAlphas ( @_, $self->{IMG_PTR} );
} # End of gdImageColorAllocateAlphas()...


=head2 SetPixels

$image->SetPixels( $x(pdl), $y(pdl), $color(pdl) )

Alias for gdImageSetPixels.

=cut


sub SetPixels
{
    return gdImageSetPixels ( @_ );
} # End of SetPixels()...


=head2 gdImageSetPixels

$image->gdImageSetPixels( $x(pdl), $y(pdl), $color(pdl) )

=cut


sub gdImageSetPixels
{
    my $self = shift;
    return _gdImageSetPixels ( @_, $self->{IMG_PTR} );
} # End of gdImageSetPixels()...


=head2 Lines

$image->Lines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

Alias for gdImageLines.

=cut


sub Lines
{
    return gdImageLines ( @_ );
} # End of Lines()...


=head2 gdImageLines

$image->gdImageLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

=cut


sub gdImageLines
{
    my $self = shift;
    return _gdImageLines ( @_, $self->{IMG_PTR} );
} # End of gdImageLines()...


=head2 DashedLines

$image->DashedLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

Alias for gdImageDashedLines.

=cut


sub DashedLines
{
    return gdImageDashedLines ( @_ );
} # End of DashedLines()...


=head2 gdImageDashedLines

$image->gdImageDashedLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

=cut


sub gdImageDashedLines
{
    my $self = shift;
    return _gdImageDashedLines ( @_, $self->{IMG_PTR} );
} # End of gdImageDashedLines()...


=head2 Rectangles

$image->Rectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

Alias for gdImageRectangles.

=cut


sub Rectangles
{
    return gdImageRectangles ( @_ );
} # End of Rectangles()...


=head2 gdImageRectangles

$image->gdImageRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

=cut


sub gdImageRectangles
{
    my $self = shift;
    return _gdImageRectangles ( @_, $self->{IMG_PTR} );
} # End of gdImageRectangles()...


=head2 FilledRectangles

$image->FilledRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

Alias for gdImageFilledRectangles.

=cut


sub FilledRectangles
{
    return gdImageFilledRectangles ( @_ );
} # End of FilledRectangles()...


=head2 gdImageFilledRectangles

$image->gdImageFilledRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )

=cut


sub gdImageFilledRectangles
{
    my $self = shift;
    return _gdImageFilledRectangles ( @_, $self->{IMG_PTR} );
} # End of gdImageFilledRectangles()...


=head2 FilledArcs

$image->FilledArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl), $style(pdl) )

Alias for gdImageFilledArcs.

=cut


sub FilledArcs
{
    return gdImageFilledArcs ( @_ );
} # End of FilledArcs()...


=head2 gdImageFilledArcs

$image->gdImageFilledArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl), $style(pdl) )

=cut


sub gdImageFilledArcs
{
    my $self = shift;
    return _gdImageFilledArcs ( @_, $self->{IMG_PTR} );
} # End of gdImageFilledArcs()...


=head2 Arcs

$image->Arcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl) )

Alias for gdImageArcs.

=cut


sub Arcs
{
    return gdImageArcs ( @_ );
} # End of Arcs()...


=head2 gdImageArcs

$image->gdImageArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl) )

=cut


sub gdImageArcs
{
    my $self = shift;
    return _gdImageArcs ( @_, $self->{IMG_PTR} );
} # End of gdImageArcs()...


=head2 FilledEllipses

$image->FilledEllipses( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $color(pdl) )

Alias for gdImageFilledEllipses.

=cut


sub FilledEllipses
{
    return gdImageFilledEllipses ( @_ );
} # End of FilledEllipses()...


=head2 gdImageFilledEllipses

$image->gdImageFilledEllipses( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $color(pdl) )

=cut


sub gdImageFilledEllipses
{
    my $self = shift;
    return _gdImageFilledEllipses ( @_, $self->{IMG_PTR} );
} # End of gdImageFilledEllipses()...


=head1 CLASS FUNCTIONS

=cut




=head2 gdImageCopy

gdImageCopy ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h )

=cut


sub gdImageCopy
{
    my $dst = shift;
    my $src = shift;
    my $dstX = shift;
    my $dstY = shift;
    my $srcX = shift;
    my $srcY = shift;
    my $w = shift;
    my $h = shift;

    return _gdImageCopy ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h );
} # End of gdImageCopy()...


=head2 gdImageCopyMerge

gdImageCopyMerge ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h, $pct )

=cut


sub gdImageCopyMerge
{
    my $dst = shift;
    my $src = shift;
    my $dstX = shift;
    my $dstY = shift;
    my $srcX = shift;
    my $srcY = shift;
    my $w = shift;
    my $h = shift;
    my $pct = shift;

    return _gdImageCopyMerge ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h, $pct );
} # End of gdImageCopyMerge()...


=head2 gdImageCopyMergeGray

gdImageCopyMergeGray ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h, $pct )

=cut


sub gdImageCopyMergeGray
{
    my $dst = shift;
    my $src = shift;
    my $dstX = shift;
    my $dstY = shift;
    my $srcX = shift;
    my $srcY = shift;
    my $w = shift;
    my $h = shift;
    my $pct = shift;

    return _gdImageCopyMergeGray ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h, $pct );
} # End of gdImageCopyMergeGray()...


=head2 gdImageCopyResized

gdImageCopyResized ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH )

=cut


sub gdImageCopyResized
{
    my $dst = shift;
    my $src = shift;
    my $dstX = shift;
    my $dstY = shift;
    my $srcX = shift;
    my $srcY = shift;
    my $dstW = shift;
    my $dstH = shift;
    my $srcW = shift;
    my $srcH = shift;

    return _gdImageCopyResized ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH );
} # End of gdImageCopyResized()...


=head2 gdImageCopyResampled

gdImageCopyResampled ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH )

=cut


sub gdImageCopyResampled
{
    my $dst = shift;
    my $src = shift;
    my $dstX = shift;
    my $dstY = shift;
    my $srcX = shift;
    my $srcY = shift;
    my $dstW = shift;
    my $dstH = shift;
    my $srcW = shift;
    my $srcH = shift;

    return _gdImageCopyResampled ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH );
} # End of gdImageCopyResampled()...


=head2 gdImageCompare

gdImageCompare ( $im1(PDL::IO::GD), $im2(PDL::IO::GD) )

=cut


sub gdImageCompare
{
    my $im1 = shift;
    my $im2 = shift;

    return _gdImageCompare ( $im1->{IMG_PTR}, $im2->{IMG_PTR} );
} # End of gdImageCompare()...


=head2 gdImagePaletteCopy

gdImagePaletteCopy ( $dst(PDL::IO::GD), $src(PDL::IO::GD) )

=cut


sub gdImagePaletteCopy
{
    my $dst = shift;
    my $src = shift;

    return _gdImagePaletteCopy ( $dst->{IMG_PTR}, $src->{IMG_PTR} );
} # End of gdImagePaletteCopy()...


=head2 StringTTF

$image->StringTTF( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )

Alias for gdImageStringTTF.

=cut


sub StringTTF
{
    return gdImageStringTTF ( @_ );
} # End of StringTTF()...


=head2 gdImageStringTTF

$image->gdImageStringTTF( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )

=cut


sub gdImageStringTTF
{
    my $self = shift;
    return _gdImageStringTTF ( $self->{IMG_PTR}, @_ );
} # End of gdImageStringTTF()...


=head2 StringFT

$image->StringFT( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )

Alias for gdImageStringFT.

=cut


sub StringFT
{
    return gdImageStringFT ( @_ );
} # End of StringFT()...


=head2 gdImageStringFT

$image->gdImageStringFT( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )

=cut


sub gdImageStringFT
{
    my $self = shift;
    return _gdImageStringFT ( $self->{IMG_PTR}, @_ );
} # End of gdImageStringFT()...



=head1 AUTHOR

Judd Taylor, Orbital Systems, Ltd.
judd dot t at orbitalsystems dot com

=cut





# Exit with OK status

1;

		   