PDLA
view release on metacpan or search on metacpan
IO/GD/GD.pd view on Meta::CPAN
{
for( x2 = 0; x2 < $SIZE(x); x2++ )
{
gdImageSetPixel(im, x2, y2, $img(x=>x2,y=>y2));
}
}
/* write the image to the file */
out = fopen($COMP(filename), "wb");
gdImagePng(im, out);
fclose(out);
gdImageDestroy(im);
EOC
# Function to write a PNG image from a piddle variable, accepting a compression
# level argument:
pp_def( 'write_png_ex',
IO/GD/GD.pd view on Meta::CPAN
{
for( x2 = 0; x2 < $SIZE(x); x2++ )
{
gdImageSetPixel(im, x2, y2, $img(x=>x2,y=>y2));
}
}
/* write the image to the file */
out = fopen($COMP(filename), "wb");
gdImagePngEx(im, out, $COMP(level));
fclose(out);
gdImageDestroy(im);
EOC
# Function to write a TRUE COLOR PNG image from a piddle variable:
pp_def( 'write_true_png',
Pars => 'img(x,y,z);',
IO/GD/GD.pd view on Meta::CPAN
gdImageColorResolve(im,
$img(x=>x2,y=>y2,z=>0),
$img(x=>x2,y=>y2,z=>1),
$img(x=>x2,y=>y2,z=>2)
)
);
}
}
/* write the image to the file */
out = fopen($COMP(filename), "wb");
gdImagePng(im, out);
fclose(out);
gdImageDestroy(im);
EOC
# Function to write a TRUE COLOR PNG image from a piddle variable,
# with the specified compression level:
pp_def( 'write_true_png_ex',
Pars => 'img(x,y,z);',
OtherPars => 'char* filename; int level',
Doc => <<'ENDDOC',
IO/GD/GD.pd view on Meta::CPAN
gdImageColorResolve(im,
$img(x=>x2,y=>y2,z=>0),
$img(x=>x2,y=>y2,z=>1),
$img(x=>x2,y=>y2,z=>2)
)
);
}
}
/* write the image to the file */
out = fopen($COMP(filename), "wb");
gdImagePngEx( im, out, $COMP(level) );
fclose(out);
gdImageDestroy(im);
EOC
#
# Add some perl level alias functions to automatically use the best compression
#
pp_addpm(<<'ENDPM');
=head2 write_png_best( $img(piddle), $lut(piddle), $filename )
IO/GD/GD.pd view on Meta::CPAN
ENDPM
pp_addxs( '', <<'ENDXS' );
void
recompress_png_best(char* filename)
CODE:
gdImagePtr im;
FILE* file;
file = fopen(filename, "rb");
im = gdImageCreateFromPng(file);
fclose(file);
file = fopen(filename, "wb");
gdImagePngEx( im, file, 9 );
fclose(file);
gdImageDestroy(im);
ENDXS
pp_add_exported( '', 'recompress_png_best' );
# End of recompress_png_best() XS code...
pp_addpm(<<'EOPM');
=head2 load_lut( $filename )
IO/GD/GD.pd view on Meta::CPAN
pp_add_exported('', 'load_lut read_png read_true_png');
pp_addxs('', <<'EOXS');
int
_get_png_xs(char* filename)
CODE:
gdImagePtr im;
FILE* in;
in = fopen(filename, "rb");
im = gdImageCreateFromPng(in);
fclose(in);
RETVAL = gdImageSX(im);
gdImageDestroy(im);
OUTPUT:
RETVAL
int
_get_png_ys(char* filename)
CODE:
gdImagePtr im;
FILE* in;
in = fopen(filename, "rb");
im = gdImageCreateFromPng(in);
fclose(in);
RETVAL = gdImageSY(im);
gdImageDestroy(im);
OUTPUT:
RETVAL
EOXS
# Function to read a TRUE COLOR PNG image into a piddle variable:
pp_def( '_read_true_png',
Pars => 'int [o] img(x,y,z);',
IO/GD/GD.pd view on Meta::CPAN
char* func = "PDLA::IO::GD::_read_png(): ";
char str[255];
FILE *in = NULL;
in = fopen($COMP(filename), "rb");
if ( in == NULL )
{
croak("%sError opening %s!\n", func, $COMP(filename));
}
im = gdImageCreateFromPng(in);
if ( im == NULL )
{
croak("%sError reading PNG data!\n", func);
}
fclose(in);
xsize = gdImageSX(im);
ysize = gdImageSY(im);
/* Check the dims... */
IO/GD/GD.pd view on Meta::CPAN
char* func = "PDLA::IO::GD::_read_png(): ";
char str[255];
FILE *in = NULL;
in = fopen($COMP(filename), "rb");
if ( in == NULL )
{
croak("%sError opening %s!\n", func, $COMP(filename));
}
im = gdImageCreateFromPng(in);
if ( im == NULL )
{
croak("%sError reading PNG data!\n", func);
}
fclose(in);
xsize = gdImageSX(im);
ysize = gdImageSY(im);
/* Check the dims... */
IO/GD/GD.pd view on Meta::CPAN
{
croak("%sLUT dims should be 3,256!\n", func);
}
in = fopen($COMP(filename), "rb");
if ( in == NULL )
{
croak("%sError opening %s!\n", func, $COMP(filename));
}
im = gdImageCreateFromPng(in);
if ( im == NULL )
{
croak("%sError reading PNG data!\n", func);
}
fclose(in);
/* read the data */
for( ind = 0; ind < 256; ind++ )
{
$lut(c=>0,i=>ind) = gdImageRed(im, ind);
IO/GD/GD.pd view on Meta::CPAN
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 PDLA 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,
IO/GD/GD.pd view on Meta::CPAN
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' );
IO/GD/GD.pd view on Meta::CPAN
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' );
IO/GD/GD.pd view on Meta::CPAN
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
ENDPM
generate_create_functions( <<'ENDCREATE' );
gdImagePtr gdImageCreateFromPng (FILE * fd);
gdImagePtr gdImageCreateFromWBMP (FILE * inFile);
gdImagePtr gdImageCreateFromJpeg (FILE * infile);
gdImagePtr gdImageCreateFromGd (FILE * in);
gdImagePtr gdImageCreateFromGd2 (FILE * in);
gdImagePtr gdImageCreateFromXbm (FILE * in);
gdImagePtr gdImageCreateFromGif (FILE * fd);
gdImagePtr gdImageCreate (int sx, int sy);
gdImagePtr gdImageCreatePalette (int sx, int sy);
gdImagePtr gdImageCreateTrueColor (int sx, int sy);
ENDCREATE
generate_create_from_data_functions( <<'ENDCDATA' );
gdImagePtr gdImageCreateFromPngPtr (int size, void * data);
gdImagePtr gdImageCreateFromWBMPPtr (int size, void * data);
gdImagePtr gdImageCreateFromJpegPtr (int size, void * data);
gdImagePtr gdImageCreateFromGdPtr (int size, void * data);
gdImagePtr gdImageCreateFromGd2Ptr (int size, void * data);
gdImagePtr gdImageCreateFromGifPtr (int size, void * data);
ENDCDATA
generate_write_functions( <<'ENDWRITE' );
void gdImagePng (gdImagePtr im, FILE * out);
void gdImagePngEx (gdImagePtr im, FILE * out, int level);
void gdImageWBMP (gdImagePtr image, int fg, FILE * out);
void gdImageJpeg (gdImagePtr im, FILE * out, int quality);
void gdImageGd (gdImagePtr im, FILE * out);
void gdImageGd2 (gdImagePtr im, FILE * out, int cs, int fmt);
void gdImageGif (gdImagePtr im, FILE * out);
ENDWRITE
generate_data_ptr_functions( <<'ENDDATAPTR' );
void *gdImagePngPtr (gdImagePtr im, int *size);
void *gdImagePngPtrEx (gdImagePtr im, int *size, int level);
void *gdImageWBMPPtr (gdImagePtr im, int *size, int fg);
void *gdImageJpegPtr (gdImagePtr im, int *size, int quality);
void *gdImageGdPtr (gdImagePtr im, int *size);
void *gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size);
ENDDATAPTR
#void gdImageDestroy (gdImagePtr im);
generate_member_functions( <<'ENDMEMBERS' );
void gdImageSetPixel (gdImagePtr im, int x, int y, int color);
IO/GD/GD.pd view on Meta::CPAN
#
# Keep these in here for later:
#
my $unused_funcs = <<'ENDUNUSED';
# These have disappeared in later versions of GD:
void gdFreeFontCache ();
void gdImageEllipse (gdImagePtr im, int cx, int cy, int w, int h, int color);
BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data);
BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx (gdIOCtxPtr in);
void gdImagePngCtx (gdImagePtr im, gdIOCtx * out);
void gdImagePngCtxEx (gdImagePtr im, gdIOCtx * out, int level);
void gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out);
void gdImageJpegCtx (gdImagePtr im, gdIOCtx * out, int quality);
void gdImagePngToSink (gdImagePtr im, gdSinkPtr out);
gdIOCtx *gdNewFileCtx (FILE *);
gdIOCtx *gdNewDynamicCtx (int, void *);
gdIOCtx *gdNewSSCtx (gdSourcePtr in, gdSinkPtr out);
void *gdDPExtractData (struct gdIOCtx *ctx, int *size);
gdImagePtr gdImageCreateFromPngSource (gdSourcePtr in);
gdImagePtr gdImageCreateFromGd2Part (FILE * in, int srcx, int srcy, int w, int h);
char* gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y, char *string, gdFTStringExtraPtr strex);
ENDUNUSED
# Add functions that the code gen doesn't handle properly:
#
#char* gdImageStringTTF (gdImagePtr im, int *brect, int fg, char *fontlist, double ptsize, double angle, int x, int y, char *string);
pp_addxs( <<"ENDXS" );
char*
_gdImageStringTTF( im, brect, fg, fontlist, ptsize, angle, x, y, string )
IO/GD/GD.pd view on Meta::CPAN
{
add_basic_xs( $info, '_' );
}
}
} # End of generate_create_functions()...
#
# Member functions to create a new object from a data scalar:
#
# gdImagePtr gdImageCreateFromPngPtr (int size, void * data);
#
sub generate_create_from_data_functions
{
my @funcs = split( /\n/, shift );
my $sub = "generate_create_from_data_functions()";
foreach my $func ( @funcs )
{
#print "$sub: Generating read function for $func...\n";
IO/GD/GD.pd view on Meta::CPAN
RETVAL = $function_name( len, (void*)data );
OUTPUT:
RETVAL
ENDXS
}
} # End of generate_create_from_data_functions()...
#void gdImagePng (gdImagePtr im, FILE * out);
#void gdImageWBMP (gdImagePtr image, int fg, FILE * out);
sub generate_write_functions
{
my @funcs = split( /\n/, shift );
my $sub = "generate_write_functions()";
foreach my $func ( @funcs )
{
#print "$sub: Generating write function for $func...\n";
IO/GD/GD.pd view on Meta::CPAN
} # End of generate_write_functions()...
#
# The functions allow you to get a pointer to a formatted region of memory
# that contains image data in the specified format. This is useful, among
# other things, because PerlQt has almost no other way to import any image
# data from PDLA!
#
#void *gdImageWBMPPtr (gdImagePtr im, int *size, int fg);
#void *gdImageJpegPtr (gdImagePtr im, int *size, int quality);
#void *gdImagePngPtr (gdImagePtr im, int *size);
#void *gdImageGdPtr (gdImagePtr im, int *size);
#void *gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size);
#void *gdImagePngPtrEx (gdImagePtr im, int *size, int level);
#
sub generate_data_ptr_functions
{
my @funcs = split( /\n/, shift );
my $sub = "generate_data_ptr_functions()";
foreach my $func ( @funcs )
{
#print "$sub: Generating data_ptr function for $func...\n";
my $info = parse_prototype( $func )
t/gd_oo_tests.t view on Meta::CPAN
# TEST 17:
# Generate a color bar:
my $x1 = zeroes( long, 256 ) + 50;
my $y1 = sequence( long, 256 ) + 30;
my $color = sequence(long, 256);
$im->Lines( $x1, $y1, $x1 + 100, $y1, $color );
ok( 1, 'generate a color bar' );
# TEST 18:
# Write the output file:
$im->write_Png( $testfile2 );
ok( 1, 'write the output file' );
$im->DESTROY(); $im = undef;
#
# New tests on object creation:
#
# TEST 19:
# Create from a 2d PDLA without a LUT:
my $pic = sequence(100, 100);
t/gd_oo_tests.t view on Meta::CPAN
ok( $rc , 'testfile3 successfully opened');
binmode( TF3 );
$/ = undef;
my $blob3d = <TF3>;
close( TF3 );
$im = PDLA::IO::GD->new({ data => $blob3d });
ok( defined( $im ), 'create from a 3d PNG data glob' );
# TEST 28:
# Get a PNG data glob from a created
my $png_blob = $im->get_Png_data();
ok( $blob3d eq $png_blob, 'get a PNG data glob' );
$im->DESTROY(); $im = undef;
# TEST 29:
# Try a nicer way to make an object. Just pass in a filename:
my $gd_new_just_filename = PDLA::IO::GD->new( $testfile1 );
ok( defined( $gd_new_just_filename ), 'initialize an object from JUST the filename' );
# TEST 30:
# Try another nicer way to make an object: Pass in an inline hash:
( run in 1.498 second using v1.01-cache-2.11-cpan-0a6323c29d9 )