"Fossies" - the Fresh Open Source Software Archive

Member "PDL-2.080/GENERATED/PDL/IO/GD.pm" (28 May 2022, 58190 Bytes) of package /linux/misc/PDL-2.080.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Perl source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "GD.pm" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 2.079_vs_2.080.

A hint: This file contains one or more very long lines, so maybe it is better readable using the pure text view mode that shows the contents as wrapped lines within the browser window.


    1 #
    2 # GENERATED WITH PDL::PP! Don't modify!
    3 #
    4 package PDL::IO::GD;
    5 
    6 our @EXPORT_OK = qw(write_png write_png_ex write_true_png write_true_png_ex write_png_best write_true_png_best recompress_png_best load_lut read_png read_true_png _read_true_png _read_png _gd_image_to_pdl_true _gd_image_to_pdl _pdl_to_gd_image_true _pdl_to_gd_image_lut read_png_lut _read_png_lut _gdImageColorAllocates _gdImageColorAllocateAlphas _gdImageSetPixels _gdImageLines _gdImageDashedLines _gdImageRectangles _gdImageFilledRectangles _gdImageFilledArcs _gdImageArcs _gdImageFilledEllipses  gdAlphaBlend   gdTrueColor   gdTrueColorAlpha   gdFree   gdFontGetLarge   gdFontGetSmall   gdFontGetMediumBold   gdFontGetGiant   gdFontGetTiny  );
    7 our %EXPORT_TAGS = (Func=>\@EXPORT_OK);
    8 
    9 use PDL::Core;
   10 use PDL::Exporter;
   11 use DynaLoader;
   12 
   13 
   14    
   15    our @ISA = ( 'PDL::Exporter','DynaLoader' );
   16    push @PDL::Core::PP, __PACKAGE__;
   17    bootstrap PDL::IO::GD ;
   18 
   19 
   20 
   21 
   22 
   23 
   24 #line 22 "GD.pd"
   25 
   26 use strict;
   27 use warnings;
   28 
   29 =head1 NAME
   30 
   31 PDL::IO::GD - Interface to the GD image library.
   32 
   33 =head1 SYNOPSIS
   34 
   35  my $pdl = sequence(byte, 30, 30);
   36  write_png($pdl, load_lut($lutfile), "test.png");
   37 
   38  write_true_png(sequence(100, 100, 3), "test_true.png");
   39 
   40  my $image = read_png("test.png");
   41 
   42  my $image = read_true_png("test_true_read.png");
   43  write_true_png($image, "test_true_read.out.png");
   44 
   45  my $lut = read_png_lut("test.png");
   46 
   47  $pdl = sequence(byte, 30, 30);
   48  write_png_ex($pdl, load_lut($lutfile), "test_nocomp.png", 0);
   49  write_png_ex($pdl, load_lut($lutfile), "test_bestcomp1.png", 9);
   50  write_png_best($pdl, load_lut($lutfile), "test_bestcomp2.png");
   51 
   52  $pdl = sequence(100, 100, 3);
   53  write_true_png_ex($pdl, "test_true_nocomp.png", 0);
   54  write_true_png_ex($pdl, "test_true_bestcomp1.png", 9);
   55  write_true_png_best($pdl, "test_true_bestcomp2.png");
   56 
   57  recompress_png_best("test_recomp_best.png");
   58 
   59 =head1 DESCRIPTION
   60 
   61 This is the "General Interface" for the PDL::IO::GD library, and is actually several
   62 years old at this point (read: stable). If you're feeling frisky, try the new OO 
   63 interface described below.
   64 
   65 The general version just provides several image IO utility functions you can use with
   66 ndarray variables. It's deceptively useful, however.
   67 
   68 =cut
   69 #line 70 "GD.pm"
   70 
   71 
   72 
   73 
   74 
   75 
   76 =head1 FUNCTIONS
   77 
   78 =cut
   79 
   80 
   81 
   82 
   83 #line 948 "../../blib/lib/PDL/PP.pm"
   84 
   85 
   86 
   87 =head2 write_png
   88 
   89 =for sig
   90 
   91   Signature: (byte img(x,y); byte lut(i,j); char* filename)
   92 
   93 Writes a 2-d PDL variable out to a PNG file, using the supplied color look-up-table ndarray
   94 (hereafter referred to as a LUT).
   95 
   96 The LUT contains a line for each value 0-255 with a corresponding R, G, and B value.
   97 
   98 
   99 =for bad
  100 
  101 write_png does not process bad values.
  102 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  103 
  104 
  105 =cut
  106 #line 107 "GD.pm"
  107 
  108 
  109 
  110 #line 950 "../../blib/lib/PDL/PP.pm"
  111 
  112 *write_png = \&PDL::write_png;
  113 #line 114 "GD.pm"
  114 
  115 
  116 
  117 #line 948 "../../blib/lib/PDL/PP.pm"
  118 
  119 
  120 
  121 =head2 write_png_ex
  122 
  123 =for sig
  124 
  125   Signature: (img(x,y); lut(i,j); char* filename; int level)
  126 
  127 Same as write_png(), except you can specify the compression level (0-9) as the last argument.
  128 
  129 
  130 =for bad
  131 
  132 write_png_ex does not process bad values.
  133 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  134 
  135 
  136 =cut
  137 #line 138 "GD.pm"
  138 
  139 
  140 
  141 #line 950 "../../blib/lib/PDL/PP.pm"
  142 
  143 *write_png_ex = \&PDL::write_png_ex;
  144 #line 145 "GD.pm"
  145 
  146 
  147 
  148 #line 948 "../../blib/lib/PDL/PP.pm"
  149 
  150 
  151 
  152 =head2 write_true_png
  153 
  154 =for sig
  155 
  156   Signature: (img(x,y,z); char* filename)
  157 
  158 Writes an (x, y, z(3)) PDL variable out to a PNG file, using a true color format.
  159 
  160 This means a larger file on disk, but can contain more than 256 colors.
  161 
  162 
  163 =for bad
  164 
  165 write_true_png does not process bad values.
  166 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  167 
  168 
  169 =cut
  170 #line 171 "GD.pm"
  171 
  172 
  173 
  174 #line 950 "../../blib/lib/PDL/PP.pm"
  175 
  176 *write_true_png = \&PDL::write_true_png;
  177 #line 178 "GD.pm"
  178 
  179 
  180 
  181 #line 948 "../../blib/lib/PDL/PP.pm"
  182 
  183 
  184 
  185 =head2 write_true_png_ex
  186 
  187 =for sig
  188 
  189   Signature: (img(x,y,z); char* filename; int level)
  190 
  191 Same as write_true_png(), except you can specify the compression level (0-9) as the last argument.
  192 
  193 
  194 =for bad
  195 
  196 write_true_png_ex does not process bad values.
  197 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  198 
  199 
  200 =cut
  201 #line 202 "GD.pm"
  202 
  203 
  204 
  205 #line 950 "../../blib/lib/PDL/PP.pm"
  206 
  207 *write_true_png_ex = \&PDL::write_true_png_ex;
  208 #line 209 "GD.pm"
  209 
  210 
  211 
  212 #line 315 "GD.pd"
  213 
  214 
  215 =head2 write_png_best
  216 
  217 Like write_png(), but it assumes the best PNG compression (9).
  218 
  219 =for example
  220 
  221   write_png_best( $img(ndarray), $lut(ndarray), $filename )
  222 
  223 =cut
  224 
  225 
  226 sub write_png_best
  227 {
  228     my $img = shift;
  229     my $lut = shift;
  230     my $filename = shift;
  231     return write_png_ex( $img, $lut, $filename, 9 );
  232 } # End of write_png_best()...
  233 
  234 =head2 write_true_png_best
  235 
  236 Like write_true_png(), but it assumes the best PNG compression (9).
  237 
  238 =for example
  239 
  240   write_true_png_best( $img(ndarray), $filename )
  241 
  242 =cut
  243 
  244 
  245 sub write_true_png_best
  246 {
  247     my $img = shift;
  248     my $filename = shift;
  249     return write_true_png_ex( $img, $filename, 9 );
  250 } # End of write_true_png_best()...
  251 #line 252 "GD.pm"
  252 
  253 
  254 
  255 #line 361 "GD.pd"
  256 #line 257 "GD.pm"
  257 
  258 
  259 
  260 #line 389 "GD.pd"
  261 
  262 
  263 =head2 load_lut( $filename )
  264 
  265 Loads a color look up table from an ASCII file. returns an ndarray
  266 
  267 =cut
  268 
  269 
  270 sub load_lut
  271 {
  272     return xchg(byte(cat(rcols(shift))), 0, 1);
  273 } # end of load_lut()...
  274 
  275 =head2 read_png( $filename )
  276 
  277 Reads a (palette) PNG image into a (new) PDL variable.
  278 
  279 =cut
  280 
  281 
  282 sub read_png
  283 {
  284     my $filename = shift;
  285 
  286     # Get the image dims...
  287     my $x = _get_png_xs($filename);
  288     my $y = _get_png_ys($filename);
  289     #print "\$x=$x\t\$y=$y\n";
  290 
  291     my $temp = zeroes(long, $x, $y);
  292     _read_png($temp, $filename);
  293     return byte($temp);
  294 } # End of read_png()...
  295 
  296 =head2 read_png_true( $filename )
  297 
  298 Reads a true color PNG image into a (new) PDL variable.
  299 
  300 =cut
  301 
  302 
  303 sub read_true_png
  304 {
  305     my $filename = shift;
  306 
  307     # Get the image dims...
  308     my $x = _get_png_xs($filename);
  309     my $y = _get_png_ys($filename);
  310     #print "\$x=$x\t\$y=$y\n";
  311 
  312 
  313     my $temp = zeroes(long, $x, $y, 3);
  314     _read_true_png($temp, $filename);
  315     return byte($temp);
  316 } # End of read_png()...
  317 #line 318 "GD.pm"
  318 
  319 
  320 
  321 #line 950 "../../blib/lib/PDL/PP.pm"
  322 
  323 *_read_true_png = \&PDL::_read_true_png;
  324 #line 325 "GD.pm"
  325 
  326 
  327 
  328 #line 950 "../../blib/lib/PDL/PP.pm"
  329 
  330 *_read_png = \&PDL::_read_png;
  331 #line 332 "GD.pm"
  332 
  333 
  334 
  335 #line 950 "../../blib/lib/PDL/PP.pm"
  336 
  337 *_gd_image_to_pdl_true = \&PDL::_gd_image_to_pdl_true;
  338 #line 339 "GD.pm"
  339 
  340 
  341 
  342 #line 950 "../../blib/lib/PDL/PP.pm"
  343 
  344 *_gd_image_to_pdl = \&PDL::_gd_image_to_pdl;
  345 #line 346 "GD.pm"
  346 
  347 
  348 
  349 #line 950 "../../blib/lib/PDL/PP.pm"
  350 
  351 *_pdl_to_gd_image_true = \&PDL::_pdl_to_gd_image_true;
  352 #line 353 "GD.pm"
  353 
  354 
  355 
  356 #line 950 "../../blib/lib/PDL/PP.pm"
  357 
  358 *_pdl_to_gd_image_lut = \&PDL::_pdl_to_gd_image_lut;
  359 #line 360 "GD.pm"
  360 
  361 
  362 
  363 #line 717 "GD.pd"
  364 
  365 
  366 =head2 read_png_lut( $filename )
  367 
  368 Reads a color LUT from an already-existing palette PNG file.
  369 
  370 =cut
  371 
  372 
  373 sub read_png_lut
  374 {
  375     my $filename = shift;
  376     my $lut = zeroes(byte, 3, 256);
  377     _read_png_lut($lut, $filename);
  378     return $lut;
  379 } # End of read_png_lut()...
  380 #line 381 "GD.pm"
  381 
  382 
  383 
  384 #line 950 "../../blib/lib/PDL/PP.pm"
  385 
  386 *_read_png_lut = \&PDL::_read_png_lut;
  387 #line 388 "GD.pm"
  388 
  389 
  390 
  391 #line 950 "../../blib/lib/PDL/PP.pm"
  392 
  393 *_gdImageColorAllocates = \&PDL::_gdImageColorAllocates;
  394 #line 395 "GD.pm"
  395 
  396 
  397 
  398 #line 950 "../../blib/lib/PDL/PP.pm"
  399 
  400 *_gdImageColorAllocateAlphas = \&PDL::_gdImageColorAllocateAlphas;
  401 #line 402 "GD.pm"
  402 
  403 
  404 
  405 #line 950 "../../blib/lib/PDL/PP.pm"
  406 
  407 *_gdImageSetPixels = \&PDL::_gdImageSetPixels;
  408 #line 409 "GD.pm"
  409 
  410 
  411 
  412 #line 950 "../../blib/lib/PDL/PP.pm"
  413 
  414 *_gdImageLines = \&PDL::_gdImageLines;
  415 #line 416 "GD.pm"
  416 
  417 
  418 
  419 #line 950 "../../blib/lib/PDL/PP.pm"
  420 
  421 *_gdImageDashedLines = \&PDL::_gdImageDashedLines;
  422 #line 423 "GD.pm"
  423 
  424 
  425 
  426 #line 950 "../../blib/lib/PDL/PP.pm"
  427 
  428 *_gdImageRectangles = \&PDL::_gdImageRectangles;
  429 #line 430 "GD.pm"
  430 
  431 
  432 
  433 #line 950 "../../blib/lib/PDL/PP.pm"
  434 
  435 *_gdImageFilledRectangles = \&PDL::_gdImageFilledRectangles;
  436 #line 437 "GD.pm"
  437 
  438 
  439 
  440 #line 950 "../../blib/lib/PDL/PP.pm"
  441 
  442 *_gdImageFilledArcs = \&PDL::_gdImageFilledArcs;
  443 #line 444 "GD.pm"
  444 
  445 
  446 
  447 #line 950 "../../blib/lib/PDL/PP.pm"
  448 
  449 *_gdImageArcs = \&PDL::_gdImageArcs;
  450 #line 451 "GD.pm"
  451 
  452 
  453 
  454 #line 950 "../../blib/lib/PDL/PP.pm"
  455 
  456 *_gdImageFilledEllipses = \&PDL::_gdImageFilledEllipses;
  457 #line 458 "GD.pm"
  458 
  459 
  460 
  461 
  462 
  463 #line 804 "GD.pd"
  464 
  465 
  466 =head1 OO INTERFACE
  467  
  468 Object Oriented interface to the GD image library.
  469 
  470 =head1 SYNOPSIS
  471 
  472  # Open an existing file:
  473  # 
  474  my $gd = PDL::IO::GD->new( { filename => "test.png" } );
  475  
  476  # Query the x and y sizes:
  477  my $x = $gd->SX();
  478  my $y = $gd->SY();
  479 
  480  # Grab the PDL of the data:
  481  my $pdl = $gd->to_pdl();
  482 
  483  # Kill this thing:
  484  $gd->DESTROY();
  485 
  486  # Create a new object:
  487  # 
  488  my $im = PDL::IO::GD->new( { x => 300, y => 300 } );
  489 
  490  # Allocate some colors:
  491  #
  492  my $black = $im->ColorAllocate( 0, 0, 0 );
  493  my $red = $im->ColorAllocate( 255, 0, 0 );
  494  my $green = $im->ColorAllocate( 0, 255, 0 );
  495  my $blue = $im->ColorAllocate( 0, 0, 255 );
  496 
  497  # Draw a rectangle:
  498  $im->Rectangle( 10, 10, 290, 290, $red );
  499 
  500  # Add some text:
  501  $im->String( gdFontGetLarge(), 20, 20, "Test Large Font!", $green );
  502 
  503  # Write the output file:
  504  $im->write_Png( "test2.png" );
  505 
  506 =head1 DESCRIPTION
  507 
  508 This is the Object-Oriented interface from PDL to the GD image library.
  509 
  510 See L<http://www.boutell.com/gd/> for more information on the GD library and how it works.
  511 
  512 =head2 IMPLEMENTATION NOTES
  513 
  514 Surprisingly enough, this interface has nothing to do with the other Perl->GD interface module, 
  515 aka 'GD' (as in 'use GD;'). This is done from scratch over the years.
  516 
  517 Requires at least version 2.0.22 of the GD library, but it's only been thoroughly tested with
  518 gd-2.0.33, so it would be best to use that. The 2.0.22 requirement has to do with a change in
  519 GD's font handling functions, so if you don't use those, then don't worry about it.
  520 
  521 I should also add, the statement about "thoroughly tested" above is mostly a joke. This OO 
  522 interface is very young, and it has I<barely> been tested at all, so if something 
  523 breaks, email me and I'll get it fixed ASAP (for me).
  524 
  525 Functions that manipulate and query the image objects generally have a 'gdImage' prefix on the
  526 function names (ex: gdImageString()). I've created aliases here for all of those member 
  527 functions so you don't have to keep typing 'gdImage' in your code, but the long version are in 
  528 there as well.
  529 
  530 =head1 METHODS
  531 
  532 =cut
  533 
  534 use PDL;
  535 use PDL::Slices;
  536 use PDL::IO::Misc;
  537 
  538 #
  539 # Some helper functions:
  540 #
  541 sub _pkg_name
  542     { return "PDL::IO::GD::" . (shift) . "()"; }
  543 
  544 # ID a file type from it's filename:
  545 sub _id_image_file
  546 {
  547     my $filename = shift;
  548     
  549     return 'png'
  550         if( $filename =~ /\.png$/ );
  551     
  552     return 'jpg'
  553         if( $filename =~ /\.jpe?g$/ );
  554     
  555     return 'wbmp'
  556         if( $filename =~ /\.w?bmp$/ );
  557     
  558     return 'gd'
  559         if( $filename =~ /\.gd$/ );
  560     
  561     return 'gd2'
  562         if( $filename =~ /\.gd2$/ );
  563     
  564     return 'gif'
  565         if( $filename =~ /\.gif$/ );
  566     
  567     return 'xbm'
  568         if( $filename =~ /\.xbm$/ );
  569         
  570     return undef;
  571 } # End of _id_image_file()...
  572 
  573 # Load a new file up (don't read it yet):
  574 sub _img_ptr_from_file
  575 {
  576     my $filename = shift;
  577     my $type = shift;
  578     
  579     return _gdImageCreateFromPng( $filename )
  580         if( $type eq 'png' );
  581     
  582     return _gdImageCreateFromJpeg( $filename )
  583         if( $type eq 'jpg' );
  584         
  585     return _gdImageCreateFromWBMP( $filename )
  586         if( $type eq 'wbmp' );
  587         
  588     return _gdImageCreateFromGd( $filename )
  589         if( $type eq 'gd' );
  590     
  591     return _gdImageCreateFromGd2( $filename )
  592         if( $type eq 'gd2' );
  593     
  594     return _gdImageCreateFromGif( $filename )
  595         if( $type eq 'gif' );
  596             
  597     return _gdImageCreateFromXbm( $filename )
  598         if( $type eq 'xbm' );
  599     
  600     return undef;
  601 } # End of _img_ptr_from_file()...
  602 
  603 # ID a file type from it's "magic" header in the image data:
  604 sub _id_image_data 
  605 {
  606     my $data = shift;
  607     my $magic = substr($data,0,4);
  608     
  609     return 'png'
  610         if( $magic eq "\x89PNG" );
  611     
  612     return 'jpg'
  613         if( $magic eq "\377\330\377\340" );
  614     return 'jpg'
  615         if( $magic eq "\377\330\377\341" );
  616     return 'jpg'
  617         if( $magic eq "\377\330\377\356" );
  618         
  619     return 'gif'
  620         if( $magic eq "GIF8" );
  621     
  622     return 'gd2'
  623         if( $magic eq "gd2\000" );
  624         
  625     # Still need filters for WBMP and .gd!
  626     
  627     return undef;
  628 } # End of _id_image_data()...
  629 
  630 
  631 # Load a new data scalar up:
  632 sub _img_ptr_from_data
  633 {
  634     my $data = shift;
  635     my $type = shift;
  636     
  637     return _gdImageCreateFromPngPtr( $data )
  638         if( $type eq 'png' );
  639     
  640     return _gdImageCreateFromJpegPtr( $data )
  641         if( $type eq 'jpg' );
  642         
  643     return _gdImageCreateFromWBMPPtr( $data )
  644         if( $type eq 'wbmp' );
  645         
  646     return _gdImageCreateFromGdPtr( $data )
  647         if( $type eq 'gd' );
  648     
  649     return _gdImageCreateFromGd2Ptr( $data )
  650         if( $type eq 'gd2' );
  651     
  652     return _gdImageCreateFromGifPtr( $data )
  653         if( $type eq 'gif' );
  654     
  655     return undef;
  656 } # End of _img_ptr_from_data()...
  657 
  658 
  659 =head2 new
  660 
  661 Creates a new PDL::IO::GD object.
  662 
  663 Accepts a hash describing how to create the object. Accepts a single hash ( with
  664 curly braces ), an inline hash (the same, but without the braces) or a single
  665 string interpreted as a filename. Thus the following are all equivalent:
  666 
  667  PDL::IO::GD->new( {filename => 'image.png'} );
  668  PDL::IO::GD->new( filename => 'image.png' );
  669  PDL::IO::GD->new( 'image.png' );
  670 
  671 If the hash has:
  672 
  673  pdl => $pdl_var (lut => $lut_ndarray)
  674     Then a new GD is created from that PDL variable.
  675 
  676  filename => $file
  677     Then a new GD is created from the image file.
  678     
  679  x => $num, y => $num
  680     Then a new GD is created as a palette image, with size x, y
  681     
  682  x => $num, y => $num, true_color => 1
  683     Then a new GD is created as a true color image, with size x, y
  684 
  685  data => $scalar (type => $typename)
  686     Then a new GD is created from the file data stored in $scalar. 
  687     If no type is given, then it will try to guess the type of the data, but 
  688         this will not work for WBMP and gd image types. For those types, you 
  689         _must_ specify the type of the data, or the operation will fail.
  690     Valid types are: 'jpg', 'png', 'gif', 'gd', 'gd2', 'wbmp'.
  691     
  692 Example:
  693  
  694  my $gd = PDL::IO::GD->new({ pdl => $pdl_var });
  695     
  696  my $gd = PDL::IO::GD->new({ pdl => $pdl_var, lut => $lut_ndarray });
  697  
  698  my $gd = PDL::IO::GD->new({ filename => "image.png" });
  699  
  700  my $gd = PDL::IO::GD->new({ x => 100, y => 100 });
  701  
  702  my $gd = PDL::IO::GD->new({ x => 100, y => 100, true_color => 1 });
  703  
  704  my $gd = PDL::IO::GD->new({ data => $imageData });
  705  
  706  my $gd = PDL::IO::GD->new({ data => $imageData, type => 'wbmp' });
  707 
  708 =cut
  709 
  710 sub new
  711 {
  712     my $proto = shift;
  713     my $class = ref($proto) || $proto;
  714     #my $self  = $class->SUPER::new( @_ );
  715     my $self = {};
  716     
  717     my $sub = _pkg_name( "new" );
  718     
  719     # Figure out our options:
  720 
  721     # I want a single hash. I handle several cases here
  722     my $options;
  723     if( @_ == 1 && ref $_[0] eq 'HASH' ) {
  724       # single hash argument. Just take it
  725       $options = shift;
  726     }
  727     elsif( @_ == 1 && ! ref $_[0] ) {
  728       # single scalar argument. Treat it as a filename by default
  729       my $filename = shift;
  730       $options = { filename => $filename };
  731     }
  732     else {
  733       # the only other acceptable option is an inline hash. This is valid if I
  734       # have an even number of arguments, and the even-indexed ones (the keys)
  735       # are scalars
  736       if( @_ % 2 == 0 ) {
  737         my @pairs = @_;
  738         my $Npairs = scalar(@pairs)/2;
  739 
  740         use List::Util 'none';
  741         if( none { ref $pairs[2*$_] } 0..$Npairs-1 ) {
  742           # treat the arguments as a hash
  743           $options = { @pairs }
  744         }
  745       }
  746     }
  747 
  748     if( !defined $options ) {
  749       die <<EOF;
  750 PDL::IO::GD::new couldn't parse its arguments.
  751 Expected a hash-ref or an inline hash or just a filename
  752 EOF
  753     }
  754 
  755 
  756     
  757     if( defined( $options->{pdl} ) )
  758     {   # Create it from a PDL variable:
  759         my $pdl = $options->{pdl};
  760         $pdl->make_physical();
  761         my $num_dims = scalar( $pdl->dims() );
  762         if( $num_dims == 2 )
  763         {
  764             if( defined( $options->{lut} ) )
  765             {
  766                 my $ptr = zeroes( longlong, 1 );
  767                 my $lut = $options->{lut};
  768                 _pdl_to_gd_image_lut( $pdl, $lut, $ptr );
  769 #       print STDERR "in new (with lut), setting IMG_PTR to " . $ptr->at(0) . "\n";
  770                 $self->{IMG_PTR} = $ptr->at(0);
  771                 $ptr = null;
  772                 die "$sub: _pdl_to_gd_image_lut() failed!\n"
  773                     if( $self->{IMG_PTR} == 0 );
  774             }
  775             else
  776             {
  777                 my $ptr = zeroes( longlong, 1 );
  778                 my $lut = sequence(byte, 255)->slice("*3,:");
  779                 _pdl_to_gd_image_lut( $pdl, $lut, $ptr );
  780 #       print STDERR "in new (no lut), setting IMG_PTR to " . $ptr->at(0) . "\n";
  781                 $self->{IMG_PTR} = $ptr->at(0);
  782                 $ptr = null;
  783                 die "$sub: _pdl_to_gd_image_lut() failed!\n"
  784                     if( $self->{IMG_PTR} == 0 );
  785             }
  786         }
  787         elsif( $num_dims == 3 )
  788         {
  789             my $ptr = zeroes( longlong, 1 );
  790             _pdl_to_gd_image_true( $pdl, $ptr );
  791 #       print STDERR "in new (ndims=3), setting IMG_PTR to " . $ptr->at(0) . "\n";
  792             $self->{IMG_PTR} = $ptr->at(0);
  793             $ptr = null;
  794             die "$sub: _pdl_to_gd_image_true() failed!\n"
  795                 if( $self->{IMG_PTR} == 0 );
  796         }
  797         else
  798         {
  799             die "Can't create a PDL::IO::GD from a PDL with bad dims!\n";
  800         }
  801     }
  802     elsif( exists( $options->{filename} ) )
  803     {   # Create it from a file:
  804 
  805         if( !defined $options->{filename} ) {
  806           die "PDL::IO::GD::new got an undefined filename. Giving up.\n";
  807         }
  808 
  809         # Figure out what type of file it is:
  810         $self->{input_type} = _id_image_file( $options->{filename} )
  811             or die "$sub: Can't determine image type of filename => \'$options->{filename}\'!\n";
  812         
  813         # Read in the file:
  814         $self->{IMG_PTR} = _img_ptr_from_file( $options->{filename}, $self->{input_type} )
  815             or die "$sub: Can't read in the input file!\n";
  816     }
  817     elsif( defined( $options->{x} ) && defined( $options->{y} ) )
  818     {   # Create an empty image:
  819         my $done = 0;
  820         if( defined( $options->{true_color} ) )
  821         {
  822             if( $options->{true_color} )
  823             {   # Create an empty true color image:
  824                 $self->{IMG_PTR} = _gdImageCreateTrueColor( $options->{x}, $options->{y} );
  825                 die "$sub: _gdImageCreateTrueColor() failed!\n"
  826                     if( $self->{IMG_PTR} == 0 );
  827                 $done = 1;
  828             }
  829         }
  830         unless( $done )
  831         {   # Create an empty palette image:
  832             $self->{IMG_PTR} = _gdImageCreatePalette( $options->{x}, $options->{y} );
  833             die "$sub: _gdImageCreatePalette() failed!\n"
  834                 if( $self->{IMG_PTR} == 0 );
  835         }
  836     }
  837     elsif( defined( $options->{data} ) )
  838     {   # Create an image from the given image data:
  839     
  840         # Figure out what type of file it is:
  841         if( defined( $options->{type} ) && 
  842             (      $options->{type} eq 'jpg'
  843                 || $options->{type} eq 'png'
  844                 || $options->{type} eq 'gif'
  845                 || $options->{type} eq 'wbmp'
  846                 || $options->{type} eq 'gd'
  847                 || $options->{type} eq 'gd2' ) )
  848         {
  849             $self->{input_type} = $options->{type};
  850         }
  851         else
  852         {
  853             $self->{input_type} = _id_image_data( $options->{data} )
  854                 or die "$sub: Can't determine image type given data!\n";
  855         }
  856         
  857         # Load the data:
  858         $self->{IMG_PTR} = _img_ptr_from_data( $options->{data}, $self->{input_type} )
  859             or die "$sub: Can't load the input image data!\n";
  860     }
  861     
  862     # Bless and return:
  863     #
  864     bless ($self, $class);    
  865     return $self;
  866 } # End of new()...
  867 
  868 =head2 to_pdl
  869 
  870 When you're done playing with your GDImage and want an ndarray back, use this function to return one.
  871 
  872 =cut
  873 
  874 
  875 sub to_pdl
  876 {
  877     my $self = shift;
  878 
  879     my $sub = _pkg_name( "to_pdl" );
  880     
  881     my $x = $self->gdImageSX();
  882     my $y = $self->gdImageSY();
  883     
  884     if( $self->gdImageTrueColor() )
  885     {
  886         my $pdl = zeroes(byte, $x, $y, 3);
  887         _gd_image_to_pdl_true( $pdl, $self->{IMG_PTR} );
  888         return $pdl;
  889     }
  890     
  891     my $pdl = zeroes(byte, $x, $y);
  892     _gd_image_to_pdl( $pdl, $self->{IMG_PTR} );
  893     return $pdl;
  894 } # End of to_pdl()...
  895 
  896 =head2 apply_lut( $lut(ndarray) )
  897 
  898 Does a $im->ColorAllocate() for and entire LUT ndarray at once.
  899 
  900 The LUT ndarray format is the same as for the general interface above.
  901 
  902 =cut
  903 
  904 
  905 sub apply_lut
  906 {
  907     my $self = shift;
  908     my $lut = shift;
  909     
  910     # Let the PDL broadcasting engine sort this out:
  911     $self->ColorAllocates( $lut->slice("(0),:"), $lut->slice("(1),:"), $lut->slice("(2),:") );
  912 } # End of apply_lut()...
  913 
  914 sub DESTROY
  915 {
  916     my $self = shift;
  917     my $sub = _pkg_name( "DESTROY" );
  918  
  919     #print STDERR sprintf("$sub: destroying gdImagePtr: 0x%p (%d) (%ld) (%lld)!\n", $self->{IMG_PTR}, $self->{IMG_PTR},$self->{IMG_PTR},$self->{IMG_PTR});
  920     
  921     if( defined( $self->{IMG_PTR} ) )
  922     {
  923         _gdImageDestroy( $self->{IMG_PTR} );
  924         delete( $self->{IMG_PTR} );
  925     }
  926 } # End of DESTROY()...
  927 
  928 =head2 WARNING:
  929 
  930 All of the docs below this point are auto-generated (not to mention the actual code), 
  931 so read with a grain of salt, and B<always> check the main GD documentation about how 
  932 that function works and what it does.
  933 
  934 =cut
  935 #line 936 "GD.pm"
  936 
  937 
  938 
  939 #line 1747 "GD.pd"
  940 
  941 =head2 write_Png
  942 
  943 $image->write_Png( $filename )
  944 
  945 =cut
  946 
  947 
  948 sub write_Png
  949 {
  950     my $self = shift;
  951     return _gdImagePng ( $self->{IMG_PTR}, @_ );
  952 } # End of write_Png()...
  953 #line 954 "GD.pm"
  954 
  955 
  956 
  957 #line 1747 "GD.pd"
  958 
  959 =head2 write_PngEx
  960 
  961 $image->write_PngEx( $filename, $level )
  962 
  963 =cut
  964 
  965 
  966 sub write_PngEx
  967 {
  968     my $self = shift;
  969     return _gdImagePngEx ( $self->{IMG_PTR}, @_ );
  970 } # End of write_PngEx()...
  971 #line 972 "GD.pm"
  972 
  973 
  974 
  975 #line 1747 "GD.pd"
  976 
  977 =head2 write_WBMP
  978 
  979 $image->write_WBMP( $fg, $filename )
  980 
  981 =cut
  982 
  983 
  984 sub write_WBMP
  985 {
  986     my $self = shift;
  987     return _gdImageWBMP ( $self->{IMG_PTR}, @_ );
  988 } # End of write_WBMP()...
  989 #line 990 "GD.pm"
  990 
  991 
  992 
  993 #line 1747 "GD.pd"
  994 
  995 =head2 write_Jpeg
  996 
  997 $image->write_Jpeg( $filename, $quality )
  998 
  999 =cut
 1000 
 1001 
 1002 sub write_Jpeg
 1003 {
 1004     my $self = shift;
 1005     return _gdImageJpeg ( $self->{IMG_PTR}, @_ );
 1006 } # End of write_Jpeg()...
 1007 #line 1008 "GD.pm"
 1008 
 1009 
 1010 
 1011 #line 1747 "GD.pd"
 1012 
 1013 =head2 write_Gd
 1014 
 1015 $image->write_Gd( $filename )
 1016 
 1017 =cut
 1018 
 1019 
 1020 sub write_Gd
 1021 {
 1022     my $self = shift;
 1023     return _gdImageGd ( $self->{IMG_PTR}, @_ );
 1024 } # End of write_Gd()...
 1025 #line 1026 "GD.pm"
 1026 
 1027 
 1028 
 1029 #line 1747 "GD.pd"
 1030 
 1031 =head2 write_Gd2
 1032 
 1033 $image->write_Gd2( $filename, $cs, $fmt )
 1034 
 1035 =cut
 1036 
 1037 
 1038 sub write_Gd2
 1039 {
 1040     my $self = shift;
 1041     return _gdImageGd2 ( $self->{IMG_PTR}, @_ );
 1042 } # End of write_Gd2()...
 1043 #line 1044 "GD.pm"
 1044 
 1045 
 1046 
 1047 #line 1747 "GD.pd"
 1048 
 1049 =head2 write_Gif
 1050 
 1051 $image->write_Gif( $filename )
 1052 
 1053 =cut
 1054 
 1055 
 1056 sub write_Gif
 1057 {
 1058     my $self = shift;
 1059     return _gdImageGif ( $self->{IMG_PTR}, @_ );
 1060 } # End of write_Gif()...
 1061 #line 1062 "GD.pm"
 1062 
 1063 
 1064 
 1065 #line 1859 "GD.pd"
 1066 
 1067 =head2 get_Png_data
 1068 
 1069 $image->get_Png_data(  )
 1070 
 1071 =cut
 1072 
 1073 
 1074 sub get_Png_data
 1075 {
 1076     my $self = shift;
 1077     return _gdImagePngPtr ( $self->{IMG_PTR}, @_ );
 1078 } # End of get_Png_data()...
 1079 #line 1080 "GD.pm"
 1080 
 1081 
 1082 
 1083 #line 1859 "GD.pd"
 1084 
 1085 =head2 get_PngEx_data
 1086 
 1087 $image->get_PngEx_data( $level )
 1088 
 1089 =cut
 1090 
 1091 
 1092 sub get_PngEx_data
 1093 {
 1094     my $self = shift;
 1095     return _gdImagePngPtrEx ( $self->{IMG_PTR}, @_ );
 1096 } # End of get_PngEx_data()...
 1097 #line 1098 "GD.pm"
 1098 
 1099 
 1100 
 1101 #line 1859 "GD.pd"
 1102 
 1103 =head2 get_WBMP_data
 1104 
 1105 $image->get_WBMP_data( $fg )
 1106 
 1107 =cut
 1108 
 1109 
 1110 sub get_WBMP_data
 1111 {
 1112     my $self = shift;
 1113     return _gdImageWBMPPtr ( $self->{IMG_PTR}, @_ );
 1114 } # End of get_WBMP_data()...
 1115 #line 1116 "GD.pm"
 1116 
 1117 
 1118 
 1119 #line 1859 "GD.pd"
 1120 
 1121 =head2 get_Jpeg_data
 1122 
 1123 $image->get_Jpeg_data( $quality )
 1124 
 1125 =cut
 1126 
 1127 
 1128 sub get_Jpeg_data
 1129 {
 1130     my $self = shift;
 1131     return _gdImageJpegPtr ( $self->{IMG_PTR}, @_ );
 1132 } # End of get_Jpeg_data()...
 1133 #line 1134 "GD.pm"
 1134 
 1135 
 1136 
 1137 #line 1859 "GD.pd"
 1138 
 1139 =head2 get_Gd_data
 1140 
 1141 $image->get_Gd_data(  )
 1142 
 1143 =cut
 1144 
 1145 
 1146 sub get_Gd_data
 1147 {
 1148     my $self = shift;
 1149     return _gdImageGdPtr ( $self->{IMG_PTR}, @_ );
 1150 } # End of get_Gd_data()...
 1151 #line 1152 "GD.pm"
 1152 
 1153 
 1154 
 1155 #line 1859 "GD.pd"
 1156 
 1157 =head2 get_Gd2_data
 1158 
 1159 $image->get_Gd2_data( $cs, $fmt )
 1160 
 1161 =cut
 1162 
 1163 
 1164 sub get_Gd2_data
 1165 {
 1166     my $self = shift;
 1167     return _gdImageGd2Ptr ( $self->{IMG_PTR}, @_ );
 1168 } # End of get_Gd2_data()...
 1169 #line 1170 "GD.pm"
 1170 
 1171 
 1172 
 1173 #line 1959 "GD.pd"
 1174 
 1175 =head2 SetPixel
 1176 
 1177 $image->SetPixel( $x, $y, $color )
 1178 
 1179 Alias for gdImageSetPixel.
 1180 
 1181 =cut
 1182 
 1183 
 1184 sub SetPixel
 1185 {
 1186     return gdImageSetPixel ( @_ );
 1187 } # End of SetPixel()...
 1188 
 1189 
 1190 =head2 gdImageSetPixel
 1191 
 1192 $image->gdImageSetPixel( $x, $y, $color )
 1193 
 1194 =cut
 1195 
 1196 
 1197 sub gdImageSetPixel
 1198 {
 1199     my $self = shift;
 1200     return _gdImageSetPixel ( $self->{IMG_PTR}, @_ );
 1201 } # End of gdImageSetPixel()...
 1202 #line 1203 "GD.pm"
 1203 
 1204 
 1205 
 1206 #line 1959 "GD.pd"
 1207 
 1208 =head2 GetPixel
 1209 
 1210 $image->GetPixel( $x, $y )
 1211 
 1212 Alias for gdImageGetPixel.
 1213 
 1214 =cut
 1215 
 1216 
 1217 sub GetPixel
 1218 {
 1219     return gdImageGetPixel ( @_ );
 1220 } # End of GetPixel()...
 1221 
 1222 
 1223 =head2 gdImageGetPixel
 1224 
 1225 $image->gdImageGetPixel( $x, $y )
 1226 
 1227 =cut
 1228 
 1229 
 1230 sub gdImageGetPixel
 1231 {
 1232     my $self = shift;
 1233     return _gdImageGetPixel ( $self->{IMG_PTR}, @_ );
 1234 } # End of gdImageGetPixel()...
 1235 #line 1236 "GD.pm"
 1236 
 1237 
 1238 
 1239 #line 1959 "GD.pd"
 1240 
 1241 =head2 AABlend
 1242 
 1243 $image->AABlend(  )
 1244 
 1245 Alias for gdImageAABlend.
 1246 
 1247 =cut
 1248 
 1249 
 1250 sub AABlend
 1251 {
 1252     return gdImageAABlend ( @_ );
 1253 } # End of AABlend()...
 1254 
 1255 
 1256 =head2 gdImageAABlend
 1257 
 1258 $image->gdImageAABlend(  )
 1259 
 1260 =cut
 1261 
 1262 
 1263 sub gdImageAABlend
 1264 {
 1265     my $self = shift;
 1266     return _gdImageAABlend ( $self->{IMG_PTR}, @_ );
 1267 } # End of gdImageAABlend()...
 1268 #line 1269 "GD.pm"
 1269 
 1270 
 1271 
 1272 #line 1959 "GD.pd"
 1273 
 1274 =head2 Line
 1275 
 1276 $image->Line( $x1, $y1, $x2, $y2, $color )
 1277 
 1278 Alias for gdImageLine.
 1279 
 1280 =cut
 1281 
 1282 
 1283 sub Line
 1284 {
 1285     return gdImageLine ( @_ );
 1286 } # End of Line()...
 1287 
 1288 
 1289 =head2 gdImageLine
 1290 
 1291 $image->gdImageLine( $x1, $y1, $x2, $y2, $color )
 1292 
 1293 =cut
 1294 
 1295 
 1296 sub gdImageLine
 1297 {
 1298     my $self = shift;
 1299     return _gdImageLine ( $self->{IMG_PTR}, @_ );
 1300 } # End of gdImageLine()...
 1301 #line 1302 "GD.pm"
 1302 
 1303 
 1304 
 1305 #line 1959 "GD.pd"
 1306 
 1307 =head2 DashedLine
 1308 
 1309 $image->DashedLine( $x1, $y1, $x2, $y2, $color )
 1310 
 1311 Alias for gdImageDashedLine.
 1312 
 1313 =cut
 1314 
 1315 
 1316 sub DashedLine
 1317 {
 1318     return gdImageDashedLine ( @_ );
 1319 } # End of DashedLine()...
 1320 
 1321 
 1322 =head2 gdImageDashedLine
 1323 
 1324 $image->gdImageDashedLine( $x1, $y1, $x2, $y2, $color )
 1325 
 1326 =cut
 1327 
 1328 
 1329 sub gdImageDashedLine
 1330 {
 1331     my $self = shift;
 1332     return _gdImageDashedLine ( $self->{IMG_PTR}, @_ );
 1333 } # End of gdImageDashedLine()...
 1334 #line 1335 "GD.pm"
 1335 
 1336 
 1337 
 1338 #line 1959 "GD.pd"
 1339 
 1340 =head2 Rectangle
 1341 
 1342 $image->Rectangle( $x1, $y1, $x2, $y2, $color )
 1343 
 1344 Alias for gdImageRectangle.
 1345 
 1346 =cut
 1347 
 1348 
 1349 sub Rectangle
 1350 {
 1351     return gdImageRectangle ( @_ );
 1352 } # End of Rectangle()...
 1353 
 1354 
 1355 =head2 gdImageRectangle
 1356 
 1357 $image->gdImageRectangle( $x1, $y1, $x2, $y2, $color )
 1358 
 1359 =cut
 1360 
 1361 
 1362 sub gdImageRectangle
 1363 {
 1364     my $self = shift;
 1365     return _gdImageRectangle ( $self->{IMG_PTR}, @_ );
 1366 } # End of gdImageRectangle()...
 1367 #line 1368 "GD.pm"
 1368 
 1369 
 1370 
 1371 #line 1959 "GD.pd"
 1372 
 1373 =head2 FilledRectangle
 1374 
 1375 $image->FilledRectangle( $x1, $y1, $x2, $y2, $color )
 1376 
 1377 Alias for gdImageFilledRectangle.
 1378 
 1379 =cut
 1380 
 1381 
 1382 sub FilledRectangle
 1383 {
 1384     return gdImageFilledRectangle ( @_ );
 1385 } # End of FilledRectangle()...
 1386 
 1387 
 1388 =head2 gdImageFilledRectangle
 1389 
 1390 $image->gdImageFilledRectangle( $x1, $y1, $x2, $y2, $color )
 1391 
 1392 =cut
 1393 
 1394 
 1395 sub gdImageFilledRectangle
 1396 {
 1397     my $self = shift;
 1398     return _gdImageFilledRectangle ( $self->{IMG_PTR}, @_ );
 1399 } # End of gdImageFilledRectangle()...
 1400 #line 1401 "GD.pm"
 1401 
 1402 
 1403 
 1404 #line 1959 "GD.pd"
 1405 
 1406 =head2 SetClip
 1407 
 1408 $image->SetClip( $x1, $y1, $x2, $y2 )
 1409 
 1410 Alias for gdImageSetClip.
 1411 
 1412 =cut
 1413 
 1414 
 1415 sub SetClip
 1416 {
 1417     return gdImageSetClip ( @_ );
 1418 } # End of SetClip()...
 1419 
 1420 
 1421 =head2 gdImageSetClip
 1422 
 1423 $image->gdImageSetClip( $x1, $y1, $x2, $y2 )
 1424 
 1425 =cut
 1426 
 1427 
 1428 sub gdImageSetClip
 1429 {
 1430     my $self = shift;
 1431     return _gdImageSetClip ( $self->{IMG_PTR}, @_ );
 1432 } # End of gdImageSetClip()...
 1433 #line 1434 "GD.pm"
 1434 
 1435 
 1436 
 1437 #line 1959 "GD.pd"
 1438 
 1439 =head2 GetClip
 1440 
 1441 $image->GetClip( $x1P, $y1P, $x2P, $y2P )
 1442 
 1443 Alias for gdImageGetClip.
 1444 
 1445 =cut
 1446 
 1447 
 1448 sub GetClip
 1449 {
 1450     return gdImageGetClip ( @_ );
 1451 } # End of GetClip()...
 1452 
 1453 
 1454 =head2 gdImageGetClip
 1455 
 1456 $image->gdImageGetClip( $x1P, $y1P, $x2P, $y2P )
 1457 
 1458 =cut
 1459 
 1460 
 1461 sub gdImageGetClip
 1462 {
 1463     my $self = shift;
 1464     return _gdImageGetClip ( $self->{IMG_PTR}, @_ );
 1465 } # End of gdImageGetClip()...
 1466 #line 1467 "GD.pm"
 1467 
 1468 
 1469 
 1470 #line 1959 "GD.pd"
 1471 
 1472 =head2 BoundsSafe
 1473 
 1474 $image->BoundsSafe( $x, $y )
 1475 
 1476 Alias for gdImageBoundsSafe.
 1477 
 1478 =cut
 1479 
 1480 
 1481 sub BoundsSafe
 1482 {
 1483     return gdImageBoundsSafe ( @_ );
 1484 } # End of BoundsSafe()...
 1485 
 1486 
 1487 =head2 gdImageBoundsSafe
 1488 
 1489 $image->gdImageBoundsSafe( $x, $y )
 1490 
 1491 =cut
 1492 
 1493 
 1494 sub gdImageBoundsSafe
 1495 {
 1496     my $self = shift;
 1497     return _gdImageBoundsSafe ( $self->{IMG_PTR}, @_ );
 1498 } # End of gdImageBoundsSafe()...
 1499 #line 1500 "GD.pm"
 1500 
 1501 
 1502 
 1503 #line 1959 "GD.pd"
 1504 
 1505 =head2 Char
 1506 
 1507 $image->Char( $f, $x, $y, $c, $color )
 1508 
 1509 Alias for gdImageChar.
 1510 
 1511 =cut
 1512 
 1513 
 1514 sub Char
 1515 {
 1516     return gdImageChar ( @_ );
 1517 } # End of Char()...
 1518 
 1519 
 1520 =head2 gdImageChar
 1521 
 1522 $image->gdImageChar( $f, $x, $y, $c, $color )
 1523 
 1524 =cut
 1525 
 1526 
 1527 sub gdImageChar
 1528 {
 1529     my $self = shift;
 1530     return _gdImageChar ( $self->{IMG_PTR}, @_ );
 1531 } # End of gdImageChar()...
 1532 #line 1533 "GD.pm"
 1533 
 1534 
 1535 
 1536 #line 1959 "GD.pd"
 1537 
 1538 =head2 CharUp
 1539 
 1540 $image->CharUp( $f, $x, $y, $c, $color )
 1541 
 1542 Alias for gdImageCharUp.
 1543 
 1544 =cut
 1545 
 1546 
 1547 sub CharUp
 1548 {
 1549     return gdImageCharUp ( @_ );
 1550 } # End of CharUp()...
 1551 
 1552 
 1553 =head2 gdImageCharUp
 1554 
 1555 $image->gdImageCharUp( $f, $x, $y, $c, $color )
 1556 
 1557 =cut
 1558 
 1559 
 1560 sub gdImageCharUp
 1561 {
 1562     my $self = shift;
 1563     return _gdImageCharUp ( $self->{IMG_PTR}, @_ );
 1564 } # End of gdImageCharUp()...
 1565 #line 1566 "GD.pm"
 1566 
 1567 
 1568 
 1569 #line 1959 "GD.pd"
 1570 
 1571 =head2 String
 1572 
 1573 $image->String( $f, $x, $y, $s, $color )
 1574 
 1575 Alias for gdImageString.
 1576 
 1577 =cut
 1578 
 1579 
 1580 sub String
 1581 {
 1582     return gdImageString ( @_ );
 1583 } # End of String()...
 1584 
 1585 
 1586 =head2 gdImageString
 1587 
 1588 $image->gdImageString( $f, $x, $y, $s, $color )
 1589 
 1590 =cut
 1591 
 1592 
 1593 sub gdImageString
 1594 {
 1595     my $self = shift;
 1596     return _gdImageString ( $self->{IMG_PTR}, @_ );
 1597 } # End of gdImageString()...
 1598 #line 1599 "GD.pm"
 1599 
 1600 
 1601 
 1602 #line 1959 "GD.pd"
 1603 
 1604 =head2 StringUp
 1605 
 1606 $image->StringUp( $f, $x, $y, $s, $color )
 1607 
 1608 Alias for gdImageStringUp.
 1609 
 1610 =cut
 1611 
 1612 
 1613 sub StringUp
 1614 {
 1615     return gdImageStringUp ( @_ );
 1616 } # End of StringUp()...
 1617 
 1618 
 1619 =head2 gdImageStringUp
 1620 
 1621 $image->gdImageStringUp( $f, $x, $y, $s, $color )
 1622 
 1623 =cut
 1624 
 1625 
 1626 sub gdImageStringUp
 1627 {
 1628     my $self = shift;
 1629     return _gdImageStringUp ( $self->{IMG_PTR}, @_ );
 1630 } # End of gdImageStringUp()...
 1631 #line 1632 "GD.pm"
 1632 
 1633 
 1634 
 1635 #line 1959 "GD.pd"
 1636 
 1637 =head2 String16
 1638 
 1639 $image->String16( $f, $x, $y, $s, $color )
 1640 
 1641 Alias for gdImageString16.
 1642 
 1643 =cut
 1644 
 1645 
 1646 sub String16
 1647 {
 1648     return gdImageString16 ( @_ );
 1649 } # End of String16()...
 1650 
 1651 
 1652 =head2 gdImageString16
 1653 
 1654 $image->gdImageString16( $f, $x, $y, $s, $color )
 1655 
 1656 =cut
 1657 
 1658 
 1659 sub gdImageString16
 1660 {
 1661     my $self = shift;
 1662     return _gdImageString16 ( $self->{IMG_PTR}, @_ );
 1663 } # End of gdImageString16()...
 1664 #line 1665 "GD.pm"
 1665 
 1666 
 1667 
 1668 #line 1959 "GD.pd"
 1669 
 1670 =head2 StringUp16
 1671 
 1672 $image->StringUp16( $f, $x, $y, $s, $color )
 1673 
 1674 Alias for gdImageStringUp16.
 1675 
 1676 =cut
 1677 
 1678 
 1679 sub StringUp16
 1680 {
 1681     return gdImageStringUp16 ( @_ );
 1682 } # End of StringUp16()...
 1683 
 1684 
 1685 =head2 gdImageStringUp16
 1686 
 1687 $image->gdImageStringUp16( $f, $x, $y, $s, $color )
 1688 
 1689 =cut
 1690 
 1691 
 1692 sub gdImageStringUp16
 1693 {
 1694     my $self = shift;
 1695     return _gdImageStringUp16 ( $self->{IMG_PTR}, @_ );
 1696 } # End of gdImageStringUp16()...
 1697 #line 1698 "GD.pm"
 1698 
 1699 
 1700 
 1701 #line 1959 "GD.pd"
 1702 
 1703 =head2 Polygon
 1704 
 1705 $image->Polygon( $p, $n, $c )
 1706 
 1707 Alias for gdImagePolygon.
 1708 
 1709 =cut
 1710 
 1711 
 1712 sub Polygon
 1713 {
 1714     return gdImagePolygon ( @_ );
 1715 } # End of Polygon()...
 1716 
 1717 
 1718 =head2 gdImagePolygon
 1719 
 1720 $image->gdImagePolygon( $p, $n, $c )
 1721 
 1722 =cut
 1723 
 1724 
 1725 sub gdImagePolygon
 1726 {
 1727     my $self = shift;
 1728     return _gdImagePolygon ( $self->{IMG_PTR}, @_ );
 1729 } # End of gdImagePolygon()...
 1730 #line 1731 "GD.pm"
 1731 
 1732 
 1733 
 1734 #line 1959 "GD.pd"
 1735 
 1736 =head2 FilledPolygon
 1737 
 1738 $image->FilledPolygon( $p, $n, $c )
 1739 
 1740 Alias for gdImageFilledPolygon.
 1741 
 1742 =cut
 1743 
 1744 
 1745 sub FilledPolygon
 1746 {
 1747     return gdImageFilledPolygon ( @_ );
 1748 } # End of FilledPolygon()...
 1749 
 1750 
 1751 =head2 gdImageFilledPolygon
 1752 
 1753 $image->gdImageFilledPolygon( $p, $n, $c )
 1754 
 1755 =cut
 1756 
 1757 
 1758 sub gdImageFilledPolygon
 1759 {
 1760     my $self = shift;
 1761     return _gdImageFilledPolygon ( $self->{IMG_PTR}, @_ );
 1762 } # End of gdImageFilledPolygon()...
 1763 #line 1764 "GD.pm"
 1764 
 1765 
 1766 
 1767 #line 1959 "GD.pd"
 1768 
 1769 =head2 ColorAllocate
 1770 
 1771 $image->ColorAllocate( $r, $g, $b )
 1772 
 1773 Alias for gdImageColorAllocate.
 1774 
 1775 =cut
 1776 
 1777 
 1778 sub ColorAllocate
 1779 {
 1780     return gdImageColorAllocate ( @_ );
 1781 } # End of ColorAllocate()...
 1782 
 1783 
 1784 =head2 gdImageColorAllocate
 1785 
 1786 $image->gdImageColorAllocate( $r, $g, $b )
 1787 
 1788 =cut
 1789 
 1790 
 1791 sub gdImageColorAllocate
 1792 {
 1793     my $self = shift;
 1794     return _gdImageColorAllocate ( $self->{IMG_PTR}, @_ );
 1795 } # End of gdImageColorAllocate()...
 1796 #line 1797 "GD.pm"
 1797 
 1798 
 1799 
 1800 #line 1959 "GD.pd"
 1801 
 1802 =head2 ColorAllocateAlpha
 1803 
 1804 $image->ColorAllocateAlpha( $r, $g, $b, $a )
 1805 
 1806 Alias for gdImageColorAllocateAlpha.
 1807 
 1808 =cut
 1809 
 1810 
 1811 sub ColorAllocateAlpha
 1812 {
 1813     return gdImageColorAllocateAlpha ( @_ );
 1814 } # End of ColorAllocateAlpha()...
 1815 
 1816 
 1817 =head2 gdImageColorAllocateAlpha
 1818 
 1819 $image->gdImageColorAllocateAlpha( $r, $g, $b, $a )
 1820 
 1821 =cut
 1822 
 1823 
 1824 sub gdImageColorAllocateAlpha
 1825 {
 1826     my $self = shift;
 1827     return _gdImageColorAllocateAlpha ( $self->{IMG_PTR}, @_ );
 1828 } # End of gdImageColorAllocateAlpha()...
 1829 #line 1830 "GD.pm"
 1830 
 1831 
 1832 
 1833 #line 1959 "GD.pd"
 1834 
 1835 =head2 ColorClosest
 1836 
 1837 $image->ColorClosest( $r, $g, $b )
 1838 
 1839 Alias for gdImageColorClosest.
 1840 
 1841 =cut
 1842 
 1843 
 1844 sub ColorClosest
 1845 {
 1846     return gdImageColorClosest ( @_ );
 1847 } # End of ColorClosest()...
 1848 
 1849 
 1850 =head2 gdImageColorClosest
 1851 
 1852 $image->gdImageColorClosest( $r, $g, $b )
 1853 
 1854 =cut
 1855 
 1856 
 1857 sub gdImageColorClosest
 1858 {
 1859     my $self = shift;
 1860     return _gdImageColorClosest ( $self->{IMG_PTR}, @_ );
 1861 } # End of gdImageColorClosest()...
 1862 #line 1863 "GD.pm"
 1863 
 1864 
 1865 
 1866 #line 1959 "GD.pd"
 1867 
 1868 =head2 ColorClosestAlpha
 1869 
 1870 $image->ColorClosestAlpha( $r, $g, $b, $a )
 1871 
 1872 Alias for gdImageColorClosestAlpha.
 1873 
 1874 =cut
 1875 
 1876 
 1877 sub ColorClosestAlpha
 1878 {
 1879     return gdImageColorClosestAlpha ( @_ );
 1880 } # End of ColorClosestAlpha()...
 1881 
 1882 
 1883 =head2 gdImageColorClosestAlpha
 1884 
 1885 $image->gdImageColorClosestAlpha( $r, $g, $b, $a )
 1886 
 1887 =cut
 1888 
 1889 
 1890 sub gdImageColorClosestAlpha
 1891 {
 1892     my $self = shift;
 1893     return _gdImageColorClosestAlpha ( $self->{IMG_PTR}, @_ );
 1894 } # End of gdImageColorClosestAlpha()...
 1895 #line 1896 "GD.pm"
 1896 
 1897 
 1898 
 1899 #line 1959 "GD.pd"
 1900 
 1901 =head2 ColorClosestHWB
 1902 
 1903 $image->ColorClosestHWB( $r, $g, $b )
 1904 
 1905 Alias for gdImageColorClosestHWB.
 1906 
 1907 =cut
 1908 
 1909 
 1910 sub ColorClosestHWB
 1911 {
 1912     return gdImageColorClosestHWB ( @_ );
 1913 } # End of ColorClosestHWB()...
 1914 
 1915 
 1916 =head2 gdImageColorClosestHWB
 1917 
 1918 $image->gdImageColorClosestHWB( $r, $g, $b )
 1919 
 1920 =cut
 1921 
 1922 
 1923 sub gdImageColorClosestHWB
 1924 {
 1925     my $self = shift;
 1926     return _gdImageColorClosestHWB ( $self->{IMG_PTR}, @_ );
 1927 } # End of gdImageColorClosestHWB()...
 1928 #line 1929 "GD.pm"
 1929 
 1930 
 1931 
 1932 #line 1959 "GD.pd"
 1933 
 1934 =head2 ColorExact
 1935 
 1936 $image->ColorExact( $r, $g, $b )
 1937 
 1938 Alias for gdImageColorExact.
 1939 
 1940 =cut
 1941 
 1942 
 1943 sub ColorExact
 1944 {
 1945     return gdImageColorExact ( @_ );
 1946 } # End of ColorExact()...
 1947 
 1948 
 1949 =head2 gdImageColorExact
 1950 
 1951 $image->gdImageColorExact( $r, $g, $b )
 1952 
 1953 =cut
 1954 
 1955 
 1956 sub gdImageColorExact
 1957 {
 1958     my $self = shift;
 1959     return _gdImageColorExact ( $self->{IMG_PTR}, @_ );
 1960 } # End of gdImageColorExact()...
 1961 #line 1962 "GD.pm"
 1962 
 1963 
 1964 
 1965 #line 1959 "GD.pd"
 1966 
 1967 =head2 ColorExactAlpha
 1968 
 1969 $image->ColorExactAlpha( $r, $g, $b, $a )
 1970 
 1971 Alias for gdImageColorExactAlpha.
 1972 
 1973 =cut
 1974 
 1975 
 1976 sub ColorExactAlpha
 1977 {
 1978     return gdImageColorExactAlpha ( @_ );
 1979 } # End of ColorExactAlpha()...
 1980 
 1981 
 1982 =head2 gdImageColorExactAlpha
 1983 
 1984 $image->gdImageColorExactAlpha( $r, $g, $b, $a )
 1985 
 1986 =cut
 1987 
 1988 
 1989 sub gdImageColorExactAlpha
 1990 {
 1991     my $self = shift;
 1992     return _gdImageColorExactAlpha ( $self->{IMG_PTR}, @_ );
 1993 } # End of gdImageColorExactAlpha()...
 1994 #line 1995 "GD.pm"
 1995 
 1996 
 1997 
 1998 #line 1959 "GD.pd"
 1999 
 2000 =head2 ColorResolve
 2001 
 2002 $image->ColorResolve( $r, $g, $b )
 2003 
 2004 Alias for gdImageColorResolve.
 2005 
 2006 =cut
 2007 
 2008 
 2009 sub ColorResolve
 2010 {
 2011     return gdImageColorResolve ( @_ );
 2012 } # End of ColorResolve()...
 2013 
 2014 
 2015 =head2 gdImageColorResolve
 2016 
 2017 $image->gdImageColorResolve( $r, $g, $b )
 2018 
 2019 =cut
 2020 
 2021 
 2022 sub gdImageColorResolve
 2023 {
 2024     my $self = shift;
 2025     return _gdImageColorResolve ( $self->{IMG_PTR}, @_ );
 2026 } # End of gdImageColorResolve()...
 2027 #line 2028 "GD.pm"
 2028 
 2029 
 2030 
 2031 #line 1959 "GD.pd"
 2032 
 2033 =head2 ColorResolveAlpha
 2034 
 2035 $image->ColorResolveAlpha( $r, $g, $b, $a )
 2036 
 2037 Alias for gdImageColorResolveAlpha.
 2038 
 2039 =cut
 2040 
 2041 
 2042 sub ColorResolveAlpha
 2043 {
 2044     return gdImageColorResolveAlpha ( @_ );
 2045 } # End of ColorResolveAlpha()...
 2046 
 2047 
 2048 =head2 gdImageColorResolveAlpha
 2049 
 2050 $image->gdImageColorResolveAlpha( $r, $g, $b, $a )
 2051 
 2052 =cut
 2053 
 2054 
 2055 sub gdImageColorResolveAlpha
 2056 {
 2057     my $self = shift;
 2058     return _gdImageColorResolveAlpha ( $self->{IMG_PTR}, @_ );
 2059 } # End of gdImageColorResolveAlpha()...
 2060 #line 2061 "GD.pm"
 2061 
 2062 
 2063 
 2064 #line 1959 "GD.pd"
 2065 
 2066 =head2 ColorDeallocate
 2067 
 2068 $image->ColorDeallocate( $color )
 2069 
 2070 Alias for gdImageColorDeallocate.
 2071 
 2072 =cut
 2073 
 2074 
 2075 sub ColorDeallocate
 2076 {
 2077     return gdImageColorDeallocate ( @_ );
 2078 } # End of ColorDeallocate()...
 2079 
 2080 
 2081 =head2 gdImageColorDeallocate
 2082 
 2083 $image->gdImageColorDeallocate( $color )
 2084 
 2085 =cut
 2086 
 2087 
 2088 sub gdImageColorDeallocate
 2089 {
 2090     my $self = shift;
 2091     return _gdImageColorDeallocate ( $self->{IMG_PTR}, @_ );
 2092 } # End of gdImageColorDeallocate()...
 2093 #line 2094 "GD.pm"
 2094 
 2095 
 2096 
 2097 #line 1959 "GD.pd"
 2098 
 2099 =head2 TrueColorToPalette
 2100 
 2101 $image->TrueColorToPalette( $ditherFlag, $colorsWanted )
 2102 
 2103 Alias for gdImageTrueColorToPalette.
 2104 
 2105 =cut
 2106 
 2107 
 2108 sub TrueColorToPalette
 2109 {
 2110     return gdImageTrueColorToPalette ( @_ );
 2111 } # End of TrueColorToPalette()...
 2112 
 2113 
 2114 =head2 gdImageTrueColorToPalette
 2115 
 2116 $image->gdImageTrueColorToPalette( $ditherFlag, $colorsWanted )
 2117 
 2118 =cut
 2119 
 2120 
 2121 sub gdImageTrueColorToPalette
 2122 {
 2123     my $self = shift;
 2124     return _gdImageTrueColorToPalette ( $self->{IMG_PTR}, @_ );
 2125 } # End of gdImageTrueColorToPalette()...
 2126 #line 2127 "GD.pm"
 2127 
 2128 
 2129 
 2130 #line 1959 "GD.pd"
 2131 
 2132 =head2 ColorTransparent
 2133 
 2134 $image->ColorTransparent( $color )
 2135 
 2136 Alias for gdImageColorTransparent.
 2137 
 2138 =cut
 2139 
 2140 
 2141 sub ColorTransparent
 2142 {
 2143     return gdImageColorTransparent ( @_ );
 2144 } # End of ColorTransparent()...
 2145 
 2146 
 2147 =head2 gdImageColorTransparent
 2148 
 2149 $image->gdImageColorTransparent( $color )
 2150 
 2151 =cut
 2152 
 2153 
 2154 sub gdImageColorTransparent
 2155 {
 2156     my $self = shift;
 2157     return _gdImageColorTransparent ( $self->{IMG_PTR}, @_ );
 2158 } # End of gdImageColorTransparent()...
 2159 #line 2160 "GD.pm"
 2160 
 2161 
 2162 
 2163 #line 1959 "GD.pd"
 2164 
 2165 =head2 FilledArc
 2166 
 2167 $image->FilledArc( $cx, $cy, $w, $h, $s, $e, $color, $style )
 2168 
 2169 Alias for gdImageFilledArc.
 2170 
 2171 =cut
 2172 
 2173 
 2174 sub FilledArc
 2175 {
 2176     return gdImageFilledArc ( @_ );
 2177 } # End of FilledArc()...
 2178 
 2179 
 2180 =head2 gdImageFilledArc
 2181 
 2182 $image->gdImageFilledArc( $cx, $cy, $w, $h, $s, $e, $color, $style )
 2183 
 2184 =cut
 2185 
 2186 
 2187 sub gdImageFilledArc
 2188 {
 2189     my $self = shift;
 2190     return _gdImageFilledArc ( $self->{IMG_PTR}, @_ );
 2191 } # End of gdImageFilledArc()...
 2192 #line 2193 "GD.pm"
 2193 
 2194 
 2195 
 2196 #line 1959 "GD.pd"
 2197 
 2198 =head2 Arc
 2199 
 2200 $image->Arc( $cx, $cy, $w, $h, $s, $e, $color )
 2201 
 2202 Alias for gdImageArc.
 2203 
 2204 =cut
 2205 
 2206 
 2207 sub Arc
 2208 {
 2209     return gdImageArc ( @_ );
 2210 } # End of Arc()...
 2211 
 2212 
 2213 =head2 gdImageArc
 2214 
 2215 $image->gdImageArc( $cx, $cy, $w, $h, $s, $e, $color )
 2216 
 2217 =cut
 2218 
 2219 
 2220 sub gdImageArc
 2221 {
 2222     my $self = shift;
 2223     return _gdImageArc ( $self->{IMG_PTR}, @_ );
 2224 } # End of gdImageArc()...
 2225 #line 2226 "GD.pm"
 2226 
 2227 
 2228 
 2229 #line 1959 "GD.pd"
 2230 
 2231 =head2 FilledEllipse
 2232 
 2233 $image->FilledEllipse( $cx, $cy, $w, $h, $color )
 2234 
 2235 Alias for gdImageFilledEllipse.
 2236 
 2237 =cut
 2238 
 2239 
 2240 sub FilledEllipse
 2241 {
 2242     return gdImageFilledEllipse ( @_ );
 2243 } # End of FilledEllipse()...
 2244 
 2245 
 2246 =head2 gdImageFilledEllipse
 2247 
 2248 $image->gdImageFilledEllipse( $cx, $cy, $w, $h, $color )
 2249 
 2250 =cut
 2251 
 2252 
 2253 sub gdImageFilledEllipse
 2254 {
 2255     my $self = shift;
 2256     return _gdImageFilledEllipse ( $self->{IMG_PTR}, @_ );
 2257 } # End of gdImageFilledEllipse()...
 2258 #line 2259 "GD.pm"
 2259 
 2260 
 2261 
 2262 #line 1959 "GD.pd"
 2263 
 2264 =head2 FillToBorder
 2265 
 2266 $image->FillToBorder( $x, $y, $border, $color )
 2267 
 2268 Alias for gdImageFillToBorder.
 2269 
 2270 =cut
 2271 
 2272 
 2273 sub FillToBorder
 2274 {
 2275     return gdImageFillToBorder ( @_ );
 2276 } # End of FillToBorder()...
 2277 
 2278 
 2279 =head2 gdImageFillToBorder
 2280 
 2281 $image->gdImageFillToBorder( $x, $y, $border, $color )
 2282 
 2283 =cut
 2284 
 2285 
 2286 sub gdImageFillToBorder
 2287 {
 2288     my $self = shift;
 2289     return _gdImageFillToBorder ( $self->{IMG_PTR}, @_ );
 2290 } # End of gdImageFillToBorder()...
 2291 #line 2292 "GD.pm"
 2292 
 2293 
 2294 
 2295 #line 1959 "GD.pd"
 2296 
 2297 =head2 Fill
 2298 
 2299 $image->Fill( $x, $y, $color )
 2300 
 2301 Alias for gdImageFill.
 2302 
 2303 =cut
 2304 
 2305 
 2306 sub Fill
 2307 {
 2308     return gdImageFill ( @_ );
 2309 } # End of Fill()...
 2310 
 2311 
 2312 =head2 gdImageFill
 2313 
 2314 $image->gdImageFill( $x, $y, $color )
 2315 
 2316 =cut
 2317 
 2318 
 2319 sub gdImageFill
 2320 {
 2321     my $self = shift;
 2322     return _gdImageFill ( $self->{IMG_PTR}, @_ );
 2323 } # End of gdImageFill()...
 2324 #line 2325 "GD.pm"
 2325 
 2326 
 2327 
 2328 #line 1959 "GD.pd"
 2329 
 2330 =head2 CopyRotated
 2331 
 2332 $image->CopyRotated( $dstX, $dstY, $srcX, $srcY, $srcWidth, $srcHeight, $angle )
 2333 
 2334 Alias for gdImageCopyRotated.
 2335 
 2336 =cut
 2337 
 2338 
 2339 sub CopyRotated
 2340 {
 2341     return gdImageCopyRotated ( @_ );
 2342 } # End of CopyRotated()...
 2343 
 2344 
 2345 =head2 gdImageCopyRotated
 2346 
 2347 $image->gdImageCopyRotated( $dstX, $dstY, $srcX, $srcY, $srcWidth, $srcHeight, $angle )
 2348 
 2349 =cut
 2350 
 2351 
 2352 sub gdImageCopyRotated
 2353 {
 2354     my $self = shift;
 2355     return _gdImageCopyRotated ( $self->{IMG_PTR}, @_ );
 2356 } # End of gdImageCopyRotated()...
 2357 #line 2358 "GD.pm"
 2358 
 2359 
 2360 
 2361 #line 1959 "GD.pd"
 2362 
 2363 =head2 SetBrush
 2364 
 2365 $image->SetBrush(  )
 2366 
 2367 Alias for gdImageSetBrush.
 2368 
 2369 =cut
 2370 
 2371 
 2372 sub SetBrush
 2373 {
 2374     return gdImageSetBrush ( @_ );
 2375 } # End of SetBrush()...
 2376 
 2377 
 2378 =head2 gdImageSetBrush
 2379 
 2380 $image->gdImageSetBrush(  )
 2381 
 2382 =cut
 2383 
 2384 
 2385 sub gdImageSetBrush
 2386 {
 2387     my $self = shift;
 2388     return _gdImageSetBrush ( $self->{IMG_PTR}, @_ );
 2389 } # End of gdImageSetBrush()...
 2390 #line 2391 "GD.pm"
 2391 
 2392 
 2393 
 2394 #line 1959 "GD.pd"
 2395 
 2396 =head2 SetTile
 2397 
 2398 $image->SetTile(  )
 2399 
 2400 Alias for gdImageSetTile.
 2401 
 2402 =cut
 2403 
 2404 
 2405 sub SetTile
 2406 {
 2407     return gdImageSetTile ( @_ );
 2408 } # End of SetTile()...
 2409 
 2410 
 2411 =head2 gdImageSetTile
 2412 
 2413 $image->gdImageSetTile(  )
 2414 
 2415 =cut
 2416 
 2417 
 2418 sub gdImageSetTile
 2419 {
 2420     my $self = shift;
 2421     return _gdImageSetTile ( $self->{IMG_PTR}, @_ );
 2422 } # End of gdImageSetTile()...
 2423 #line 2424 "GD.pm"
 2424 
 2425 
 2426 
 2427 #line 1959 "GD.pd"
 2428 
 2429 =head2 SetAntiAliased
 2430 
 2431 $image->SetAntiAliased( $c )
 2432 
 2433 Alias for gdImageSetAntiAliased.
 2434 
 2435 =cut
 2436 
 2437 
 2438 sub SetAntiAliased
 2439 {
 2440     return gdImageSetAntiAliased ( @_ );
 2441 } # End of SetAntiAliased()...
 2442 
 2443 
 2444 =head2 gdImageSetAntiAliased
 2445 
 2446 $image->gdImageSetAntiAliased( $c )
 2447 
 2448 =cut
 2449 
 2450 
 2451 sub gdImageSetAntiAliased
 2452 {
 2453     my $self = shift;
 2454     return _gdImageSetAntiAliased ( $self->{IMG_PTR}, @_ );
 2455 } # End of gdImageSetAntiAliased()...
 2456 #line 2457 "GD.pm"
 2457 
 2458 
 2459 
 2460 #line 1959 "GD.pd"
 2461 
 2462 =head2 SetAntiAliasedDontBlend
 2463 
 2464 $image->SetAntiAliasedDontBlend( $c, $dont_blend )
 2465 
 2466 Alias for gdImageSetAntiAliasedDontBlend.
 2467 
 2468 =cut
 2469 
 2470 
 2471 sub SetAntiAliasedDontBlend
 2472 {
 2473     return gdImageSetAntiAliasedDontBlend ( @_ );
 2474 } # End of SetAntiAliasedDontBlend()...
 2475 
 2476 
 2477 =head2 gdImageSetAntiAliasedDontBlend
 2478 
 2479 $image->gdImageSetAntiAliasedDontBlend( $c, $dont_blend )
 2480 
 2481 =cut
 2482 
 2483 
 2484 sub gdImageSetAntiAliasedDontBlend
 2485 {
 2486     my $self = shift;
 2487     return _gdImageSetAntiAliasedDontBlend ( $self->{IMG_PTR}, @_ );
 2488 } # End of gdImageSetAntiAliasedDontBlend()...
 2489 #line 2490 "GD.pm"
 2490 
 2491 
 2492 
 2493 #line 1959 "GD.pd"
 2494 
 2495 =head2 SetStyle
 2496 
 2497 $image->SetStyle( $style, $noOfPixels )
 2498 
 2499 Alias for gdImageSetStyle.
 2500 
 2501 =cut
 2502 
 2503 
 2504 sub SetStyle
 2505 {
 2506     return gdImageSetStyle ( @_ );
 2507 } # End of SetStyle()...
 2508 
 2509 
 2510 =head2 gdImageSetStyle
 2511 
 2512 $image->gdImageSetStyle( $style, $noOfPixels )
 2513 
 2514 =cut
 2515 
 2516 
 2517 sub gdImageSetStyle
 2518 {
 2519     my $self = shift;
 2520     return _gdImageSetStyle ( $self->{IMG_PTR}, @_ );
 2521 } # End of gdImageSetStyle()...
 2522 #line 2523 "GD.pm"
 2523 
 2524 
 2525 
 2526 #line 1959 "GD.pd"
 2527 
 2528 =head2 SetThickness
 2529 
 2530 $image->SetThickness( $thickness )
 2531 
 2532 Alias for gdImageSetThickness.
 2533 
 2534 =cut
 2535 
 2536 
 2537 sub SetThickness
 2538 {
 2539     return gdImageSetThickness ( @_ );
 2540 } # End of SetThickness()...
 2541 
 2542 
 2543 =head2 gdImageSetThickness
 2544 
 2545 $image->gdImageSetThickness( $thickness )
 2546 
 2547 =cut
 2548 
 2549 
 2550 sub gdImageSetThickness
 2551 {
 2552     my $self = shift;
 2553     return _gdImageSetThickness ( $self->{IMG_PTR}, @_ );
 2554 } # End of gdImageSetThickness()...
 2555 #line 2556 "GD.pm"
 2556 
 2557 
 2558 
 2559 #line 1959 "GD.pd"
 2560 
 2561 =head2 Interlace
 2562 
 2563 $image->Interlace( $interlaceArg )
 2564 
 2565 Alias for gdImageInterlace.
 2566 
 2567 =cut
 2568 
 2569 
 2570 sub Interlace
 2571 {
 2572     return gdImageInterlace ( @_ );
 2573 } # End of Interlace()...
 2574 
 2575 
 2576 =head2 gdImageInterlace
 2577 
 2578 $image->gdImageInterlace( $interlaceArg )
 2579 
 2580 =cut
 2581 
 2582 
 2583 sub gdImageInterlace
 2584 {
 2585     my $self = shift;
 2586     return _gdImageInterlace ( $self->{IMG_PTR}, @_ );
 2587 } # End of gdImageInterlace()...
 2588 #line 2589 "GD.pm"
 2589 
 2590 
 2591 
 2592 #line 1959 "GD.pd"
 2593 
 2594 =head2 AlphaBlending
 2595 
 2596 $image->AlphaBlending( $alphaBlendingArg )
 2597 
 2598 Alias for gdImageAlphaBlending.
 2599 
 2600 =cut
 2601 
 2602 
 2603 sub AlphaBlending
 2604 {
 2605     return gdImageAlphaBlending ( @_ );
 2606 } # End of AlphaBlending()...
 2607 
 2608 
 2609 =head2 gdImageAlphaBlending
 2610 
 2611 $image->gdImageAlphaBlending( $alphaBlendingArg )
 2612 
 2613 =cut
 2614 
 2615 
 2616 sub gdImageAlphaBlending
 2617 {
 2618     my $self = shift;
 2619     return _gdImageAlphaBlending ( $self->{IMG_PTR}, @_ );
 2620 } # End of gdImageAlphaBlending()...
 2621 #line 2622 "GD.pm"
 2622 
 2623 
 2624 
 2625 #line 1959 "GD.pd"
 2626 
 2627 =head2 SaveAlpha
 2628 
 2629 $image->SaveAlpha( $saveAlphaArg )
 2630 
 2631 Alias for gdImageSaveAlpha.
 2632 
 2633 =cut
 2634 
 2635 
 2636 sub SaveAlpha
 2637 {
 2638     return gdImageSaveAlpha ( @_ );
 2639 } # End of SaveAlpha()...
 2640 
 2641 
 2642 =head2 gdImageSaveAlpha
 2643 
 2644 $image->gdImageSaveAlpha( $saveAlphaArg )
 2645 
 2646 =cut
 2647 
 2648 
 2649 sub gdImageSaveAlpha
 2650 {
 2651     my $self = shift;
 2652     return _gdImageSaveAlpha ( $self->{IMG_PTR}, @_ );
 2653 } # End of gdImageSaveAlpha()...
 2654 #line 2655 "GD.pm"
 2655 
 2656 
 2657 
 2658 #line 1959 "GD.pd"
 2659 
 2660 =head2 TrueColor
 2661 
 2662 $image->TrueColor(  )
 2663 
 2664 Alias for gdImageTrueColor.
 2665 
 2666 =cut
 2667 
 2668 
 2669 sub TrueColor
 2670 {
 2671     return gdImageTrueColor ( @_ );
 2672 } # End of TrueColor()...
 2673 
 2674 
 2675 =head2 gdImageTrueColor
 2676 
 2677 $image->gdImageTrueColor(  )
 2678 
 2679 =cut
 2680 
 2681 
 2682 sub gdImageTrueColor
 2683 {
 2684     my $self = shift;
 2685     return _gdImageTrueColor ( $self->{IMG_PTR}, @_ );
 2686 } # End of gdImageTrueColor()...
 2687 #line 2688 "GD.pm"
 2688 
 2689 
 2690 
 2691 #line 1959 "GD.pd"
 2692 
 2693 =head2 ColorsTotal
 2694 
 2695 $image->ColorsTotal(  )
 2696 
 2697 Alias for gdImageColorsTotal.
 2698 
 2699 =cut
 2700 
 2701 
 2702 sub ColorsTotal
 2703 {
 2704     return gdImageColorsTotal ( @_ );
 2705 } # End of ColorsTotal()...
 2706 
 2707 
 2708 =head2 gdImageColorsTotal
 2709 
 2710 $image->gdImageColorsTotal(  )
 2711 
 2712 =cut
 2713 
 2714 
 2715 sub gdImageColorsTotal
 2716 {
 2717     my $self = shift;
 2718     return _gdImageColorsTotal ( $self->{IMG_PTR}, @_ );
 2719 } # End of gdImageColorsTotal()...
 2720 #line 2721 "GD.pm"
 2721 
 2722 
 2723 
 2724 #line 1959 "GD.pd"
 2725 
 2726 =head2 Red
 2727 
 2728 $image->Red( $c )
 2729 
 2730 Alias for gdImageRed.
 2731 
 2732 =cut
 2733 
 2734 
 2735 sub Red
 2736 {
 2737     return gdImageRed ( @_ );
 2738 } # End of Red()...
 2739 
 2740 
 2741 =head2 gdImageRed
 2742 
 2743 $image->gdImageRed( $c )
 2744 
 2745 =cut
 2746 
 2747 
 2748 sub gdImageRed
 2749 {
 2750     my $self = shift;
 2751     return _gdImageRed ( $self->{IMG_PTR}, @_ );
 2752 } # End of gdImageRed()...
 2753 #line 2754 "GD.pm"
 2754 
 2755 
 2756 
 2757 #line 1959 "GD.pd"
 2758 
 2759 =head2 Green
 2760 
 2761 $image->Green( $c )
 2762 
 2763 Alias for gdImageGreen.
 2764 
 2765 =cut
 2766 
 2767 
 2768 sub Green
 2769 {
 2770     return gdImageGreen ( @_ );
 2771 } # End of Green()...
 2772 
 2773 
 2774 =head2 gdImageGreen
 2775 
 2776 $image->gdImageGreen( $c )
 2777 
 2778 =cut
 2779 
 2780 
 2781 sub gdImageGreen
 2782 {
 2783     my $self = shift;
 2784     return _gdImageGreen ( $self->{IMG_PTR}, @_ );
 2785 } # End of gdImageGreen()...
 2786 #line 2787 "GD.pm"
 2787 
 2788 
 2789 
 2790 #line 1959 "GD.pd"
 2791 
 2792 =head2 Blue
 2793 
 2794 $image->Blue( $c )
 2795 
 2796 Alias for gdImageBlue.
 2797 
 2798 =cut
 2799 
 2800 
 2801 sub Blue
 2802 {
 2803     return gdImageBlue ( @_ );
 2804 } # End of Blue()...
 2805 
 2806 
 2807 =head2 gdImageBlue
 2808 
 2809 $image->gdImageBlue( $c )
 2810 
 2811 =cut
 2812 
 2813 
 2814 sub gdImageBlue
 2815 {
 2816     my $self = shift;
 2817     return _gdImageBlue ( $self->{IMG_PTR}, @_ );
 2818 } # End of gdImageBlue()...
 2819 #line 2820 "GD.pm"
 2820 
 2821 
 2822 
 2823 #line 1959 "GD.pd"
 2824 
 2825 =head2 Alpha
 2826 
 2827 $image->Alpha( $c )
 2828 
 2829 Alias for gdImageAlpha.
 2830 
 2831 =cut
 2832 
 2833 
 2834 sub Alpha
 2835 {
 2836     return gdImageAlpha ( @_ );
 2837 } # End of Alpha()...
 2838 
 2839 
 2840 =head2 gdImageAlpha
 2841 
 2842 $image->gdImageAlpha( $c )
 2843 
 2844 =cut
 2845 
 2846 
 2847 sub gdImageAlpha
 2848 {
 2849     my $self = shift;
 2850     return _gdImageAlpha ( $self->{IMG_PTR}, @_ );
 2851 } # End of gdImageAlpha()...
 2852 #line 2853 "GD.pm"
 2853 
 2854 
 2855 
 2856 #line 1959 "GD.pd"
 2857 
 2858 =head2 GetTransparent
 2859 
 2860 $image->GetTransparent(  )
 2861 
 2862 Alias for gdImageGetTransparent.
 2863 
 2864 =cut
 2865 
 2866 
 2867 sub GetTransparent
 2868 {
 2869     return gdImageGetTransparent ( @_ );
 2870 } # End of GetTransparent()...
 2871 
 2872 
 2873 =head2 gdImageGetTransparent
 2874 
 2875 $image->gdImageGetTransparent(  )
 2876 
 2877 =cut
 2878 
 2879 
 2880 sub gdImageGetTransparent
 2881 {
 2882     my $self = shift;
 2883     return _gdImageGetTransparent ( $self->{IMG_PTR}, @_ );
 2884 } # End of gdImageGetTransparent()...
 2885 #line 2886 "GD.pm"
 2886 
 2887 
 2888 
 2889 #line 1959 "GD.pd"
 2890 
 2891 =head2 GetInterlaced
 2892 
 2893 $image->GetInterlaced(  )
 2894 
 2895 Alias for gdImageGetInterlaced.
 2896 
 2897 =cut
 2898 
 2899 
 2900 sub GetInterlaced
 2901 {
 2902     return gdImageGetInterlaced ( @_ );
 2903 } # End of GetInterlaced()...
 2904 
 2905 
 2906 =head2 gdImageGetInterlaced
 2907 
 2908 $image->gdImageGetInterlaced(  )
 2909 
 2910 =cut
 2911 
 2912 
 2913 sub gdImageGetInterlaced
 2914 {
 2915     my $self = shift;
 2916     return _gdImageGetInterlaced ( $self->{IMG_PTR}, @_ );
 2917 } # End of gdImageGetInterlaced()...
 2918 #line 2919 "GD.pm"
 2919 
 2920 
 2921 
 2922 #line 1959 "GD.pd"
 2923 
 2924 =head2 SX
 2925 
 2926 $image->SX(  )
 2927 
 2928 Alias for gdImageSX.
 2929 
 2930 =cut
 2931 
 2932 
 2933 sub SX
 2934 {
 2935     return gdImageSX ( @_ );
 2936 } # End of SX()...
 2937 
 2938 
 2939 =head2 gdImageSX
 2940 
 2941 $image->gdImageSX(  )
 2942 
 2943 =cut
 2944 
 2945 
 2946 sub gdImageSX
 2947 {
 2948     my $self = shift;
 2949     return _gdImageSX ( $self->{IMG_PTR}, @_ );
 2950 } # End of gdImageSX()...
 2951 #line 2952 "GD.pm"
 2952 
 2953 
 2954 
 2955 #line 1959 "GD.pd"
 2956 
 2957 =head2 SY
 2958 
 2959 $image->SY(  )
 2960 
 2961 Alias for gdImageSY.
 2962 
 2963 =cut
 2964 
 2965 
 2966 sub SY
 2967 {
 2968     return gdImageSY ( @_ );
 2969 } # End of SY()...
 2970 
 2971 
 2972 =head2 gdImageSY
 2973 
 2974 $image->gdImageSY(  )
 2975 
 2976 =cut
 2977 
 2978 
 2979 sub gdImageSY
 2980 {
 2981     my $self = shift;
 2982     return _gdImageSY ( $self->{IMG_PTR}, @_ );
 2983 } # End of gdImageSY()...
 2984 #line 2985 "GD.pm"
 2985 
 2986 
 2987 
 2988 #line 2060 "GD.pd"
 2989 
 2990 =head2 ColorAllocates
 2991 
 2992 $image->ColorAllocates( $r(pdl), $g(pdl), $b(pdl) )
 2993 
 2994 Alias for gdImageColorAllocates.
 2995 
 2996 =cut
 2997 
 2998 
 2999 sub ColorAllocates
 3000 {
 3001     return gdImageColorAllocates ( @_ );
 3002 } # End of ColorAllocates()...
 3003 
 3004 
 3005 =head2 gdImageColorAllocates
 3006 
 3007 $image->gdImageColorAllocates( $r(pdl), $g(pdl), $b(pdl) )
 3008 
 3009 =cut
 3010 
 3011 
 3012 sub gdImageColorAllocates
 3013 {
 3014     my $self = shift;
 3015     return _gdImageColorAllocates ( @_, $self->{IMG_PTR} );
 3016 } # End of gdImageColorAllocates()...
 3017 #line 3018 "GD.pm"
 3018 
 3019 
 3020 
 3021 #line 2060 "GD.pd"
 3022 
 3023 =head2 ColorAllocateAlphas
 3024 
 3025 $image->ColorAllocateAlphas( $r(pdl), $g(pdl), $b(pdl), $a(pdl) )
 3026 
 3027 Alias for gdImageColorAllocateAlphas.
 3028 
 3029 =cut
 3030 
 3031 
 3032 sub ColorAllocateAlphas
 3033 {
 3034     return gdImageColorAllocateAlphas ( @_ );
 3035 } # End of ColorAllocateAlphas()...
 3036 
 3037 
 3038 =head2 gdImageColorAllocateAlphas
 3039 
 3040 $image->gdImageColorAllocateAlphas( $r(pdl), $g(pdl), $b(pdl), $a(pdl) )
 3041 
 3042 =cut
 3043 
 3044 
 3045 sub gdImageColorAllocateAlphas
 3046 {
 3047     my $self = shift;
 3048     return _gdImageColorAllocateAlphas ( @_, $self->{IMG_PTR} );
 3049 } # End of gdImageColorAllocateAlphas()...
 3050 #line 3051 "GD.pm"
 3051 
 3052 
 3053 
 3054 #line 2060 "GD.pd"
 3055 
 3056 =head2 SetPixels
 3057 
 3058 $image->SetPixels( $x(pdl), $y(pdl), $color(pdl) )
 3059 
 3060 Alias for gdImageSetPixels.
 3061 
 3062 =cut
 3063 
 3064 
 3065 sub SetPixels
 3066 {
 3067     return gdImageSetPixels ( @_ );
 3068 } # End of SetPixels()...
 3069 
 3070 
 3071 =head2 gdImageSetPixels
 3072 
 3073 $image->gdImageSetPixels( $x(pdl), $y(pdl), $color(pdl) )
 3074 
 3075 =cut
 3076 
 3077 
 3078 sub gdImageSetPixels
 3079 {
 3080     my $self = shift;
 3081     return _gdImageSetPixels ( @_, $self->{IMG_PTR} );
 3082 } # End of gdImageSetPixels()...
 3083 #line 3084 "GD.pm"
 3084 
 3085 
 3086 
 3087 #line 2060 "GD.pd"
 3088 
 3089 =head2 Lines
 3090 
 3091 $image->Lines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3092 
 3093 Alias for gdImageLines.
 3094 
 3095 =cut
 3096 
 3097 
 3098 sub Lines
 3099 {
 3100     return gdImageLines ( @_ );
 3101 } # End of Lines()...
 3102 
 3103 
 3104 =head2 gdImageLines
 3105 
 3106 $image->gdImageLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3107 
 3108 =cut
 3109 
 3110 
 3111 sub gdImageLines
 3112 {
 3113     my $self = shift;
 3114     return _gdImageLines ( @_, $self->{IMG_PTR} );
 3115 } # End of gdImageLines()...
 3116 #line 3117 "GD.pm"
 3117 
 3118 
 3119 
 3120 #line 2060 "GD.pd"
 3121 
 3122 =head2 DashedLines
 3123 
 3124 $image->DashedLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3125 
 3126 Alias for gdImageDashedLines.
 3127 
 3128 =cut
 3129 
 3130 
 3131 sub DashedLines
 3132 {
 3133     return gdImageDashedLines ( @_ );
 3134 } # End of DashedLines()...
 3135 
 3136 
 3137 =head2 gdImageDashedLines
 3138 
 3139 $image->gdImageDashedLines( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3140 
 3141 =cut
 3142 
 3143 
 3144 sub gdImageDashedLines
 3145 {
 3146     my $self = shift;
 3147     return _gdImageDashedLines ( @_, $self->{IMG_PTR} );
 3148 } # End of gdImageDashedLines()...
 3149 #line 3150 "GD.pm"
 3150 
 3151 
 3152 
 3153 #line 2060 "GD.pd"
 3154 
 3155 =head2 Rectangles
 3156 
 3157 $image->Rectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3158 
 3159 Alias for gdImageRectangles.
 3160 
 3161 =cut
 3162 
 3163 
 3164 sub Rectangles
 3165 {
 3166     return gdImageRectangles ( @_ );
 3167 } # End of Rectangles()...
 3168 
 3169 
 3170 =head2 gdImageRectangles
 3171 
 3172 $image->gdImageRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3173 
 3174 =cut
 3175 
 3176 
 3177 sub gdImageRectangles
 3178 {
 3179     my $self = shift;
 3180     return _gdImageRectangles ( @_, $self->{IMG_PTR} );
 3181 } # End of gdImageRectangles()...
 3182 #line 3183 "GD.pm"
 3183 
 3184 
 3185 
 3186 #line 2060 "GD.pd"
 3187 
 3188 =head2 FilledRectangles
 3189 
 3190 $image->FilledRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3191 
 3192 Alias for gdImageFilledRectangles.
 3193 
 3194 =cut
 3195 
 3196 
 3197 sub FilledRectangles
 3198 {
 3199     return gdImageFilledRectangles ( @_ );
 3200 } # End of FilledRectangles()...
 3201 
 3202 
 3203 =head2 gdImageFilledRectangles
 3204 
 3205 $image->gdImageFilledRectangles( $x1(pdl), $y1(pdl), $x2(pdl), $y2(pdl), $color(pdl) )
 3206 
 3207 =cut
 3208 
 3209 
 3210 sub gdImageFilledRectangles
 3211 {
 3212     my $self = shift;
 3213     return _gdImageFilledRectangles ( @_, $self->{IMG_PTR} );
 3214 } # End of gdImageFilledRectangles()...
 3215 #line 3216 "GD.pm"
 3216 
 3217 
 3218 
 3219 #line 2060 "GD.pd"
 3220 
 3221 =head2 FilledArcs
 3222 
 3223 $image->FilledArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl), $style(pdl) )
 3224 
 3225 Alias for gdImageFilledArcs.
 3226 
 3227 =cut
 3228 
 3229 
 3230 sub FilledArcs
 3231 {
 3232     return gdImageFilledArcs ( @_ );
 3233 } # End of FilledArcs()...
 3234 
 3235 
 3236 =head2 gdImageFilledArcs
 3237 
 3238 $image->gdImageFilledArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl), $style(pdl) )
 3239 
 3240 =cut
 3241 
 3242 
 3243 sub gdImageFilledArcs
 3244 {
 3245     my $self = shift;
 3246     return _gdImageFilledArcs ( @_, $self->{IMG_PTR} );
 3247 } # End of gdImageFilledArcs()...
 3248 #line 3249 "GD.pm"
 3249 
 3250 
 3251 
 3252 #line 2060 "GD.pd"
 3253 
 3254 =head2 Arcs
 3255 
 3256 $image->Arcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl) )
 3257 
 3258 Alias for gdImageArcs.
 3259 
 3260 =cut
 3261 
 3262 
 3263 sub Arcs
 3264 {
 3265     return gdImageArcs ( @_ );
 3266 } # End of Arcs()...
 3267 
 3268 
 3269 =head2 gdImageArcs
 3270 
 3271 $image->gdImageArcs( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $s(pdl), $e(pdl), $color(pdl) )
 3272 
 3273 =cut
 3274 
 3275 
 3276 sub gdImageArcs
 3277 {
 3278     my $self = shift;
 3279     return _gdImageArcs ( @_, $self->{IMG_PTR} );
 3280 } # End of gdImageArcs()...
 3281 #line 3282 "GD.pm"
 3282 
 3283 
 3284 
 3285 #line 2060 "GD.pd"
 3286 
 3287 =head2 FilledEllipses
 3288 
 3289 $image->FilledEllipses( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $color(pdl) )
 3290 
 3291 Alias for gdImageFilledEllipses.
 3292 
 3293 =cut
 3294 
 3295 
 3296 sub FilledEllipses
 3297 {
 3298     return gdImageFilledEllipses ( @_ );
 3299 } # End of FilledEllipses()...
 3300 
 3301 
 3302 =head2 gdImageFilledEllipses
 3303 
 3304 $image->gdImageFilledEllipses( $cx(pdl), $cy(pdl), $w(pdl), $h(pdl), $color(pdl) )
 3305 
 3306 =cut
 3307 
 3308 
 3309 sub gdImageFilledEllipses
 3310 {
 3311     my $self = shift;
 3312     return _gdImageFilledEllipses ( @_, $self->{IMG_PTR} );
 3313 } # End of gdImageFilledEllipses()...
 3314 #line 3315 "GD.pm"
 3315 
 3316 
 3317 
 3318 #line 2072 "GD.pd"
 3319 
 3320 =head1 CLASS FUNCTIONS
 3321 
 3322 =cut
 3323 #line 3324 "GD.pm"
 3324 
 3325 
 3326 
 3327 #line 2142 "GD.pd"
 3328 
 3329 =head2 gdImageCopy
 3330 
 3331 gdImageCopy ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h )
 3332 
 3333 =cut
 3334 
 3335 
 3336 sub gdImageCopy
 3337 {
 3338     my $dst = shift;
 3339     my $src = shift;
 3340     my $dstX = shift;
 3341     my $dstY = shift;
 3342     my $srcX = shift;
 3343     my $srcY = shift;
 3344     my $w = shift;
 3345     my $h = shift;
 3346 
 3347     return _gdImageCopy ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h );
 3348 } # End of gdImageCopy()...
 3349 #line 3350 "GD.pm"
 3350 
 3351 
 3352 
 3353 #line 2142 "GD.pd"
 3354 
 3355 =head2 gdImageCopyMerge
 3356 
 3357 gdImageCopyMerge ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h, $pct )
 3358 
 3359 =cut
 3360 
 3361 
 3362 sub gdImageCopyMerge
 3363 {
 3364     my $dst = shift;
 3365     my $src = shift;
 3366     my $dstX = shift;
 3367     my $dstY = shift;
 3368     my $srcX = shift;
 3369     my $srcY = shift;
 3370     my $w = shift;
 3371     my $h = shift;
 3372     my $pct = shift;
 3373 
 3374     return _gdImageCopyMerge ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h, $pct );
 3375 } # End of gdImageCopyMerge()...
 3376 #line 3377 "GD.pm"
 3377 
 3378 
 3379 
 3380 #line 2142 "GD.pd"
 3381 
 3382 =head2 gdImageCopyMergeGray
 3383 
 3384 gdImageCopyMergeGray ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $w, $h, $pct )
 3385 
 3386 =cut
 3387 
 3388 
 3389 sub gdImageCopyMergeGray
 3390 {
 3391     my $dst = shift;
 3392     my $src = shift;
 3393     my $dstX = shift;
 3394     my $dstY = shift;
 3395     my $srcX = shift;
 3396     my $srcY = shift;
 3397     my $w = shift;
 3398     my $h = shift;
 3399     my $pct = shift;
 3400 
 3401     return _gdImageCopyMergeGray ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $w, $h, $pct );
 3402 } # End of gdImageCopyMergeGray()...
 3403 #line 3404 "GD.pm"
 3404 
 3405 
 3406 
 3407 #line 2142 "GD.pd"
 3408 
 3409 =head2 gdImageCopyResized
 3410 
 3411 gdImageCopyResized ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH )
 3412 
 3413 =cut
 3414 
 3415 
 3416 sub gdImageCopyResized
 3417 {
 3418     my $dst = shift;
 3419     my $src = shift;
 3420     my $dstX = shift;
 3421     my $dstY = shift;
 3422     my $srcX = shift;
 3423     my $srcY = shift;
 3424     my $dstW = shift;
 3425     my $dstH = shift;
 3426     my $srcW = shift;
 3427     my $srcH = shift;
 3428 
 3429     return _gdImageCopyResized ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH );
 3430 } # End of gdImageCopyResized()...
 3431 #line 3432 "GD.pm"
 3432 
 3433 
 3434 
 3435 #line 2142 "GD.pd"
 3436 
 3437 =head2 gdImageCopyResampled
 3438 
 3439 gdImageCopyResampled ( $dst(PDL::IO::GD), $src(PDL::IO::GD), $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH )
 3440 
 3441 =cut
 3442 
 3443 
 3444 sub gdImageCopyResampled
 3445 {
 3446     my $dst = shift;
 3447     my $src = shift;
 3448     my $dstX = shift;
 3449     my $dstY = shift;
 3450     my $srcX = shift;
 3451     my $srcY = shift;
 3452     my $dstW = shift;
 3453     my $dstH = shift;
 3454     my $srcW = shift;
 3455     my $srcH = shift;
 3456 
 3457     return _gdImageCopyResampled ( $dst->{IMG_PTR}, $src->{IMG_PTR}, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH );
 3458 } # End of gdImageCopyResampled()...
 3459 #line 3460 "GD.pm"
 3460 
 3461 
 3462 
 3463 #line 2142 "GD.pd"
 3464 
 3465 =head2 gdImageCompare
 3466 
 3467 gdImageCompare ( $im1(PDL::IO::GD), $im2(PDL::IO::GD) )
 3468 
 3469 =cut
 3470 
 3471 
 3472 sub gdImageCompare
 3473 {
 3474     my $im1 = shift;
 3475     my $im2 = shift;
 3476 
 3477     return _gdImageCompare ( $im1->{IMG_PTR}, $im2->{IMG_PTR} );
 3478 } # End of gdImageCompare()...
 3479 #line 3480 "GD.pm"
 3480 
 3481 
 3482 
 3483 #line 2142 "GD.pd"
 3484 
 3485 =head2 gdImagePaletteCopy
 3486 
 3487 gdImagePaletteCopy ( $dst(PDL::IO::GD), $src(PDL::IO::GD) )
 3488 
 3489 =cut
 3490 
 3491 
 3492 sub gdImagePaletteCopy
 3493 {
 3494     my $dst = shift;
 3495     my $src = shift;
 3496 
 3497     return _gdImagePaletteCopy ( $dst->{IMG_PTR}, $src->{IMG_PTR} );
 3498 } # End of gdImagePaletteCopy()...
 3499 #line 3500 "GD.pm"
 3500 
 3501 
 3502 
 3503 #line 1468 "GD.pd"
 3504 
 3505 =head2 StringTTF
 3506 
 3507 $image->StringTTF( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )
 3508 
 3509 Alias for gdImageStringTTF.
 3510 
 3511 =cut
 3512 
 3513 
 3514 sub StringTTF
 3515 {
 3516     return gdImageStringTTF ( @_ );
 3517 } # End of StringTTF()...
 3518 
 3519 
 3520 =head2 gdImageStringTTF
 3521 
 3522 $image->gdImageStringTTF( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )
 3523 
 3524 =cut
 3525 
 3526 
 3527 sub gdImageStringTTF
 3528 {
 3529     my $self = shift;
 3530     return _gdImageStringTTF ( $self->{IMG_PTR}, @_ );
 3531 } # End of gdImageStringTTF()...
 3532 #line 3533 "GD.pm"
 3533 
 3534 
 3535 
 3536 #line 1521 "GD.pd"
 3537 
 3538 =head2 StringFT
 3539 
 3540 $image->StringFT( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )
 3541 
 3542 Alias for gdImageStringFT.
 3543 
 3544 =cut
 3545 
 3546 
 3547 sub StringFT
 3548 {
 3549     return gdImageStringFT ( @_ );
 3550 } # End of StringFT()...
 3551 
 3552 
 3553 =head2 gdImageStringFT
 3554 
 3555 $image->gdImageStringFT( $brect, $fg, $fontlist, $ptsize, $angle, $x, $y, $string )
 3556 
 3557 =cut
 3558 
 3559 
 3560 sub gdImageStringFT
 3561 {
 3562     my $self = shift;
 3563     return _gdImageStringFT ( $self->{IMG_PTR}, @_ );
 3564 } # End of gdImageStringFT()...
 3565 #line 3566 "GD.pm"
 3566 
 3567 
 3568 
 3569 #line 1553 "GD.pd"
 3570 
 3571 
 3572 =head1 AUTHOR
 3573 
 3574 Judd Taylor, Orbital Systems, Ltd.
 3575 judd dot t at orbitalsystems dot com
 3576 
 3577 =cut
 3578 #line 3579 "GD.pm"
 3579 
 3580 
 3581 
 3582 
 3583 # Exit with OK status
 3584 
 3585 1;