package Imager;
+use 5.006;
use strict;
-use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS %formats $DEBUG %filters %DSOs $ERRSTR %OPCODES $I2P $FORMATGUESS $warn_obsolete);
use IO::File;
-
+use Scalar::Util;
use Imager::Color;
use Imager::Font;
+use Config;
+
+our $ERRSTR;
-@EXPORT_OK = qw(
+our @EXPORT_OK = qw(
init
init_log
DSO_open
NCF
);
-@EXPORT=qw(
+our @EXPORT=qw(
);
-%EXPORT_TAGS=
+our %EXPORT_TAGS=
(handy => [qw(
newfont
newcolor
# this will be used to store global defaults at some point
my %defaults;
+our $VERSION;
+
BEGIN {
require Exporter;
my $ex_version = eval $Exporter::VERSION;
if ($ex_version < 5.57) {
- @ISA = qw(Exporter);
+ our @ISA = qw(Exporter);
}
- $VERSION = '0.93';
+ $VERSION = '1.011';
require XSLoader;
XSLoader::load(Imager => $VERSION);
}
t1 => "Imager::Font::T1",
);
+our %formats;
+
tie %formats, "Imager::FORMATS", \%formats_low, \%format_classes;
+our %filters;
+
+our $DEBUG;
+our %OPCODES;
+our $FORMATGUESS;
+our $warn_obsolete;
+
BEGIN {
for(i_list_formats()) { $formats_low{$_}++; }
callsub => sub { my %hsh=@_; i_hardinvertall($hsh{image}); }
};
- $filters{autolevels} ={
+ $filters{autolevels_skew} ={
callseq => ['image','lsat','usat','skew'],
defaults => { lsat=>0.1,usat=>0.1,skew=>0.0 },
callsub => sub { my %hsh=@_; i_autolevels($hsh{image},$hsh{lsat},$hsh{usat},$hsh{skew}); }
};
+ $filters{autolevels} ={
+ callseq => ['image','lsat','usat'],
+ defaults => { lsat=>0.1,usat=>0.1 },
+ callsub => sub { my %hsh=@_; i_autolevels_mono($hsh{image},$hsh{lsat},$hsh{usat}); }
+ };
+
$filters{turbnoise} ={
callseq => ['image'],
defaults => { xo=>0.0,yo=>0.0,scale=>10.0 },
defaults => { },
callsub => sub { my %hsh = @_; i_gaussian($hsh{image}, $hsh{stddev}); },
};
+ $filters{gaussian2} = {
+ callseq => [ 'image', 'stddevX', 'stddevY' ],
+ defaults => { },
+ callsub => sub { my %hsh = @_; i_gaussian2($hsh{image}, $hsh{stddevX}, $hsh{stddevY}); },
+ };
$filters{mosaic} =
{
callseq => [ qw(image size) ],
# Non methods
#
-# initlize Imager
+# initialize Imager
# NOTE: this might be moved to an import override later on
sub import {
}
}
-# Load a filter plugin
+# Load a filter plugin
+
+our %DSOs;
sub load_plugin {
my ($filename)=@_;
my $i;
+
+ if ($^O eq 'android') {
+ require File::Spec;
+ $filename = File::Spec->rel2abs($filename);
+ }
+
my ($DSO_handle,$str)=DSO_open($filename);
if (!defined($DSO_handle)) { $Imager::ERRSTR="Couldn't load plugin '$filename'\n"; return undef; }
my %funcs=DSO_funclist($DSO_handle);
sub unload_plugin {
my ($filename)=@_;
+ if ($^O eq 'android') {
+ require File::Spec;
+ $filename = File::Spec->rel2abs($filename);
+ }
+
if (!$DSOs{$filename}) { $ERRSTR="plugin '$filename' not loaded."; return undef; }
my ($DSO_handle,$funcref)=@{$DSOs{$filename}};
for(keys %{$funcref}) {
sub _valid_image {
my ($self, $method) = @_;
- $self->{IMG} and return 1;
+ ref $self
+ or return Imager->_set_error("$method needs an image object");
+
+ $self->{IMG} && Scalar::Util::blessed($self->{IMG}) and return 1;
- my $msg = 'empty input image';
+ my $msg = $self->{IMG} ? "images do not cross threads" : "empty input image";
$msg = "$method: $msg" if $method;
$self->_set_error($msg);
$self->{ERRSTR}=undef; #
$self->{DEBUG}=$DEBUG;
$self->{DEBUG} and print "Initialized Imager\n";
- if (defined $hsh{xsize} || defined $hsh{ysize}) {
- unless ($self->img_set(%hsh)) {
- $Imager::ERRSTR = $self->{ERRSTR};
- return;
- }
- }
- elsif (defined $hsh{file} ||
- defined $hsh{fh} ||
- defined $hsh{fd} ||
- defined $hsh{callback} ||
- defined $hsh{readcb} ||
- defined $hsh{data}) {
+ if (defined $hsh{file} ||
+ defined $hsh{fh} ||
+ defined $hsh{fd} ||
+ defined $hsh{callback} ||
+ defined $hsh{readcb} ||
+ defined $hsh{data} ||
+ defined $hsh{io}) {
# allow $img = Imager->new(file => $filename)
my %extras;
return;
}
}
+ elsif (defined $hsh{xsize} || defined $hsh{ysize}) {
+ unless ($self->img_set(%hsh)) {
+ $Imager::ERRSTR = $self->{ERRSTR};
+ return;
+ }
+ }
+ elsif (%hsh) {
+ Imager->_set_error("new: supply xsize and ysize or a file access parameter or no parameters");
+ return;
+ }
return $self;
}
sub copy {
my $self = shift;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("copy")
+ or return;
unless (defined wantarray) {
my @caller = caller;
sub paste {
my $self = shift;
- unless ($self->{IMG}) {
- $self->_set_error('empty input image');
- return;
- }
+ $self->_valid_image("paste")
+ or return;
+
my %input=(left=>0, top=>0, src_minx => 0, src_miny => 0, @_);
my $src = $input{img} || $input{src};
unless($src) {
$self->_set_error("no source image");
return;
}
+ unless ($src->_valid_image("paste")) {
+ $self->{ERRSTR} = $src->{ERRSTR} . " (for src)";
+ return;
+ }
$input{left}=0 if $input{left} <= 0;
$input{top}=0 if $input{top} <= 0;
sub crop {
my $self=shift;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("crop")
+ or return;
unless (defined wantarray) {
my @caller = caller;
sub _sametype {
my ($self, %opts) = @_;
- $self->{IMG} or return $self->_set_error("Not a valid image");
+ $self->_valid_image
+ or return;
my $x = $opts{xsize} || $self->getwidth;
my $y = $opts{ysize} || $self->getheight;
# Sets an image to a certain size and channel number
# if there was previously data in the image it is discarded
+my %model_channels =
+ (
+ gray => 1,
+ graya => 2,
+ rgb => 3,
+ rgba => 4,
+ );
+
sub img_set {
my $self=shift;
my %hsh=(xsize=>100, ysize=>100, channels=>3, bits=>8, type=>'direct', @_);
- if (defined($self->{IMG})) {
- # let IIM_DESTROY destroy it, it's possible this image is
- # referenced from a virtual image (like masked)
- #i_img_destroy($self->{IMG});
- undef($self->{IMG});
+ undef($self->{IMG});
+
+ if ($hsh{model}) {
+ if (my $channels = $model_channels{$hsh{model}}) {
+ $hsh{channels} = $channels;
+ }
+ else {
+ $self->_set_error("new: unknown value for model '$hsh{model}'");
+ return;
+ }
}
if ($hsh{type} eq 'paletted' || $hsh{type} eq 'pseudo') {
}
unless ($self->{IMG}) {
- $self->{ERRSTR} = Imager->_error_as_msg();
+ $self->_set_error(Imager->_error_as_msg());
return;
}
sub masked {
my $self = shift;
- $self or return undef;
+ $self->_valid_image("masked")
+ or return;
+
my %opts = (left => 0,
top => 0,
right => $self->getwidth,
return;
}
- $self->_valid_image
+ $self->_valid_image("to_paletted")
or return;
my $result = Imager->new;
++$index;
}
- return i_img_make_palette($quant, map $_->{IMG}, @images);
+ my @cols = i_img_make_palette($quant, map $_->{IMG}, @images);
+ unless (@cols) {
+ Imager->_set_error(Imager->_error_as_msg);
+ return;
+ }
+ return @cols;
}
# convert a paletted (or any image) to an 8-bit/channel RGB image
return;
}
- $self->_valid_image
+ $self->_valid_image("to_rgb8")
or return;
my $result = Imager->new;
return;
}
- $self->_valid_image
+ $self->_valid_image("to_rgb16")
or return;
my $result = Imager->new;
return;
}
- $self->_valid_image
+ $self->_valid_image("to_rgb_double")
or return;
my $result = Imager->new;
my $self = shift;
my %opts = (colors=>[], @_);
- unless ($self->{IMG}) {
- $self->_set_error("empty input image");
- return;
- }
+ $self->_valid_image("addcolors")
+ or return -1;
my @colors = @{$opts{colors}}
or return undef;
my $self = shift;
my %opts = (start=>0, colors=>[], @_);
- unless ($self->{IMG}) {
- $self->_set_error("empty input image");
- return;
- }
+ $self->_valid_image("setcolors")
+ or return;
my @colors = @{$opts{colors}}
or return undef;
sub getcolors {
my $self = shift;
my %opts = @_;
+
+ $self->_valid_image("getcolors")
+ or return;
+
if (!exists $opts{start} && !exists $opts{count}) {
# get them all
$opts{start} = 0;
elsif (!exists $opts{start}) {
$opts{start} = 0;
}
-
- $self->{IMG} and
- return i_getcolors($self->{IMG}, $opts{start}, $opts{count});
+
+ return i_getcolors($self->{IMG}, $opts{start}, $opts{count});
}
sub colorcount {
- i_colorcount($_[0]{IMG});
+ my ($self) = @_;
+
+ $self->_valid_image("colorcount")
+ or return -1;
+
+ return i_colorcount($self->{IMG});
}
sub maxcolors {
- i_maxcolors($_[0]{IMG});
+ my $self = shift;
+
+ $self->_valid_image("maxcolors")
+ or return -1;
+
+ i_maxcolors($self->{IMG});
}
sub findcolor {
my $self = shift;
my %opts = @_;
- $opts{color} or return undef;
- $self->{IMG} and i_findcolor($self->{IMG}, $opts{color});
+ $self->_valid_image("findcolor")
+ or return;
+
+ unless ($opts{color}) {
+ $self->_set_error("findcolor: no color parameter");
+ return;
+ }
+
+ my $color = _color($opts{color})
+ or return;
+
+ return i_findcolor($self->{IMG}, $color);
}
sub bits {
my $self = shift;
- my $bits = $self->{IMG} && i_img_bits($self->{IMG});
+
+ $self->_valid_image("bits")
+ or return;
+
+ my $bits = i_img_bits($self->{IMG});
if ($bits && $bits == length(pack("d", 1)) * 8) {
$bits = 'double';
}
- $bits;
+ return $bits;
}
sub type {
my $self = shift;
- if ($self->{IMG}) {
- return i_img_type($self->{IMG}) ? "paletted" : "direct";
- }
+
+ $self->_valid_image("type")
+ or return;
+
+ return i_img_type($self->{IMG}) ? "paletted" : "direct";
}
sub virtual {
my $self = shift;
- $self->{IMG} and i_img_virtual($self->{IMG});
+
+ $self->_valid_image("virtual")
+ or return;
+
+ return i_img_virtual($self->{IMG});
}
sub is_bilevel {
my ($self) = @_;
- $self->{IMG} or return;
+ $self->_valid_image("is_bilevel")
+ or return;
return i_img_is_monochrome($self->{IMG});
}
sub tags {
my ($self, %opts) = @_;
- $self->{IMG} or return;
+ $self->_valid_image("tags")
+ or return;
if (defined $opts{name}) {
my @result;
my $self = shift;
my %opts = @_;
- return -1 unless $self->{IMG};
+ $self->_valid_image("addtag")
+ or return;
+
if ($opts{name}) {
if (defined $opts{value}) {
if ($opts{value} =~ /^\d+$/) {
my $self = shift;
my %opts = @_;
- return 0 unless $self->{IMG};
+ $self->_valid_image("deltag")
+ or return 0;
if (defined $opts{'index'}) {
return i_tags_delete($self->{IMG}, $opts{'index'});
sub settag {
my ($self, %opts) = @_;
+ $self->_valid_image("settag")
+ or return;
+
if ($opts{name}) {
$self->deltag(name=>$opts{name});
return $self->addtag(name=>$opts{name}, value=>$opts{value});
return io_new_fd($input->{fd});
}
elsif ($input->{fh}) {
- my $fd = fileno($input->{fh});
- unless (defined $fd) {
+ unless (Scalar::Util::openhandle($input->{fh})) {
$self->_set_error("Handle in fh option not opened");
return;
}
- return io_new_fd($fd);
+ return Imager::IO->new_fh($input->{fh});
}
elsif ($input->{file}) {
my $file = IO::File->new($input->{file}, "r");
$io = io_new_fd($input->{fd});
}
elsif ($input->{fh}) {
- my $fd = fileno($input->{fh});
- unless (defined $fd) {
+ unless (Scalar::Util::openhandle($input->{fh})) {
$self->_set_error("Handle in fh option not opened");
return;
}
- # flush it
- my $oldfh = select($input->{fh});
- # flush anything that's buffered, and make sure anything else is flushed
- $| = 1;
- select($oldfh);
- $io = io_new_fd($fd);
+ $io = Imager::IO->new_fh($input->{fh});
}
elsif ($input->{file}) {
my $fh = new IO::File($input->{file},"w+");
return ($io, @extras);
}
+sub _test_format {
+ my ($io) = @_;
+
+ return i_test_format_probe($io, -1);
+}
+
+sub add_file_magic {
+ my ($class, %opts) = @_;
+
+ my $name = delete $opts{name};
+ my $bits = delete $opts{bits};
+ my $mask = delete $opts{mask};
+
+ unless (i_add_file_magic($name, $bits, $mask)) {
+ Imager->_set_error(Imager->_error_as_msg);
+ return;
+ }
+
+ 1;
+}
+
# Read an image from file
sub read {
my $type = $input{'type'};
unless ($type) {
- $type = i_test_format_probe($IO, -1);
+ $type = _test_format($IO);
}
if ($input{file} && !$type) {
else {
local $SIG{__DIE__};
my $loaded = eval {
+ local @INC = @INC;
+ pop @INC if $INC[-1] eq '.';
++$attempted_to_load{$file};
require $file;
return 1;
fax_fine=>1, @_);
my $rc;
+ $self->_valid_image("write")
+ or return;
+
$self->_set_opts(\%input, "i_", $self)
or return undef;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
-
my $type = $input{'type'};
if (!$type and $input{file}) {
$type = $FORMATGUESS->($input{file});
return;
}
# translate to ImgRaw
- if (grep !UNIVERSAL::isa($_, 'Imager') || !$_->{IMG}, @images) {
- $class->_set_error('Usage: Imager->write_multi({ options }, @images)');
- return 0;
+ my $index = 1;
+ for my $img (@images) {
+ unless (ref $img && Scalar::Util::blessed($img) && $img->isa("Imager")) {
+ $class->_set_error("write_multi: image $index is not an Imager image object");
+ return;
+ }
+ unless ($img->_valid_image("write_multi")) {
+ $class->_set_error($img->errstr . " (image $index)");
+ return;
+ }
+ ++$index;
}
$class->_set_opts($opts, "i_", @images)
or return;
my $type = $opts{'type'};
unless ($type) {
- $type = i_test_format_probe($IO, -1);
+ $type = _test_format($IO);
}
if ($opts{file} && !$type) {
my $self=shift;
my %input=@_;
my %hsh;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("filter")
+ or return;
if (!$input{'type'}) { $self->{ERRSTR}='type parameter missing'; return undef; }
return;
}
- unless ($self->{IMG}) {
- $self->_set_error('empty input image');
- return undef;
- }
+ $self->_valid_image("scale")
+ or return;
my ($x_scale, $y_scale, $new_width, $new_height) =
$self->scale_calculate(%opts)
return;
}
- unless ($self->{IMG}) {
- $self->{ERRSTR} = 'empty input image';
- return undef;
- }
+ $self->_valid_image("scaleX")
+ or return;
my $img = Imager->new();
return;
}
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+ $self->_valid_image("scaleY")
+ or return;
my $img = Imager->new();
# NOTE - should make a utility function to check transforms for
# stack overruns
+our $I2P;
+
sub transform {
my $self=shift;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
my %opts=@_;
my (@op,@ropx,@ropy,$iop,$or,@parm,$expr,@xt,@yt,@pt,$numre);
# print Dumper(\%opts);
# xopcopdes
+ $self->_valid_image("transform")
+ or return;
+
if ( $opts{'xexpr'} and $opts{'yexpr'} ) {
if (!$I2P) {
- eval ("use Affix::Infix2Postfix;");
- print $@;
+ {
+ local @INC = @INC;
+ pop @INC if $INC[-1] eq '.';
+ eval ("use Affix::Infix2Postfix;");
+ }
+
if ( $@ ) {
$self->{ERRSTR}='transform: expr given and Affix::Infix2Postfix is not avaliable.';
return undef;
$opts->{variables} = [ qw(x y) ];
my ($width, $height) = @{$opts}{qw(width height)};
if (@imgs) {
+ my $index = 1;
+ for my $img (@imgs) {
+ unless ($img->_valid_image("transform2")) {
+ Imager->_set_error($img->errstr . " (input image $index)");
+ return;
+ }
+ ++$index;
+ }
+
$width ||= $imgs[0]->getwidth();
$height ||= $imgs[0]->getheight();
my $img_num = 1;
my $self=shift;
my %opts= @_;
- unless ($self->{IMG}) {
- $self->{ERRSTR}='empty input image';
- return undef;
- }
- unless ($opts{src} && $opts{src}->{IMG}) {
- $self->{ERRSTR}='empty input image for src';
- return undef;
+ $self->_valid_image("rubthrough")
+ or return;
+
+ unless ($opts{src} && $opts{src}->_valid_image("rubthrough")) {
+ $self->{ERRSTR} = $opts{src}{ERRSTR} . ' (for src)';
+ return;
}
%opts = (src_minx => 0,
@_
);
- unless ($self->{IMG}) {
- $self->_set_error("compose: empty input image");
- return;
- }
+ $self->_valid_image("compose")
+ or return;
unless ($opts{src}) {
$self->_set_error("compose: src parameter missing");
return;
}
- unless ($opts{src}{IMG}) {
- $self->_set_error("compose: src parameter empty image");
+ unless ($opts{src}->_valid_image("compose")) {
+ $self->_set_error($opts{src}->errstr . " (for src)");
return;
}
my $src = $opts{src};
my $combine = $self->_combine($opts{combine}, 'normal');
if ($opts{mask}) {
- unless ($opts{mask}{IMG}) {
- $self->_set_error("compose: mask parameter empty image");
+ unless ($opts{mask}->_valid_image("compose")) {
+ $self->_set_error($opts{mask}->errstr . " (for mask)");
return;
}
sub flip {
my $self = shift;
my %opts = @_;
+
+ $self->_valid_image("flip")
+ or return;
+
my %xlate = (h=>0, v=>1, hv=>2, vh=>2);
my $dir;
return () unless defined $opts{'dir'} and defined $xlate{$opts{'dir'}};
return;
}
+ $self->_valid_image("rotate")
+ or return;
+
if (defined $opts{right}) {
my $degrees = $opts{right};
if ($degrees < 0) {
my $self = shift;
my %opts = @_;
+ $self->_valid_image("matrix_transform")
+ or return;
+
unless (defined wantarray) {
my @caller = caller;
warn "copy() called in void context - copy() returns the copied image at $caller[1] line $caller[2]\n";
my $self=shift;
my $raw = $self->{IMG};
- unless ($raw) {
- $self->{ERRSTR}='empty input image';
- return undef;
- }
+ $self->_valid_image("box")
+ or return;
my %opts = @_;
sub arc {
my $self=shift;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("arc")
+ or return;
+
my $dflcl= [ 255, 255, 255, 255];
my $good = 1;
my %opts=
return;
}
}
- i_arc_aa_cfill($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},$opts{'d1'},
- $opts{'d2'}, $opts{fill}{fill});
+ if ($opts{d1} == 0 && $opts{d2} == 361) {
+ i_circle_aa_fill($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{'r'},
+ $opts{fill}{fill});
+ }
+ else {
+ i_arc_aa_cfill($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},$opts{'d1'},
+ $opts{'d2'}, $opts{fill}{fill});
+ }
}
elsif ($opts{filled}) {
my $color = _color($opts{'color'});
my %opts=(color=>$dflcl,
endp => 1,
@_);
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("line")
+ or return;
unless (exists $opts{x1} and exists $opts{y1}) { $self->{ERRSTR}='missing begining coord'; return undef; }
unless (exists $opts{x2} and exists $opts{y2}) { $self->{ERRSTR}='missing ending coord'; return undef; }
my $dflcl=i_color_new(0,0,0,0);
my %opts=(color=>$dflcl,@_);
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+ $self->_valid_image("polyline")
+ or return;
if (exists($opts{points})) { @points=@{$opts{points}}; }
if (!exists($opts{points}) and exists($opts{'x'}) and exists($opts{'y'}) ) {
my $dflcl = i_color_new(0,0,0,0);
my %opts = (color=>$dflcl, @_);
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+ $self->_valid_image("polygon")
+ or return;
if (exists($opts{points})) {
$opts{'x'} = [ map { $_->[0] } @{$opts{points}} ];
$self->{ERRSTR} = 'no points array, or x and y arrays.'; return undef;
}
+ my $mode = _first($opts{mode}, 0);
+
if ($opts{'fill'}) {
unless (UNIVERSAL::isa($opts{'fill'}, 'Imager::Fill')) {
# assume it's a hash ref
return undef;
}
}
- i_poly_aa_cfill($self->{IMG}, $opts{'x'}, $opts{'y'},
- $opts{'fill'}{'fill'});
+ unless (i_poly_aa_cfill_m($self->{IMG}, $opts{'x'}, $opts{'y'},
+ $mode, $opts{'fill'}{'fill'})) {
+ return $self->_set_error($self->_error_as_msg);
+ }
}
else {
my $color = _color($opts{'color'});
unless ($color) {
$self->{ERRSTR} = $Imager::ERRSTR;
- return;
+ return;
+ }
+ unless (i_poly_aa_m($self->{IMG}, $opts{'x'}, $opts{'y'}, $mode, $color)) {
+ return $self->_set_error($self->_error_as_msg);
}
- i_poly_aa($self->{IMG}, $opts{'x'}, $opts{'y'}, $color);
}
return $self;
}
+sub polypolygon {
+ my ($self, %opts) = @_;
+
+ $self->_valid_image("polypolygon")
+ or return;
+
+ my $points = $opts{points};
+ $points
+ or return $self->_set_error("polypolygon: missing required points");
+
+ my $mode = _first($opts{mode}, "evenodd");
+
+ if ($opts{filled}) {
+ my $color = _color(_first($opts{color}, [ 0, 0, 0, 0 ]))
+ or return $self->_set_error($Imager::ERRSTR);
+
+ i_poly_poly_aa($self->{IMG}, $points, $mode, $color)
+ or return $self->_set_error($self->_error_as_msg);
+ }
+ elsif ($opts{fill}) {
+ my $fill = $opts{fill};
+ $self->_valid_fill($fill, "polypolygon")
+ or return;
+
+ i_poly_poly_aa_cfill($self->{IMG}, $points, $mode, $fill->{fill})
+ or return $self->_set_error($self->_error_as_msg);
+ }
+ else {
+ my $color = _color(_first($opts{color}, [ 0, 0, 0, 255 ]))
+ or return $self->_set_error($Imager::ERRSTR);
+
+ my $rimg = $self->{IMG};
+
+ if (_first($opts{aa}, 1)) {
+ for my $poly (@$points) {
+ my $xp = $poly->[0];
+ my $yp = $poly->[1];
+ for my $i (0 .. $#$xp - 1) {
+ i_line_aa($rimg, $xp->[$i], $yp->[$i], $xp->[$i+1], $yp->[$i+1],
+ $color, 0);
+ }
+ i_line_aa($rimg, $xp->[$#$xp], $yp->[$#$yp], $xp->[0], $yp->[0],
+ $color, 0);
+ }
+ }
+ else {
+ for my $poly (@$points) {
+ my $xp = $poly->[0];
+ my $yp = $poly->[1];
+ for my $i (0 .. $#$xp - 1) {
+ i_line($rimg, $xp->[$i], $yp->[$i], $xp->[$i+1], $yp->[$i+1],
+ $color, 0);
+ }
+ i_line($rimg, $xp->[$#$xp], $yp->[$#$yp], $xp->[0], $yp->[0],
+ $color, 0);
+ }
+ }
+ }
+
+ return $self;
+}
# this the multipoint bezier curve
# this is here more for testing that actual usage since
my $dflcl=i_color_new(0,0,0,0);
my %opts=(color=>$dflcl,@_);
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+ $self->_valid_image("polybezier")
+ or return;
if (exists $opts{points}) {
$opts{'x'}=map { $_->[0]; } @{$opts{'points'}};
my %opts = ( color=>Imager::Color->new(255, 255, 255), @_ );
my $rc;
+ $self->_valid_image("flood_fill")
+ or return;
+
unless (exists $opts{'x'} && exists $opts{'y'}) {
$self->{ERRSTR} = "missing seed x and y parameters";
return undef;
else {
if ($color->isa('Imager::Color')) {
i_ppix($self->{IMG}, $x, $y, $color)
- and return;
+ and return "0 but true";
}
else {
i_ppixf($self->{IMG}, $x, $y, $color)
- and return;
+ and return "0 but true";
}
- }
- return $self;
+ return 1;
+ }
}
sub getpixel {
my $self = shift;
my %opts = ( type => '8bit', x=>0, @_);
- $self->_valid_image or return;
+ $self->_valid_image("getscanline")
+ or return;
defined $opts{width} or $opts{width} = $self->getwidth - $opts{x};
my $self = shift;
my %opts = ( x=>0, @_);
- $self->_valid_image or return;
+ $self->_valid_image("setscanline")
+ or return;
unless (defined $opts{'y'}) {
$self->_set_error("missing y parameter");
my $self = shift;
my %opts = ( type => '8bit', x=>0, offset => 0, @_);
+ $self->_valid_image("getsamples")
+ or return;
+
defined $opts{width} or $opts{width} = $self->getwidth - $opts{x};
unless (defined $opts{'y'}) {
sub setsamples {
my $self = shift;
- unless ($self->{IMG}) {
- $self->_set_error('setsamples: empty input image');
- return;
- }
+ $self->_valid_image("setsamples")
+ or return;
my %opts = ( x => 0, offset => 0 );
my $data_index;
my ($self, %opts) = @_;
my $matrix;
+ $self->_valid_image("convert")
+ or return;
+
unless (defined wantarray) {
my @caller = caller;
warn "convert() called in void context - convert() returns the converted image at $caller[1] line $caller[2]\n";
$class->_set_error("src must contain image objects");
return;
}
- unless ($img->{IMG}) {
- $class->_set_error("empty input image");
+ unless ($img->_valid_image("combine")) {
+ $Imager::ERRSTR = $img->{ERRSTR} . " (src->[$index])";
return;
}
push @imgs, $img->{IMG};
my ($self, %opts) = @_;
my @chlist = qw( red green blue alpha );
+ $self->_valid_image("map")
+ or return;
+
if (!exists($opts{'maps'})) {
# make maps from channel maps
my $chnum;
sub difference {
my ($self, %opts) = @_;
+ $self->_valid_image("difference")
+ or return;
+
defined $opts{mindist} or $opts{mindist} = 0;
defined $opts{other}
or return $self->_set_error("No 'other' parameter supplied");
- defined $opts{other}{IMG}
- or return $self->_set_error("No image data in 'other' image");
-
- $self->{IMG}
- or return $self->_set_error("No image data");
+ unless ($opts{other}->_valid_image("difference")) {
+ $self->_set_error($opts{other}->errstr . " (other image)");
+ return;
+ }
my $result = Imager->new;
$result->{IMG} = i_diff_image($self->{IMG}, $opts{other}{IMG},
sub getwidth {
my $self = shift;
- if (my $raw = $self->{IMG}) {
- return i_img_get_width($raw);
- }
- else {
- $self->{ERRSTR} = 'image is empty'; return undef;
- }
+ $self->_valid_image("getwidth")
+ or return;
+
+ return i_img_get_width($self->{IMG});
}
# Get the height of an image
sub getheight {
my $self = shift;
- if (my $raw = $self->{IMG}) {
- return i_img_get_height($raw);
- }
- else {
- $self->{ERRSTR} = 'image is empty'; return undef;
- }
+ $self->_valid_image("getheight")
+ or return;
+
+ return i_img_get_height($self->{IMG});
}
# Get number of channels in an image
sub getchannels {
my $self = shift;
- if (!defined($self->{IMG})) { $self->{ERRSTR} = 'image is empty'; return undef; }
+
+ $self->_valid_image("getchannels")
+ or return;
+
return i_img_getchannels($self->{IMG});
}
+my @model_names = qw(unknown gray graya rgb rgba);
+
+sub colormodel {
+ my ($self, %opts) = @_;
+
+ $self->_valid_image("colormodel")
+ or return;
+
+ my $model = i_img_color_model($self->{IMG});
+
+ return $opts{numeric} ? $model : $model_names[$model];
+}
+
+sub colorchannels {
+ my ($self) = @_;
+
+ $self->_valid_image("colorchannels")
+ or return;
+
+ return i_img_color_channels($self->{IMG});
+}
+
+sub alphachannel {
+ my ($self) = @_;
+
+ $self->_valid_image("alphachannel")
+ or return;
+
+ return scalar(i_img_alpha_channel($self->{IMG}));
+}
+
# Get channel mask
sub getmask {
my $self = shift;
- if (!defined($self->{IMG})) { $self->{ERRSTR} = 'image is empty'; return undef; }
+
+ $self->_valid_image("getmask")
+ or return;
+
return i_img_getmask($self->{IMG});
}
sub setmask {
my $self = shift;
my %opts = @_;
- if (!defined($self->{IMG})) {
- $self->{ERRSTR} = 'image is empty';
- return undef;
- }
+
+ $self->_valid_image("setmask")
+ or return;
+
unless (defined $opts{mask}) {
$self->_set_error("mask parameter required");
return;
}
+
i_img_setmask( $self->{IMG} , $opts{mask} );
1;
sub getcolorcount {
my $self=shift;
my %opts=('maxcolors'=>2**30,@_);
- if (!defined($self->{IMG})) { $self->{ERRSTR}='image is empty'; return undef; }
+
+ $self->_valid_image("getcolorcount")
+ or return;
+
my $rc=i_count_colors($self->{IMG},$opts{'maxcolors'});
return ($rc==-1? undef : $rc);
}
# values are the number of pixels in this colour.
sub getcolorusagehash {
my $self = shift;
-
+
+ $self->_valid_image("getcolorusagehash")
+ or return;
+
my %opts = ( maxcolors => 2**30, @_ );
my $max_colors = $opts{maxcolors};
unless (defined $max_colors && $max_colors > 0) {
return;
}
- unless (defined $self->{IMG}) {
- $self->_set_error('empty input image');
- return;
- }
-
my $channels= $self->getchannels;
# We don't want to look at the alpha channel, because some gifs using it
# doesn't define it for every colour (but only for some)
sub getcolorusage {
my $self = shift;
+ $self->_valid_image("getcolorusage")
+ or return;
+
my %opts = ( maxcolors => 2**30, @_ );
my $max_colors = $opts{maxcolors};
unless (defined $max_colors && $max_colors > 0) {
return;
}
- unless (defined $self->{IMG}) {
- $self->_set_error('empty input image');
- return undef;
- }
-
return i_get_anonymous_color_histo($self->{IMG}, $max_colors);
}
sub string {
my $self = shift;
- unless ($self->{IMG}) { $self->{ERRSTR}='empty input image'; return undef; }
+
+ $self->_valid_image("string")
+ or return;
my %input=('x'=>0, 'y'=>0, @_);
defined($input{string}) or $input{string} = $input{text};
my $img;
if (ref $self) {
- unless ($self->{IMG}) {
- $self->{ERRSTR}='empty input image';
- return;
- }
+ $self->_valid_image("align_string")
+ or return;
+
$img = $self;
}
else {
# Default guess for the type of an image from extension
-my @simple_types = qw(png tga gif raw ico cur xpm mng jng ilbm pcx psd eps);
+my @simple_types = qw(png tga gif raw ico cur xpm mng jng ilbm pcx psd eps webp xwd xpm dng ras);
my %ext_types =
(
return $type;
}
+sub add_type_extensions {
+ my ($class, $type, @exts) = @_;
+
+ for my $ext (@exts) {
+ exists $ext_types{lc $ext} or $ext_types{lc $ext} = lc $type;
+ }
+ 1;
+}
+
sub combines {
return @combine_types;
}
}
sub Inline {
- my ($lang) = @_;
+ # Inline added a new argument at the beginning
+ my $lang = $_[-1];
$lang eq 'C'
or die "Only C language supported";
# - something for Module::ScanDeps to analyze
# https://rt.cpan.org/Ticket/Display.html?id=6566
local $@;
+ local @INC = @INC;
+ pop @INC if $INC[-1] eq '.';
eval { require Imager::File::GIF };
eval { require Imager::File::JPEG };
eval { require Imager::File::PNG };
eval { require Imager::Font::W32 };
eval { require Imager::Font::FT2 };
eval { require Imager::Font::T1 };
+ eval { require Imager::Color::Table };
+
+ 1;
+}
+
+package Imager::IO;
+use IO::Seekable;
+
+sub new_fh {
+ my ($class, $fh) = @_;
+
+ if (tied(*$fh)) {
+ return $class->new_cb
+ (
+ sub {
+ local $\;
+
+ return print $fh $_[0];
+ },
+ sub {
+ my $tmp;
+ my $count = CORE::read $fh, $tmp, $_[1];
+ defined $count
+ or return undef;
+ $count
+ or return "";
+ return $tmp;
+ },
+ sub {
+ if ($_[1] != SEEK_CUR || $_[0] != 0) {
+ unless (CORE::seek $fh, $_[0], $_[1]) {
+ return -1;
+ }
+ }
+
+ return tell $fh;
+ },
+ undef,
+ );
+ }
+ else {
+ return $class->_new_perlio($fh);
+ }
}
# backward compatibility for %formats
=item *
+L<Imager::Install> - installation notes for Imager.
+
+=item *
+
L<Imager::Tutorial> - a brief introduction to Imager.
=item *
=item *
+L<Imager::IO> - Imager I/O abstraction.
+
+=item *
+
L<Imager::API> - using Imager's C API
=item *
L<Imager::Security> - brief security notes.
+=item *
+
+L<Imager::Threads> - brief information on working with threads.
+
=back
=head2 Basic Overview
addcolors() - L<Imager::ImageTypes/addcolors()> - add colors to a
paletted image
+add_file_magic() - L<Imager::Files/add_file_magic()> - add magic to
+Imager's file type detector.
+
addtag() - L<Imager::ImageTypes/addtag()> - add image tags
+add_type_extensions() - L<Imager::Files/add_file_magic()> - add magic
+for new image file types.
+
+L<Imager::Files/add_type_extensions($type, $ext, ...)> - add extensions for
+new image file types.
+
align_string() - L<Imager::Draw/align_string()> - draw text aligned on a
point
+alphachannel() - L<Imager::ImageTypes/alphachannel()> - return the
+channel index of the alpha channel (if any).
+
arc() - L<Imager::Draw/arc()> - draw a filled arc
bits() - L<Imager::ImageTypes/bits()> - number of bits per sample for the
close_log() - L<Imager::ImageTypes/close_log()> - close the Imager
debugging log.
+colorchannels() - L<Imager::ImageTypes/colorchannels()> - the number
+of channels used for color.
+
colorcount() - L<Imager::ImageTypes/colorcount()> - the number of
colors in an image's palette (paletted images only)
+colormodel() - L<Imager::ImageTypes/colorcount()> - how color is
+represented.
+
combine() - L<Imager::Transformations/combine()> - combine channels
from one or more images.
polyline() - L<Imager::Draw/polyline()>
+polypolygon() - L<Imager::Draw/polypolygon()>
+
preload() - L<Imager::Files/preload()>
read() - L<Imager::Files/read()> - read a single image from an image file
blend - alpha blending one image onto another
L<Imager::Transformations/rubthrough()>
-blur - L<Imager::Filters/gaussian>, L<Imager::Filters/conv>
+blur - L<< Imager::Filters/C<gaussian> >>, L<< Imager::Filters/C<conv> >>
boxes, drawing - L<Imager::Draw/box()>
compare images - L<Imager::Filters/"Image Difference">
-contrast - L<Imager::Filters/contrast>, L<Imager::Filters/autolevels>
+contrast - L<< Imager::Filters/C<contrast> >>, L<< Imager::Filters/C<autolevels> >>
-convolution - L<Imager::Filters/conv>
+convolution - L<< Imager::Filters/C<conv> >>
cropping - L<Imager::Transformations/crop()>
fonts, multiple master - L<Imager::Font/"MULTIPLE MASTER FONTS">
fountain fill - L<Imager::Fill/"Fountain fills">,
-L<Imager::Filters/fountain>, L<Imager::Fountain>,
-L<Imager::Filters/gradgen>
+L<< Imager::Filters/C<fountain> >>, L<Imager::Fountain>,
+L<< Imager::Filters/C<gradgen> >>
GIF files - L<Imager::Files/"GIF">
GIF files, animated - L<Imager::Files/"Writing an animated GIF">
gradient fill - L<Imager::Fill/"Fountain fills">,
-L<Imager::Filters/fountain>, L<Imager::Fountain>,
-L<Imager::Filters/gradgen>
+L<< Imager::Filters/C<fountain> >>, L<Imager::Fountain>,
+L<< Imager::Filters/C<gradgen> >>
gray scale, convert image to - L<Imager::Transformations/convert()>
-gaussian blur - L<Imager::Filters/gaussian>
+gaussian blur - L<< Imager::Filters/C<gaussian> >>, L<< Imager::Filters/C<gaussian2> >>
hatch fills - L<Imager::Fill/"Hatched fills">
ICO files - L<Imager::Files/"ICO (Microsoft Windows Icon) and CUR (Microsoft Windows Cursor)">
-invert image - L<Imager::Filters/hardinvert>,
-L<Imager::Filters/hardinvertall>
+invert image - L<< Imager::Filters/C<hardinvert> >>,
+L<< Imager::Filters/C<hardinvertall> >>
JPEG - L<Imager::Files/"JPEG">
metadata, image - L<Imager::ImageTypes/"Tags">, L<Image::ExifTool>
-mosaic - L<Imager::Filters/mosaic>
+mosaic - L<< Imager::Filters/C<mosaic> >>
-noise, filter - L<Imager::Filters/noise>
+noise, filter - L<< Imager::Filters/C<noise> >>
-noise, rendered - L<Imager::Filters/turbnoise>,
-L<Imager::Filters/radnoise>
+noise, rendered - L<< Imager::Filters/C<turbnoise> >>,
+L<< Imager::Filters/C<radnoise> >>
paste - L<Imager::Transformations/paste()>,
L<Imager::Transformations/rubthrough()>
=for stopwords posterize
-posterize - L<Imager::Filters/postlevels>
+posterize - L<< Imager::Filters/C<postlevels> >>
PNG files - L<Imager::Files>, L<Imager::Files/"PNG">
SGI files - L<Imager::Files/"SGI (RGB, BW)">
-sharpen - L<Imager::Filters/unsharpmask>, L<Imager::Filters/conv>
+sharpen - L<< Imager::Filters/C<unsharpmask> >>, L<< Imager::Filters/C<conv> >>
size, image - L<Imager::ImageTypes/getwidth()>,
L<Imager::ImageTypes/getheight()>
text, measuring - L<Imager::Font/bounding_box()>, L<Imager::Font::BBox>
-tiles, color - L<Imager::Filters/mosaic>
+threads - L<Imager::Threads>
+
+tiles, color - L<< Imager::Filters/C<mosaic> >>
transparent images - L<Imager::ImageTypes>,
L<Imager::Cookbook/"Transparent PNG">
=for stopwords unsharp
-unsharp mask - L<Imager::Filters/unsharpmask>
+unsharp mask - L<< Imager::Filters/C<unsharpmask> >>
-watermark - L<Imager::Filters/watermark>
+watermark - L<< Imager::Filters/C<watermark> >>
writing an image to a file - L<Imager::Files>
-=head1 THREADS
-
-Imager doesn't support perl threads.
-
-Imager has limited code to prevent double frees if you create images,
-colors etc, and then create a thread, but has no code to prevent two
-threads entering Imager's error handling code, and none is likely to
-be added.
-
=head1 SUPPORT
The best place to get help with Imager is the mailing list.
where you can also find the mailing list archive.
-You can report bugs by pointing your browser at:
+You can report bugs either via github at:
+
+=over
+
+L<https://github.com/tonycoz/imager/issues>
+
+=back
+
+or at:
=over
libraries, and any relevant code. If you have specific images that
cause the problems, please include those too.
-If you don't want to publish your email address on a mailing list you
-can use CPAN::Forum:
-
- http://www.cpanforum.com/dist/Imager
-
-You will need to register to post.
-
=head1 CONTRIBUTING TO IMAGER
=head2 Feedback
I like feedback.
-If you like or dislike Imager, you can add a public review of Imager
-at CPAN Ratings:
-
- http://cpanratings.perl.org/dist/Imager
-
-=for stopwords Bitcard
-
-This requires a Bitcard account (http://www.bitcard.org).
-
-You can also send email to the maintainer below.
+You can send email to the maintainer below.
If you send me a bug report via email, it will be copied to Request
Tracker.
To browse Imager's git repository:
- http://git.imager.perl.org/imager.git
+ https://github.com/tonycoz/imager.git
-or:
+To clone:
- https://github.com/tonycoz/imager
+ git clone git://github.com/tonycoz/imager.git
-To clone:
+Or you can create a fork as usual on github and submit a github pull
+request.
- git clone git://git.imager.perl.org/imager.git
+Patches can either be submitted as a github pull request or by using
+C<git format-patch>, for example, if you made your changes in a branch
+from master you might do:
-or:
+ git format-patch -k --stdout master >my-patch.txt
- git clone git://github.com/tonycoz/imager.git
+and then attach that to your bug report, either by adding it as an
+attachment in your email client, or by using the Request Tracker
+attachment mechanism.
=head1 AUTHOR
Other perl imaging modules include:
-L<GD>(3), L<Image::Magick>(3), L<Graphics::Magick>(3),
+L<GD>(3), L<Image::Magick>(3),
+L<Graphics::Magick|http://www.graphicsmagick.org/perl.html>(3),
L<Prima::Image>, L<IPA>.
For manipulating image metadata see L<Image::ExifTool>.
projects / imager.git / blobdiff