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;
@EXPORT_OK = qw(
init
i_color_set
i_color_info
- i_img_empty
- i_img_empty_ch
- i_img_exorcise
- i_img_destroy
-
i_img_info
i_img_setmask
if ($ex_version < 5.57) {
@ISA = qw(Exporter);
}
- $VERSION = '0.87';
- eval {
- require XSLoader;
- XSLoader::load(Imager => $VERSION);
- 1;
- } or do {
- require DynaLoader;
- push @ISA, 'DynaLoader';
- bootstrap Imager $VERSION;
- }
+ $VERSION = '0.94';
+ require XSLoader;
+ XSLoader::load(Imager => $VERSION);
}
my %formats_low;
}
sub _valid_image {
- my ($self) = @_;
+ my ($self, $method) = @_;
- $self->{IMG} and return 1;
+ $self->{IMG} && Scalar::Util::blessed($self->{IMG}) and return 1;
- $self->_set_error('empty input image');
+ my $msg = $self->{IMG} ? "images do not cross threads" : "empty input image";
+ $msg = "$method: $msg" if $method;
+ $self->_set_error($msg);
return;
}
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;
$self->{IMG} = i_img_16_new($hsh{xsize}, $hsh{ysize}, $hsh{channels});
}
else {
- $self->{IMG}=Imager::ImgRaw::new($hsh{'xsize'}, $hsh{'ysize'},
- $hsh{'channels'});
+ $self->{IMG}= i_img_8_new($hsh{'xsize'}, $hsh{'ysize'},
+ $hsh{'channels'});
}
unless ($self->{IMG}) {
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;
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 1;
}
else {
- my $work = $@ || "Unknown error loading $file";
+ my $work = $@ || "Unknown error";
chomp $work;
$work =~ s/\n?Compilation failed in require at .*Imager\.pm line .*\z//m;
$work =~ s/\n/\\n/g;
+ $work =~ s/\s*\.?\z/ loading $file/;
$file_load_errors{$file} = $work;
$$error = $work;
return 0;
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 ($img->_valid_image("write_multi")) {
+ $class->_set_error($img->errstr . " (image $index)");
+ return;
+ }
+ ++$index;
}
$class->_set_opts($opts, "i_", @images)
or return;
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();
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;");
$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) {
}
}
elsif (defined $opts{radians} || defined $opts{degrees}) {
- my $amount = $opts{radians} || $opts{degrees} * 3.1415926535 / 180;
+ my $amount = $opts{radians} || $opts{degrees} * 3.14159265358979 / 180;
my $back = $opts{back};
my $result = Imager->new;
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=
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}} ];
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;
sub setpixel {
my ($self, %opts) = @_;
+ $self->_valid_image("setpixel")
+ or return;
+
my $color = $opts{color};
unless (defined $color) {
$color = $self->{fg};
}
unless (ref $color && UNIVERSAL::isa($color, "Imager::Color")) {
- $color = _color($color)
- or return undef;
+ unless ($color = _color($color, 'setpixel')) {
+ $self->_set_error("setpixel: " . Imager->errstr);
+ return;
+ }
}
unless (exists $opts{'x'} && exists $opts{'y'}) {
- $self->{ERRSTR} = 'missing x and y parameters';
- return undef;
+ $self->_set_error('setpixel: missing x or y parameter');
+ return;
}
my $x = $opts{'x'};
my $y = $opts{'y'};
- if (ref $x && ref $y) {
- unless (@$x == @$y) {
- $self->{ERRSTR} = 'length of x and y mismatch';
+ if (ref $x || ref $y) {
+ $x = ref $x ? $x : [ $x ];
+ $y = ref $y ? $y : [ $y ];
+ unless (@$x) {
+ $self->_set_error("setpixel: x is a reference to an empty array");
return;
}
+ unless (@$y) {
+ $self->_set_error("setpixel: y is a reference to an empty array");
+ return;
+ }
+
+ # make both the same length, replicating the last element
+ if (@$x < @$y) {
+ $x = [ @$x, ($x->[-1]) x (@$y - @$x) ];
+ }
+ elsif (@$y < @$x) {
+ $y = [ @$y, ($y->[-1]) x (@$x - @$y) ];
+ }
+
my $set = 0;
if ($color->isa('Imager::Color')) {
- for my $i (0..$#{$opts{'x'}}) {
+ for my $i (0..$#$x) {
i_ppix($self->{IMG}, $x->[$i], $y->[$i], $color)
or ++$set;
}
}
else {
- for my $i (0..$#{$opts{'x'}}) {
+ for my $i (0..$#$x) {
i_ppixf($self->{IMG}, $x->[$i], $y->[$i], $color)
or ++$set;
}
}
- $set or return;
+
return $set;
}
else {
}
}
- $self;
+ return $self;
}
sub getpixel {
my %opts = ( "type"=>'8bit', @_);
+ $self->_valid_image("getpixel")
+ or return;
+
unless (exists $opts{'x'} && exists $opts{'y'}) {
- $self->{ERRSTR} = 'missing x and y parameters';
- return undef;
+ $self->_set_error('getpixel: missing x or y parameter');
+ return;
}
my $x = $opts{'x'};
my $y = $opts{'y'};
- if (ref $x && ref $y) {
- unless (@$x == @$y) {
- $self->{ERRSTR} = 'length of x and y mismatch';
- return undef;
+ my $type = $opts{'type'};
+ if (ref $x || ref $y) {
+ $x = ref $x ? $x : [ $x ];
+ $y = ref $y ? $y : [ $y ];
+ unless (@$x) {
+ $self->_set_error("getpixel: x is a reference to an empty array");
+ return;
}
+ unless (@$y) {
+ $self->_set_error("getpixel: y is a reference to an empty array");
+ return;
+ }
+
+ # make both the same length, replicating the last element
+ if (@$x < @$y) {
+ $x = [ @$x, ($x->[-1]) x (@$y - @$x) ];
+ }
+ elsif (@$y < @$x) {
+ $y = [ @$y, ($y->[-1]) x (@$x - @$y) ];
+ }
+
my @result;
- if ($opts{"type"} eq '8bit') {
- for my $i (0..$#{$opts{'x'}}) {
+ if ($type eq '8bit') {
+ for my $i (0..$#$x) {
push(@result, i_get_pixel($self->{IMG}, $x->[$i], $y->[$i]));
}
}
- else {
- for my $i (0..$#{$opts{'x'}}) {
+ elsif ($type eq 'float' || $type eq 'double') {
+ for my $i (0..$#$x) {
push(@result, i_gpixf($self->{IMG}, $x->[$i], $y->[$i]));
}
}
+ else {
+ $self->_set_error("getpixel: type must be '8bit' or 'float'");
+ return;
+ }
return wantarray ? @result : \@result;
}
else {
- if ($opts{"type"} eq '8bit') {
+ if ($type eq '8bit') {
return i_get_pixel($self->{IMG}, $x, $y);
}
- else {
+ elsif ($type eq 'float' || $type eq 'double') {
return i_gpixf($self->{IMG}, $x, $y);
}
+ else {
+ $self->_set_error("getpixel: type must be '8bit' or 'float'");
+ return;
+ }
}
-
- $self;
}
sub getscanline {
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'}) {
return;
}
- unless ($opts{channels}) {
- $opts{channels} = [ 0 .. $self->getchannels()-1 ];
- }
-
if ($opts{target}) {
my $target = $opts{target};
my $offset = $opts{offset};
sub setsamples {
my $self = shift;
- my %opts = ( x => 0, offset => 0, @_ );
- 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;
+ # avoid duplicating the data parameter, it may be a large scalar
+ my $i = 0;
+ while ($i < @_ -1) {
+ if ($_[$i] eq 'data') {
+ $data_index = $i+1;
+ }
+ else {
+ $opts{$_[$i]} = $_[$i+1];
+ }
+
+ $i += 2;
}
- unless(defined $opts{data} && ref $opts{data}) {
- $self->_set_error('setsamples: data parameter missing or invalid');
+ unless(defined $data_index) {
+ $self->_set_error('setsamples: data parameter missing');
return;
}
-
- unless ($opts{channels}) {
- $opts{channels} = [ 0 .. $self->getchannels()-1 ];
+ unless (defined $_[$data_index]) {
+ $self->_set_error('setsamples: data parameter not defined');
+ return;
}
- unless ($opts{type} && $opts{type} =~ /^(\d+)bit$/) {
- $self->_set_error('setsamples: type parameter missing or invalid');
- return;
+ my $type = $opts{type};
+ defined $type or $type = '8bit';
+
+ my $width = defined $opts{width} ? $opts{width}
+ : $self->getwidth() - $opts{x};
+
+ my $count;
+ if ($type eq '8bit') {
+ $count = i_psamp($self->{IMG}, $opts{x}, $opts{y}, $opts{channels},
+ $_[$data_index], $opts{offset}, $width);
+ }
+ elsif ($type eq 'float') {
+ $count = i_psampf($self->{IMG}, $opts{x}, $opts{y}, $opts{channels},
+ $_[$data_index], $opts{offset}, $width);
}
- my $bits = $1;
+ elsif ($type =~ /^([0-9]+)bit$/) {
+ my $bits = $1;
- unless (defined $opts{width}) {
- $opts{width} = $self->getwidth() - $opts{x};
+ unless (ref $_[$data_index]) {
+ $self->_set_error("setsamples: data must be an array ref for type not 8bit or float");
+ return;
+ }
+
+ $count = i_psamp_bits($self->{IMG}, $opts{x}, $opts{y}, $bits,
+ $opts{channels}, $_[$data_index], $opts{offset},
+ $width);
+ }
+ else {
+ $self->_set_error('setsamples: type parameter invalid');
+ return;
}
- my $count = i_psamp_bits($self->{IMG}, $opts{x}, $opts{y}, $bits,
- $opts{channels}, $opts{data}, $opts{offset},
- $opts{width});
unless (defined $count) {
$self->_set_error(Imager->_error_as_msg);
return;
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";
$new->{IMG} = i_convert($self->{IMG}, $matrix);
unless ($new->{IMG}) {
# most likely a bad matrix
+ i_push_error(0, "convert");
$self->{ERRSTR} = _error_as_msg();
return undef;
}
$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});
}
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 {
i_get_image_file_limits();
}
+my @check_args = qw(width height channels sample_size);
+
+sub check_file_limits {
+ my $class = shift;
+
+ my %opts =
+ (
+ channels => 3,
+ sample_size => 1,
+ @_,
+ );
+
+ if ($opts{sample_size} && $opts{sample_size} eq 'float') {
+ $opts{sample_size} = length(pack("d", 0));
+ }
+
+ for my $name (@check_args) {
+ unless (defined $opts{$name}) {
+ $class->_set_error("check_file_limits: $name must be defined");
+ return;
+ }
+ unless ($opts{$name} == int($opts{$name})) {
+ $class->_set_error("check_file_limits: $name must be a positive integer");
+ return;
+ }
+ }
+
+ my $result = i_int_check_image_file_limits(@opts{@check_args});
+ unless ($result) {
+ $class->_set_error($class->_error_as_msg());
+ }
+
+ return $result;
+}
+
# Shortcuts that can be exported
sub newcolor { Imager::Color->new(@_); }
eval { require Imager::Font::T1 };
}
+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
package Imager::FORMATS;
use strict;
=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::ExtUtils> - tools to get access to 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
box() - L<Imager::Draw/box()> - draw a filled or outline box.
+check_file_limits() - L<Imager::Files/check_file_limits()>
+
circle() - L<Imager::Draw/circle()> - draw a filled circle
close_log() - L<Imager::ImageTypes/close_log()> - close the Imager
getcolorusagehash() - L<Imager::ImageTypes/getcolorusagehash()>
-get_file_limits() - L<Imager::Files/"Limiting the sizes of images you read">
+get_file_limits() - L<Imager::Files/get_file_limits()>
getheight() - L<Imager::ImageTypes/getheight()> - height of the image in
pixels
make_palette() - L<Imager::ImageTypes/make_palette()> - produce a
color palette from one or more input images.
-map() - L<Imager::Transformations/"Color Mappings"> - remap color
+map() - L<Imager::Transformations/map()> - remap color
channel values
masked() - L<Imager::ImageTypes/masked()> - make a masked image
NF() - L<Imager::Handy/NF()>
-open() - L<Imager::Files> - an alias for read()
+open() - L<Imager::Files/read()> - an alias for read()
open_log() - L<Imager::ImageTypes/open_log()> - open the debug log.
setcolors() - L<Imager::ImageTypes/setcolors()> - set palette colors
in a paletted image
-set_file_limits() - L<Imager::Files/"Limiting the sizes of images you read">
+set_file_limits() - L<Imager::Files/set_file_limits()>
setmask() - L<Imager::ImageTypes/setmask()>
L<Imager::Engines/"Matrix Transformations">,
L<Imager::Font/transform()>
-metadata, image - L<Imager::ImageTypes/"Tags">
+metadata, image - L<Imager::ImageTypes/"Tags">, L<Image::ExifTool>
mosaic - L<Imager::Filters/mosaic>
scaling - L<Imager::Transformations/scale()>
+security - L<Imager::Security>
+
SGI files - L<Imager::Files/"SGI (RGB, BW)">
sharpen - L<Imager::Filters/unsharpmask>, L<Imager::Filters/conv>
text, measuring - L<Imager::Font/bounding_box()>, L<Imager::Font::BBox>
+threads - L<Imager::Threads>
+
tiles, color - L<Imager::Filters/mosaic>
transparent images - L<Imager::ImageTypes>,
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.
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>.
+
If you're trying to use Imager for array processing, you should
probably using L<PDL>.
projects / imager.git / blobdiff