blib/lib/Imager.pm

filter: Statementstmt 76.3% 1758 / 2303 Branchbran 71.6% 1020 / 1424 Conditioncond 60.0% 204 / 340 MC/DCmcdc 36.7% 78 / 212 Subroutinesub 89.5% 162 / 181 Podpod 1.8% 2 / 106 totaltotal 70.6% 3224 / 4566 CC 881 SCAR 36.0
CC
881
Cov
73%
transform
650.0
load_plugin
110.0
_set_opts
101.7
CRAP 36.6
« blib/lib/Imager/Color.pm ↑ Summary blib/lib/Imager/Test.pm »
1 package Imager;
2 79 ▶use 5.006;
Subroutine BEGIN: called CC=1 SCAR=0.0
3  
4 79 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 79 ▶use Scalar::Util;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 79 ▶use Imager::Color;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 79 ▶use Imager::Color::Float;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 79 ▶use Imager::Font;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 79 ▶use Imager::TrimColorList;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 79 ▶use POSIX qw(INT_MIN INT_MAX);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 79 ▶use if $] >= 5.014, "warnings::register" => qw(tagcodes channelmask);
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 79 our $ERRSTR;
14 79 our $_out_of_memory;
15  
16 79 our @EXPORT_OK = qw(
17 init
18 init_log
19 DSO_open
20 DSO_close
21 DSO_funclist
22 DSO_call
23  
24 load_plugin
25 unload_plugin
26  
27 i_list_formats
28  
29 i_color_new
30 i_color_set
31 i_color_info
32  
33 i_img_info
34  
35 i_img_setmask
36 i_img_getmask
37  
38 i_line
39 i_line_aa
40 i_box
41 i_box_filled
42 i_arc
43 i_circle_aa
44  
45 i_bezier_multi
46 i_poly_aa
47 i_poly_aa_cfill
48  
49 i_copyto
50 i_rubthru
51 i_scaleaxis
52 i_scale_nn
53 i_haar
54 i_count_colors
55  
56 i_gaussian
57 i_conv
58  
59 i_convert
60 i_map
61  
62 i_img_diff
63  
64 i_tt_set_aa
65 i_tt_cp
66 i_tt_text
67 i_tt_bbox
68  
69 i_readpnm_wiol
70 i_writeppm_wiol
71  
72 i_readraw_wiol
73 i_writeraw_wiol
74  
75 i_contrast
76 i_hardinvert
77 i_noise
78 i_bumpmap
79 i_postlevels
80 i_mosaic
81 i_watermark
82  
83 list_formats
84  
85 i_gifquant
86  
87 newfont
88 newcolor
89 newcolour
90 NC
91 NF
92 NCF
93 );
94  
95 79 our @EXPORT=qw(
96 );
97  
98 79 our %EXPORT_TAGS=
99 (handy => [qw(
100 newfont
101 newcolor
102 NF
103 NC
104 NCF
105 )],
106 all => [@EXPORT_OK],
107 default => [qw(
108 load_plugin
109 unload_plugin
110 )]);
111  
112 # registered file readers
113 79 my %readers;
114  
115 # registered file writers
116 my %writers;
117  
118 # modules we attempted to autoload
119 79 my %attempted_to_load;
120  
121 # errors from loading files
122 79 my %file_load_errors;
123  
124 # what happened when we tried to load
125 79 my %reader_load_errors;
126 79 my %writer_load_errors;
127  
128 # library keys that are image file formats
129 79 my %file_formats = map { $_ => 1 } qw/tiff pnm gif png jpeg raw bmp tga/;
130  
131 # image pixel combine types
132 79 my @combine_types =
133 qw/none normal multiply dissolve add subtract diff lighten darken
134 hue saturation value color/;
135 79 my %combine_types;
136 79 @combine_types{@combine_types} = 0 .. $#combine_types;
137 79 $combine_types{mult} = $combine_types{multiply};
138 79 $combine_types{'sub'} = $combine_types{subtract};
139 79 $combine_types{sat} = $combine_types{saturation};
140  
141 # this will be used to store global defaults at some point
142 79 my %defaults;
143  
144 79 our $VERSION;
145  
146 79 ▶BEGIN {
Subroutine BEGIN: called CC=2 SCAR=7.1
147 79 require Exporter;
148 79 my $ex_version = eval $Exporter::VERSION;
149 79 ▶ if ($ex_version < 5.57) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ex_version < "5.57") 0 79 79
150 0 our @ISA = qw(Exporter);
151 }
152 79 $VERSION = '1.041';
153 79 require XSLoader;
154 79 XSLoader::load(Imager => $VERSION);
155 }
156  
157 79 my %formats_low;
158 79 my %format_classes =
159 (
160 png => "Imager::File::PNG",
161 gif => "Imager::File::GIF",
162 tiff => "Imager::File::TIFF",
163 jpeg => "Imager::File::JPEG",
164 w32 => "Imager::Font::W32",
165 ft2 => "Imager::Font::FT2",
166 t1 => "Imager::Font::T1",
167 );
168  
169 79 our %formats;
170  
171 79 tie %formats, "Imager::FORMATS", \%formats_low, \%format_classes;
172  
173 79 our %filters;
174  
175 79 our $DEBUG;
176 79 our %OPCODES;
177 79 our $FORMATGUESS;
178 79 our $warn_obsolete;
179  
180 79 ▶BEGIN {
Subroutine BEGIN: called CC=2 SCAR=6.9
181 79 for(i_list_formats()) { $formats_low{$_}++; }
182  
183 79 %OPCODES=(Add=>[0],Sub=>[1],Mult=>[2],Div=>[3],Parm=>[4],'sin'=>[5],'cos'=>[6],'x'=>[4,0],'y'=>[4,1]);
184  
185 79 $DEBUG=0;
186  
187 # the members of the subhashes under %filters are:
188 # callseq - a list of the parameters to the underlying filter in the
189 # order they are passed
190 # callsub - a code ref that takes a named parameter list and calls the
191 # underlying filter
192 # defaults - a hash of default values
193 # names - defines names for value of given parameters so if the names
194 # field is foo=> { bar=>1 }, and the user supplies "bar" as the
195 # foo parameter, the filter will receive 1 for the foo
196 # parameter
197 $filters{contrast}={
198 callseq => ['image','intensity'],
199 1 ▶ callsub => sub { my %hsh=@_; i_contrast($hsh{image},$hsh{intensity}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
200 79 };
201  
202 $filters{noise} ={
203 callseq => ['image', 'amount', 'subtype'],
204 defaults => { amount=>3,subtype=>0 },
205 1 ▶ callsub => sub { my %hsh=@_; i_noise($hsh{image},$hsh{amount},$hsh{subtype}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
206 79 };
207  
208 $filters{hardinvert} ={
209 callseq => ['image'],
210 defaults => { },
211 3 ▶ callsub => sub { my %hsh=@_; i_hardinvert($hsh{image}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
212 79 };
213  
214 $filters{hardinvertall} =
215 {
216 callseq => ['image'],
217 defaults => { },
218 2 ▶ callsub => sub { my %hsh=@_; i_hardinvertall($hsh{image}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
219 79 };
220  
221 $filters{autolevels_skew} ={
222 callseq => ['image','lsat','usat','skew'],
223 defaults => { lsat=>0.1,usat=>0.1,skew=>0.0 },
224 1 ▶ callsub => sub { my %hsh=@_; i_autolevels($hsh{image},$hsh{lsat},$hsh{usat},$hsh{skew}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
225 79 };
226  
227 $filters{autolevels} ={
228 callseq => ['image','lsat','usat'],
229 defaults => { lsat=>0.1,usat=>0.1 },
230 3 ▶ callsub => sub { my %hsh=@_; i_autolevels_mono($hsh{image},$hsh{lsat},$hsh{usat}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
231 79 };
232  
233 $filters{turbnoise} ={
234 callseq => ['image'],
235 defaults => { xo=>0.0,yo=>0.0,scale=>10.0 },
236 1 ▶ callsub => sub { my %hsh=@_; i_turbnoise($hsh{image},$hsh{xo},$hsh{yo},$hsh{scale}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
237 79 };
238  
239 $filters{radnoise} ={
240 callseq => ['image'],
241 defaults => { xo=>100,yo=>100,ascale=>17.0,rscale=>0.02 },
242 1 ▶ callsub => sub { my %hsh=@_; i_radnoise($hsh{image},$hsh{xo},$hsh{yo},$hsh{rscale},$hsh{ascale}); }
Subroutine __ANON__: called CC=1 SCAR=0.0
243 79 };
244  
245 $filters{conv} =
246 {
247 callseq => ['image', 'coef'],
248 defaults => { },
249 callsub =>
250 63 ▶ sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
251 63 my %hsh=@_;
252 i_conv($hsh{image},$hsh{coef})
253 63 ▶ or die Imager->_error_as_msg() . "\n";
Branch: 1 branch
BranchTrueFalseTotal
&i_conv($hsh{"image"}, $hsh{"coef"}) or die "Imager"->_error_as_msg . "\n" 60 2 62
254 }
255 79 };
256  
257 $filters{gradgen} =
258 {
259 callseq => ['image', 'xo', 'yo', 'colors', 'dist'],
260 defaults => { dist => 0 },
261 callsub =>
262 1 ▶ sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
263 1 my %hsh=@_;
264 1 my @colors = @{$hsh{colors}};
265 $_ = _color($_)
266 1 for @colors;
267 1 i_gradgen($hsh{image}, $hsh{xo}, $hsh{yo}, \@colors, $hsh{dist});
268 }
269 79 };
270  
271 $filters{nearest_color} =
272 {
273 callseq => ['image', 'xo', 'yo', 'colors', 'dist'],
274 defaults => { },
275 callsub =>
276 1 ▶ sub {
Subroutine __ANON__: called CC=4 SCAR=14.1
277 1 my %hsh=@_;
278 # make sure the segments are specified with colors
279 1 my @colors;
280 1 for my $color (@{$hsh{colors}}) {
281 3 ▶ my $new_color = _color($color)
Branch: 1 branch
BranchTrueFalseTotal
my $new_color = _color($color) or die $Imager::ERRSTR . "\n" 3 0 3
282 or die $Imager::ERRSTR."\n";
283 3 push @colors, $new_color;
284 }
285  
286 i_nearest_color($hsh{image}, $hsh{xo}, $hsh{yo}, \@colors,
287 $hsh{dist})
288 1 ▶ or die Imager->_error_as_msg() . "\n";
Branch: 1 branch
BranchTrueFalseTotal
&i_nearest_color($hsh{"image"}, $hsh{"xo"}, $hsh{"yo"}, \@colors, $hsh{"dist"}) or die "Imager"->_error_as_msg . "\n" 1 0 1
289 },
290 79 };
291 $filters{gaussian} = {
292 callseq => [ 'image', 'stddev' ],
293 defaults => { },
294 2 ▶ callsub => sub { my %hsh = @_; i_gaussian($hsh{image}, $hsh{stddev}); },
Subroutine __ANON__: called CC=1 SCAR=0.0
295 79 };
296 $filters{gaussian2} = {
297 callseq => [ 'image', 'stddevX', 'stddevY' ],
298 defaults => { },
299 5 ▶ callsub => sub { my %hsh = @_; i_gaussian2($hsh{image}, $hsh{stddevX}, $hsh{stddevY}); },
Subroutine __ANON__: called CC=1 SCAR=0.0
300 79 };
301 $filters{mosaic} =
302 {
303 callseq => [ qw(image size) ],
304 defaults => { size => 20 },
305 1 ▶ callsub => sub { my %hsh = @_; i_mosaic($hsh{image}, $hsh{size}) },
Subroutine __ANON__: called CC=1 SCAR=0.0
306 79 };
307 $filters{bumpmap} =
308 {
309 callseq => [ qw(image bump elevation lightx lighty st) ],
310 defaults => { elevation=>0, st=> 2 },
311 1 ▶ callsub => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
312 1 my %hsh = @_;
313 i_bumpmap($hsh{image}, $hsh{bump}{IMG}, $hsh{elevation},
314 1 $hsh{lightx}, $hsh{lighty}, $hsh{st});
315 },
316 79 };
317 $filters{bumpmap_complex} =
318 {
319 callseq => [ qw(image bump channel tx ty Lx Ly Lz cd cs n Ia Il Is) ],
320 defaults => {
321 channel => 0,
322 tx => 0,
323 ty => 0,
324 Lx => 0.2,
325 Ly => 0.4,
326 Lz => -1.0,
327 cd => 1.0,
328 cs => 40,
329 n => 1.3,
330 Ia => [0,0,0],
331 Il => [255,255,255],
332 Is => [255,255,255],
333 },
334 1 ▶ callsub => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
335 1 my %hsh = @_;
336 1 for my $cname (qw/Ia Il Is/) {
337 3 my $old = $hsh{$cname};
338 3 ▶ my $new_color = _color($old)
Branch: 1 branch
BranchTrueFalseTotal
my $new_color = _color($old) or die $Imager::ERRSTR, "\n" 3 0 3
339 or die $Imager::ERRSTR, "\n";
340 3 $hsh{$cname} = $new_color;
341 }
342 i_bumpmap_complex($hsh{image}, $hsh{bump}{IMG}, $hsh{channel},
343 $hsh{tx}, $hsh{ty}, $hsh{Lx}, $hsh{Ly}, $hsh{Lz},
344 $hsh{cd}, $hsh{cs}, $hsh{n}, $hsh{Ia}, $hsh{Il},
345 1 $hsh{Is});
346 },
347 79 };
348 $filters{postlevels} =
349 {
350 callseq => [ qw(image levels) ],
351 defaults => { levels => 10 },
352 1 ▶ callsub => sub { my %hsh = @_; i_postlevels($hsh{image}, $hsh{levels}); },
Subroutine __ANON__: called CC=1 SCAR=0.0
353 79 };
354 $filters{watermark} =
355 {
356 callseq => [ qw(image wmark tx ty pixdiff) ],
357 defaults => { pixdiff=>10, tx=>0, ty=>0 },
358 callsub =>
359 1 ▶ sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
360 1 my %hsh = @_;
361 i_watermark($hsh{image}, $hsh{wmark}{IMG}, $hsh{tx}, $hsh{ty},
362 1 $hsh{pixdiff});
363 },
364 79 };
365 $filters{fountain} =
366 {
367 callseq => [ qw(image xa ya xb yb ftype repeat combine super_sample ssample_param segments) ],
368 names => {
369 ftype => { linear => 0,
370 bilinear => 1,
371 radial => 2,
372 radial_square => 3,
373 revolution => 4,
374 conical => 5 },
375 repeat => { none => 0,
376 sawtooth => 1,
377 triangle => 2,
378 saw_both => 3,
379 tri_both => 4,
380 },
381 super_sample => {
382 none => 0,
383 grid => 1,
384 random => 2,
385 circle => 3,
386 },
387 combine => {
388 none => 0,
389 normal => 1,
390 multiply => 2, mult => 2,
391 dissolve => 3,
392 add => 4,
393 subtract => 5, 'sub' => 5,
394 diff => 6,
395 lighten => 7,
396 darken => 8,
397 hue => 9,
398 sat => 10,
399 value => 11,
400 color => 12,
401 },
402 },
403 defaults => { ftype => 0, repeat => 0, combine => 0,
404 super_sample => 0, ssample_param => 4,
405 segments=>[
406 [ 0, 0.5, 1,
407 [0,0,0],
408 [255, 255, 255],
409 0, 0,
410 ],
411 ],
412 },
413 callsub =>
414 10 ▶ sub {
Subroutine __ANON__: called CC=5 SCAR=16.1
415 10 my %hsh = @_;
416  
417 # make sure the segments are specified with colors
418 10 my @segments;
419 10 for my $segment (@{$hsh{segments}}) {
420 13 my @new_segment = @$segment;
421
422 13 ▶ $_ = _color($_) or die $Imager::ERRSTR."\n" for @new_segment[3,4];
Branch: 1 branch
BranchTrueFalseTotal
$_ = _color($_) or die $Imager::ERRSTR . "\n" 25 1 26
423 12 push @segments, \@new_segment;
424 }
425  
426 i_fountain($hsh{image}, $hsh{xa}, $hsh{ya}, $hsh{xb}, $hsh{yb},
427 $hsh{ftype}, $hsh{repeat}, $hsh{combine}, $hsh{super_sample},
428 9 ▶ $hsh{ssample_param}, \@segments)
Branch: 1 branch
BranchTrueFalseTotal
&i_fountain($hsh{"image"}, $hsh{"xa"}, $hsh{"ya"}, $hsh{"xb"}, $hsh{"yb"}, $hsh{"ftype"}, $hsh{"repeat"}, $hsh{"combine"}, $hsh{"super_sample"}, $hsh{"ssample_param"}, \@segments) or die "Imager"->_error_as_msg . "\n" 9 0 9
429 or die Imager->_error_as_msg() . "\n";
430 },
431 79 };
432 $filters{unsharpmask} =
433 {
434 callseq => [ qw(image stddev scale) ],
435 defaults => { stddev=>2.0, scale=>1.0 },
436 callsub =>
437 1 ▶ sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
438 1 my %hsh = @_;
439 1 i_unsharp_mask($hsh{image}, $hsh{stddev}, $hsh{scale});
440 },
441 79 };
442  
443 79 $FORMATGUESS=\&def_guess_type;
444  
445 79 $warn_obsolete = 1;
446 }
447  
448 #
449 # Non methods
450 #
451  
452 # initialize Imager
453 # NOTE: this might be moved to an import override later on
454  
455 146 ▶sub import {
Subroutine import: called CC=3 SCAR=11.6
456 146 my $i = 1;
457 146 ▶ while ($i < @_) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @_) 31 146 177
458 31 ▶ if ($_[$i] eq '-log-stderr') {
Branch: 1 branch
BranchTrueFalseTotal
if ($_[$i] eq '-log-stderr') { } 0 31 31
459 0 init_log(undef, 4);
460 0 splice(@_, $i, 1);
461 }
462 else {
463 31 ++$i;
464 }
465 }
466 146 goto &Exporter::import;
467 }
468  
469 9 ▶sub init_log {
Subroutine init_log: called CC=1 SCAR=0.0
Pod undocumented
470 9 Imager->open_log(log => $_[0], level => $_[1]);
471 }
472  
473  
474 8 ▶sub init {
Subroutine init: called CC=7 SCAR=27.6
Pod undocumented
475 8 my %parms=(loglevel=>1,@_);
476  
477 8 ▶ if (exists $parms{'warn_obsolete'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $parms{"warn_obsolete"}) 0 8 8
478 0 $warn_obsolete = $parms{'warn_obsolete'};
479 }
480  
481 8 ▶ if ($parms{'log'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($parms{"log"}) 8 0 8
482 Imager->open_log(log => $parms{log}, level => $parms{loglevel})
483 8 ▶ or return;
Branch: 1 branch
BranchTrueFalseTotal
"Imager"->open_log("log", $parms{"log"}, "level", $parms{"loglevel"}) or return 8 0 8
484 }
485  
486 8 ▶ if (exists $parms{'t1log'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $parms{"t1log"}) 0 8 8
487 0 ▶ if ($formats{t1}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($Imager::formats{"t1"}) 0 0 0
488 0 ▶ if (Imager::Font::T1::i_init_t1($parms{'t1log'})) {
Branch: 1 branch
BranchTrueFalseTotal
if (Imager::Font::T1::i_init_t1($parms{"t1log"})) 0 0 0
489 0 Imager->_set_error(Imager->_error_as_msg);
490 0 return;
491 }
492 }
493 }
494  
495 8 return 1;
496 }
497  
498 {
499 79 my $is_logging = 0;
500  
501 37 ▶ sub open_log {
Subroutine open_log: called CC=2 SCAR=7.5
Pod undocumented
502 37 my $class = shift;
503 37 my (%opts) = ( loglevel => 1, @_ );
504  
505 37 $is_logging = i_init_log($opts{log}, $opts{loglevel});
506 37 ▶ unless ($is_logging) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($is_logging) 0 37 37
507 0 Imager->_set_error(Imager->_error_as_msg());
508 0 return;
509 }
510  
511 37 Imager->log("Imager $VERSION starting\n", 1);
512  
513 37 return $is_logging;
514 }
515  
516 19 ▶ sub close_log {
Subroutine close_log: called CC=1 SCAR=0.0
Pod undocumented
517 19 i_init_log(undef, -1);
518 19 $is_logging = 0;
519 }
520  
521 38 ▶ sub log {
Subroutine log: called CC=2 SCAR=6.9
Pod undocumented
522 38 my ($class, $message, $level) = @_;
523  
524 38 ▶ defined $level or $level = 1;
Branch: 1 branch
BranchTrueFalseTotal
defined $level or $level = 1 37 1 38
525  
526 38 i_log_entry($message, $level);
527 }
528  
529 0 ▶ sub is_logging {
Subroutine is_logging: not called CC=1 SCAR=6.9
Pod undocumented
530 0 return $is_logging;
531 }
532 }
533  
534 79 ▶END {
Subroutine END: called CC=2 SCAR=9.2
535 79 ▶ if ($DEBUG) {
Branch: 1 branch
BranchTrueFalseTotal
if ($Imager::DEBUG) 0 79 79
536 0 print "shutdown code\n";
537 # for(keys %instances) { $instances{$_}->DESTROY(); }
538 0 print "Imager exiting\n";
539 }
540 }
541  
542 # Load a filter plugin
543  
544 79 our %DSOs;
545  
546 0 ▶sub load_plugin {
Subroutine load_plugin: not called CC=10 SCAR=47.0
Pod undocumented
547 0 my ($filename)=@_;
548 0 my $i;
549  
550 0 ▶ if ($^O eq 'android') {
Branch: 1 branch
BranchTrueFalseTotal
if ($^O eq "android") 0 0 0
551 0 require File::Spec;
552 0 $filename = File::Spec->rel2abs($filename);
553 }
554  
555 0 my ($DSO_handle,$str)=DSO_open($filename);
556 0 ▶ if (!defined($DSO_handle)) { $Imager::ERRSTR="Couldn't load plugin '$filename'\n"; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $DSO_handle) 0 0 0
557 0 my %funcs=DSO_funclist($DSO_handle);
558 0 ▶ if ($DEBUG) { print "loading module $filename\n"; $i=0; for(keys %funcs) { printf(" %2d: %s\n",$i++,$_); } }
Branch: 1 branch
BranchTrueFalseTotal
if ($Imager::DEBUG) 0 0 0
559 0 $i=0;
560 0 ▶ for(keys %funcs) { if ($filters{$_}) { $ERRSTR="filter '$_' already exists\n"; DSO_close($DSO_handle); return undef; } }
Branch: 1 branch
BranchTrueFalseTotal
if ($Imager::filters{$_}) 0 0 0
561  
562 0 $DSOs{$filename}=[$DSO_handle,\%funcs];
563  
564 0 for(keys %funcs) {
565 0 my $evstr="\$filters{'".$_."'}={".$funcs{$_}.'};';
566 0 ▶ $DEBUG && print "eval string:\n",$evstr,"\n";
Branch: 1 branch
BranchTrueFalseTotal
$Imager::DEBUG and print "eval string:\n", $evstr, "\n" 0 0 0
567 0 eval $evstr;
568 0 ▶ print $@ if $@;
Branch: 1 branch
BranchTrueFalseTotal
if $@ 0 0 0
569 }
570 0 return 1;
571 }
572  
573 # Unload a plugin
574  
575 0 ▶sub unload_plugin {
Subroutine unload_plugin: not called CC=6 SCAR=37.4
Pod undocumented
576 0 my ($filename)=@_;
577  
578 0 ▶ if ($^O eq 'android') {
Branch: 1 branch
BranchTrueFalseTotal
if ($^O eq "android") 0 0 0
579 0 require File::Spec;
580 0 $filename = File::Spec->rel2abs($filename);
581 }
582  
583 0 ▶ if (!$DSOs{$filename}) { $ERRSTR="plugin '$filename' not loaded."; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless ($Imager::DSOs{$filename}) 0 0 0
584 0 my ($DSO_handle,$funcref)=@{$DSOs{$filename}};
585 0 for(keys %{$funcref}) {
586 0 delete $filters{$_};
587 0 ▶ $DEBUG && print "unloading: $_\n";
Branch: 1 branch
BranchTrueFalseTotal
$Imager::DEBUG and print "unloading: $_\n" 0 0 0
588 }
589 0 my $rc=DSO_close($DSO_handle);
590 0 ▶ if (!defined($rc)) { $ERRSTR="unable to unload plugin '$filename'."; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $rc) 0 0 0
591 0 return 1;
592 }
593  
594 # take the results of i_error() and make a message out of it
595 316 ▶sub _error_as_msg {
Subroutine _error_as_msg: called CC=1 SCAR=0.0
596 316 return join(": ", map $_->[0], i_errors());
597 }
598  
599 # this function tries to DWIM for color parameters
600 # color objects are used as is
601 # simple scalars are simply treated as single parameters to Imager::Color->new
602 # hashrefs are treated as named argument lists to Imager::Color->new
603 # arrayrefs are treated as list arguments to Imager::Color->new iff any
604 # parameter is > 1
605 # other arrayrefs are treated as list arguments to Imager::Color::Float
606  
607 1189 ▶sub _color {
Subroutine _color: called CC=6 SCAR=18.0
608 1189 my $arg = shift;
609 # perl 5.6.0 seems to do weird things to $arg if we don't make an
610 # explicitly stringified copy
611 # I vaguely remember a bug on this on p5p, but couldn't find it
612 # through bugs.perl.org (I had trouble getting it to find any bugs)
613 1189 my $copy = $arg . "";
614 1189 my $result;
615  
616 1189 ▶ if (ref $arg) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $arg) { } 807 382 1189
617 807 ▶ if (UNIVERSAL::isa($arg, "Imager::Color")
Branch: 1 branch
BranchTrueFalseTotal
if (UNIVERSAL::isa($arg, 'Imager::Color') or UNIVERSAL::isa($arg, 'Imager::Color::Float')) { } 580 227 807
Condition100%3/3
UNIVERSAL::isa($arg, "Imager::Color") or UNIVERSAL::isa($arg, "Imager::Color::Float")
l!l&&r!l&&!r
53842227
MC/DC100%2/2
UNIVERSAL::isa($arg, "Imager::Color") or UNIVERSAL::isa($arg, "Imager::Color::Float")
UNIVERSAL::isa($arg, "Imager::Color") UNIVERSAL::isa($arg, "Imager::Color::Float")
Truth table100%3/3
A or B
A= UNIVERSAL::isa($arg, "Imager::Color")B= UNIVERSAL::isa($arg, "Imager::Color::Float")
ABresult
1X1
011
000
618 || UNIVERSAL::isa($arg, "Imager::Color::Float")) {
619 580 $result = $arg;
620 }
621 else {
622 227 ▶ if ($copy =~ /^HASH\(/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($copy =~ /^HASH\(/) { } 11 216 227
elsif ($copy =~ /^ARRAY\(/) { } 216 0 216
623 11 $result = Imager::Color->new(%$arg);
624 }
625 elsif ($copy =~ /^ARRAY\(/) {
626 216 $result = Imager::Color->new(@$arg);
627 }
628 else {
629 0 $Imager::ERRSTR = "Not a color";
630 }
631 }
632 }
633 else {
634 # assume Imager::Color::new knows how to handle it
635 382 $result = Imager::Color->new($arg);
636 }
637  
638 1189 return $result;
639 }
640  
641 125 ▶sub _combine {
Subroutine _combine: called CC=6 SCAR=17.9
642 125 my ($self, $combine, $default) = @_;
643  
644 125 ▶ if (!defined $combine && ref $self) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $combine and ref $self) 55 70 125
Condition100%3/3
not defined $combine and ref $self
!ll&&!rl&&r
323855
MC/DC100%2/2
not defined $combine and ref $self
not defined $combine ref $self
Truth table100%3/3
not(A) and B
A= not defined $combineB= ref $self
ABresult
0X0
100
111
645 55 $combine = $self->{combine};
646 }
647 125 ▶ defined $combine or $combine = $defaults{combine};
Branch: 1 branch
BranchTrueFalseTotal
defined $combine or $combine = $defaults{"combine"} 32 93 125
648 125 ▶ defined $combine or $combine = $default;
Branch: 1 branch
BranchTrueFalseTotal
defined $combine or $combine = $default 32 93 125
649  
650 125 ▶ if (exists $combine_types{$combine}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $combine_types{$combine}) 85 40 125
651 85 $combine = $combine_types{$combine};
652 }
653
654 125 return $combine;
655 }
656  
657 9718 ▶sub _valid_image {
Subroutine _valid_image: called CC=6 SCAR=18.6
658 9718 my ($self, $method) = @_;
659  
660 9718 ▶ ref $self
Branch: 1 branch
BranchTrueFalseTotal
ref $self or return "Imager"->_set_error("$method needs an image object") 9718 0 9718
661 or return Imager->_set_error("$method needs an image object");
662  
663 9718 ▶ $self->{IMG} && Scalar::Util::blessed($self->{IMG}) and return 1;
Branch: 1 branch
BranchTrueFalseTotal
$self->{"IMG"} and builtin::blessed($self->{"IMG"}) and return 1 9650 68 9718
Condition66%2/3
$self->{"IMG"} and builtin::blessed($self->{"IMG"})
!ll&&!rl&&r
6809650
MC/DC50%1/2
$self->{"IMG"} and builtin::blessed($self->{"IMG"})
$self->{"IMG"} builtin::blessed($self->{"IMG"})
Truth table66%2/3
A and B
A= $self->{"IMG"}B= builtin::blessed($self->{"IMG"})
ABresult
0X0
100
111
664  
665 68 ▶ my $msg = $self->{IMG} ? "images do not cross threads" : "empty input image";
Branch: 1 branch
BranchTrueFalseTotal
$self->{'IMG'} ? : 0 68 68
666 68 ▶ $msg = "$method: $msg" if $method;
Branch: 1 branch
BranchTrueFalseTotal
if $method 68 0 68
667 68 $self->_set_error($msg);
668  
669 68 return;
670 }
671  
672 # returns first defined parameter
673 112 ▶sub _first {
Subroutine _first: called CC=3 SCAR=11.0
674 112 for (@_) {
675 234 ▶ return $_ if defined $_;
Branch: 1 branch
BranchTrueFalseTotal
if defined $_ 111 123 234
676 }
677 1 return undef;
678 }
679  
680 #
681 # Methods to be called on objects.
682 #
683  
684 # Create a new Imager object takes very few parameters.
685 # usually you call this method and then call open from
686 # the resulting object
687  
688 1454 ▶sub new {
Subroutine new: called CC=15 SCAR=27.7
Pod undocumented
689 1454 my $class = shift;
690 1454 my $self ={};
691 1454 my %hsh=@_;
692 1454 bless $self,$class;
693 1454 $self->{IMG}=undef; # Just to indicate what exists
694 1454 $self->{ERRSTR}=undef; #
695 1454 $self->{DEBUG}=$DEBUG;
696 1454 ▶ $self->{DEBUG} and print "Initialized Imager\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "Initialized Imager\n" 0 1454 1454
697 1454 ▶ if (defined $hsh{file} ||
Branch: 3 branches
BranchTrueFalseTotal
if (defined $hsh{'file'} or defined $hsh{'fh'} or defined $hsh{'fd'} or defined $hsh{'callback'} or defined $hsh{'readcb'} or defined $hsh{'data'} or defined $hsh{'io'}) { } 20 1434 1454
elsif (defined $hsh{'xsize'} or defined $hsh{'ysize'}) { } 607 827 1434
elsif (%hsh) { } 0 827 827
Condition77%14/18
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"} or defined $hsh{"callback"} or defined $hsh{"readcb"} or defined $hsh{"data"} or defined $hsh{"io"}
l!l&&r!l&&!r
2001434
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"} or defined $hsh{"callback"} or defined $hsh{"readcb"} or defined $hsh{"data"}
l!l&&r!l&&!r
7131434
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"} or defined $hsh{"callback"} or defined $hsh{"readcb"}
l!l&&r!l&&!r
701447
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"} or defined $hsh{"callback"}
l!l&&r!l&&!r
701447
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"}
l!l&&r!l&&!r
701447
defined $hsh{"file"} or defined $hsh{"fh"}
l!l&&r!l&&!r
611447
MC/DC42%3/7
defined $hsh{"file"} or defined $hsh{"fh"} or defined $hsh{"fd"} or defined $hsh{"callback"} or defined $hsh{"readcb"} or defined $hsh{"data"} or defined $hsh{"io"}
defined $hsh{"file"} defined $hsh{"fh"} defined $hsh{"fd"} defined $hsh{"callback"} defined $hsh{"readcb"} defined $hsh{"data"} defined $hsh{"io"}
Truth table50%4/8
A or B or C or D or E or F or G
A= defined $hsh{"file"}B= defined $hsh{"fh"}C= defined $hsh{"fd"}D= defined $hsh{"callback"}E= defined $hsh{"readcb"}F= defined $hsh{"data"}G= defined $hsh{"io"}
ABCDEFGresult
1XXXXXX1
01XXXXX1
001XXXX1
0001XXX1
00001XX1
000001X1
00000011
00000000
698 defined $hsh{fh} ||
699 defined $hsh{fd} ||
700 defined $hsh{callback} ||
701 defined $hsh{readcb} ||
702 defined $hsh{data} ||
703 defined $hsh{io}) {
704 # allow $img = Imager->new(file => $filename)
705 20 my %extras;
706
707 # type is already used as a parameter to new(), rename it for the
708 # call to read()
709 20 ▶ if ($hsh{filetype}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($hsh{"filetype"}) 10 10 20
710 10 $extras{type} = $hsh{filetype};
711 }
712 20 ▶ unless ($self->read(%hsh, %extras)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->read(%hsh, %extras)) 5 15 20
713 5 $Imager::ERRSTR = $self->{ERRSTR};
714 5 return;
715 }
716 }
717 ▶ elsif (defined $hsh{xsize} || defined $hsh{ysize}) {
Condition66%2/3
defined $hsh{"xsize"} or defined $hsh{"ysize"}
l!l&&r!l&&!r
6070827
MC/DC50%1/2
defined $hsh{"xsize"} or defined $hsh{"ysize"}
defined $hsh{"xsize"} defined $hsh{"ysize"}
Truth table66%2/3
A or B
A= defined $hsh{"xsize"}B= defined $hsh{"ysize"}
ABresult
1X1
011
000
718 607 ▶ unless ($self->img_set(%hsh)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->img_set(%hsh)) 25 582 607
719 25 $Imager::ERRSTR = $self->{ERRSTR};
720 25 return;
721 }
722 }
723 elsif (%hsh) {
724 0 Imager->_set_error("new: supply xsize and ysize or a file access parameter or no parameters");
725 0 return;
726 }
727  
728 1424 return $self;
729 }
730  
731 # Copy an entire image with no changes
732 # - if an image has magic the copy of it will not be magical
733  
734 220 ▶sub copy {
Subroutine copy: called CC=3 SCAR=11.0
Pod undocumented
735 220 my $self = shift;
736  
737 220 ▶ $self->_valid_image("copy")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("copy") or return 219 1 220
738 or return;
739  
740 219 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 218 219
741 1 my @caller = caller;
742 1 warn "copy() called in void context - copy() returns the copied image at $caller[1] line $caller[2]\n";
743 1 return;
744 }
745  
746 218 my $newcopy=Imager->new();
747 218 $newcopy->{IMG} = i_copy($self->{IMG});
748 218 return $newcopy;
749 }
750  
751 # Paste a region
752  
753 33 ▶sub paste {
Subroutine paste: called CC=18 SCAR=29.8
Pod undocumented
754 33 my $self = shift;
755  
756 33 ▶ $self->_valid_image("paste")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("paste") or return 32 1 33
757 or return;
758  
759 32 my %input=(left=>0, top=>0, src_minx => 0, src_miny => 0, @_);
760 32 ▶ my $src = $input{img} || $input{src};
Condition100%3/3
$input{'img'} || $input{'src'}
l!l&&r!l&&!r
1301
MC/DC100%2/2
$input{'img'} || $input{'src'}
$input{'img'} $input{'src'}
Truth table100%3/3
A || B
A= $input{'img'}B= $input{'src'}
ABresult
1X1
011
000
761 32 ▶ unless($src) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($src) 1 31 32
762 1 $self->_set_error("no source image");
763 1 return;
764 }
765 31 ▶ unless ($src->_valid_image("paste")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($src->_valid_image("paste")) 1 30 31
766 1 $self->{ERRSTR} = $src->{ERRSTR} . " (for src)";
767 1 return;
768 }
769 30 ▶ $input{left}=0 if $input{left} <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $input{"left"} <= 0 5 25 30
770 30 ▶ $input{top}=0 if $input{top} <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if $input{"top"} <= 0 5 25 30
771  
772 30 my($r,$b)=i_img_info($src->{IMG});
773 30 my ($src_left, $src_top) = @input{qw/src_minx src_miny/};
774 30 my ($src_right, $src_bottom);
775 30 ▶ if ($input{src_coords}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($input{'src_coords'}) { } 1 29 30
776 1 ($src_left, $src_top, $src_right, $src_bottom) = @{$input{src_coords}}
777 }
778 else {
779 29 ▶ if (defined $input{src_maxx}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $input{'src_maxx'}) { } 2 27 29
elsif (defined $input{'width'}) { } 1 26 27
780 2 $src_right = $input{src_maxx};
781 }
782 elsif (defined $input{width}) {
783 1 ▶ if ($input{width} <= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($input{"width"} <= 0) 0 1 1
784 0 $self->_set_error("paste: width must me positive");
785 0 return;
786 }
787 1 $src_right = $src_left + $input{width};
788 }
789 else {
790 26 $src_right = $r;
791 }
792 29 ▶ if (defined $input{src_maxy}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $input{'src_maxy'}) { } 3 26 29
elsif (defined $input{'height'}) { } 1 25 26
793 3 $src_bottom = $input{src_maxy};
794 }
795 elsif (defined $input{height}) {
796 1 ▶ if ($input{height} < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($input{"height"} < 0) 0 1 1
797 0 $self->_set_error("paste: height must be positive");
798 0 return;
799 }
800 1 $src_bottom = $src_top + $input{height};
801 }
802 else {
803 25 $src_bottom = $b;
804 }
805 }
806  
807 30 ▶ $src_right > $r and $src_right = $r;
Branch: 1 branch
BranchTrueFalseTotal
$src_right > $r and $src_right = $r 0 30 30
808 30 ▶ $src_bottom > $b and $src_bottom = $b;
Branch: 1 branch
BranchTrueFalseTotal
$src_bottom > $b and $src_bottom = $b 0 30 30
809  
810 30 ▶ if ($src_right <= $src_left
Branch: 1 branch
BranchTrueFalseTotal
if ($src_right <= $src_left or $src_bottom < $src_top) 0 30 30
Condition33%1/3
$src_right <= $src_left or $src_bottom < $src_top
l!l&&r!l&&!r
0030
MC/DC0%0/2
$src_right <= $src_left or $src_bottom < $src_top
$src_right <= $src_left $src_bottom < $src_top
Truth table33%1/3
A or B
A= $src_right <= $src_leftB= $src_bottom < $src_top
ABresult
1X1
011
000
811 || $src_bottom < $src_top) {
812 0 $self->_set_error("nothing to paste");
813 0 return;
814 }
815  
816 i_copyto($self->{IMG}, $src->{IMG},
817 $src_left, $src_top, $src_right, $src_bottom,
818 30 $input{left}, $input{top});
819  
820 30 return $self; # What should go here??
821 }
822  
823 # Crop an image - i.e. return a new image that is smaller
824  
825 48 ▶sub crop {
Subroutine crop: called CC=26 SCAR=32.6
Pod undocumented
826 48 my $self=shift;
827  
828 48 ▶ $self->_valid_image("crop")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("crop") or return 47 1 48
829 or return;
830
831 47 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 46 47
832 1 my @caller = caller;
833 1 warn "crop() called in void context - crop() returns the cropped image at $caller[1] line $caller[2]\n";
834 1 return;
835 }
836  
837 46 my %hsh=@_;
838  
839 my ($w, $h, $l, $r, $b, $t) =
840 46 @hsh{qw(width height left right bottom top)};
841  
842 # work through the various possibilities
843 46 ▶ if (defined $l) {
Branch: 3 branches
BranchTrueFalseTotal
if (defined $l) { } 34 12 46
elsif (defined $r) { } 3 9 12
elsif (defined $w) { } 1 8 9
844 34 ▶ if (defined $w) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $w) { } 1 33 34
elsif (not defined $r) { } 1 32 33
845 1 $r = $l + $w;
846 }
847 elsif (!defined $r) {
848 1 $r = $self->getwidth;
849 }
850 }
851 elsif (defined $r) {
852 3 ▶ if (defined $w) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $w) { } 2 1 3
853 2 $l = $r - $w;
854 }
855 else {
856 1 $l = 0;
857 }
858 }
859 elsif (defined $w) {
860 1 $l = int(0.5+($self->getwidth()-$w)/2);
861 1 $r = $l + $w;
862 }
863 else {
864 8 $l = 0;
865 8 $r = $self->getwidth;
866 }
867 46 ▶ if (defined $t) {
Branch: 3 branches
BranchTrueFalseTotal
if (defined $t) { } 36 10 46
elsif (defined $b) { } 3 7 10
elsif (defined $h) { } 1 6 7
868 36 ▶ if (defined $h) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $h) { } 4 32 36
elsif (not defined $b) { } 1 31 32
869 4 $b = $t + $h;
870 }
871 elsif (!defined $b) {
872 1 $b = $self->getheight;
873 }
874 }
875 elsif (defined $b) {
876 3 ▶ if (defined $h) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $h) { } 2 1 3
877 2 $t = $b - $h;
878 }
879 else {
880 1 $t = 0;
881 }
882 }
883 elsif (defined $h) {
884 1 $t=int(0.5+($self->getheight()-$h)/2);
885 1 $b=$t+$h;
886 }
887 else {
888 6 $t = 0;
889 6 $b = $self->getheight;
890 }
891  
892 46 ▶ ($l,$r)=($r,$l) if $l>$r;
Branch: 1 branch
BranchTrueFalseTotal
if $l > $r 0 46 46
893 46 ▶ ($t,$b)=($b,$t) if $t>$b;
Branch: 1 branch
BranchTrueFalseTotal
if $t > $b 0 46 46
894  
895 46 ▶ $l < 0 and $l = 0;
Branch: 1 branch
BranchTrueFalseTotal
$l < 0 and $l = 0 1 45 46
896 46 ▶ $r > $self->getwidth and $r = $self->getwidth;
Branch: 1 branch
BranchTrueFalseTotal
$r > $self->getwidth and $r = $self->getwidth 2 44 46
897 46 ▶ $t < 0 and $t = 0;
Branch: 1 branch
BranchTrueFalseTotal
$t < 0 and $t = 0 1 45 46
898 46 ▶ $b > $self->getheight and $b = $self->getheight;
Branch: 1 branch
BranchTrueFalseTotal
$b > $self->getheight and $b = $self->getheight 3 43 46
899  
900 46 ▶ if ($l == $r || $t == $b) {
Branch: 1 branch
BranchTrueFalseTotal
if ($l == $r or $t == $b) 2 44 46
Condition100%3/3
$l == $r or $t == $b
l!l&&r!l&&!r
1144
MC/DC100%2/2
$l == $r or $t == $b
$l == $r $t == $b
Truth table100%3/3
A or B
A= $l == $rB= $t == $b
ABresult
1X1
011
000
901 2 $self->_set_error("resulting image would have no content");
902 2 return;
903 }
904 44 ▶ if( $r < $l or $b < $t ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($r < $l or $b < $t) 2 42 44
Condition100%3/3
$r < $l or $b < $t
l!l&&r!l&&!r
1142
MC/DC100%2/2
$r < $l or $b < $t
$r < $l $b < $t
Truth table100%3/3
A or B
A= $r < $lB= $b < $t
ABresult
1X1
011
000
905 2 $self->_set_error("attempting to crop outside of the image");
906 2 return;
907 }
908 42 ▶ my $dst = $self->_sametype(xsize=>$r-$l, ysize=>$b-$t)
Branch: 1 branch
BranchTrueFalseTotal
my $dst = $self->_sametype("xsize", $r - $l, "ysize", $b - $t) or return 42 0 42
909 or return;
910  
911 42 i_copyto($dst->{IMG},$self->{IMG},$l,$t,$r,$b,0,0);
912 42 return $dst;
913 }
914  
915 79 my $empty_trim_colors = Imager::TrimColorList->new();
916  
917 15 ▶sub _trim_rect {
Subroutine _trim_rect: called CC=13 SCAR=31.7
918 15 my ($self, $name, %hsh) = @_;
919  
920 15 ▶ $self->_valid_image($name)
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image($name) or return 15 0 15
921 or return;
922  
923 15 my $auto = delete $hsh{auto};
924 15 ▶ my $colors = delete $hsh{colors} || $empty_trim_colors;
Condition66%2/3
delete $hsh{'colors'} || $empty_trim_colors
l!l&&r!l&&!r
690
MC/DC0%0/2
delete $hsh{'colors'} || $empty_trim_colors
delete $hsh{'colors'} $empty_trim_colors
Truth table66%2/3
A || B
A= delete $hsh{'colors'}B= $empty_trim_colors
ABresult
1X1
011
000
925 15 ▶ my $alpha = delete $hsh{alpha} || 0;
Condition50%1/2
delete $hsh{'alpha'} || 0
l!l
015
MC/DC0%0/1
delete $hsh{'alpha'} || 0
delete $hsh{'alpha'}
Truth table50%1/2
A
A= delete $hsh{'alpha'}
Aresult
11
00
926 15 my $tolerance = delete $hsh{tolerance};
927 15 ▶ defined $tolerance or $tolerance = 0.01;
Branch: 1 branch
BranchTrueFalseTotal
defined $tolerance or $tolerance = "0.01" 0 15 15
928  
929 15 ▶ if (keys %hsh) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %hsh) 0 15 15
930 0 $self->_set_error("$name: unexpected arguments:".join(", ", sort keys %hsh));
931 0 return;
932 }
933  
934 15 ▶ if ($auto) {
Branch: 1 branch
BranchTrueFalseTotal
if ($auto) 5 10 15
935 5 ▶ if ($colors != $empty_trim_colors) {
Branch: 1 branch
BranchTrueFalseTotal
if ($colors != $empty_trim_colors) 0 5 5
936 0 $self->_set_error("$name: only one of auto and colors can be supplied");
937 0 return;
938 }
939 5 ▶ if ($tolerance < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($tolerance < 0) 0 5 5
940 0 $self->_set_error("$name: tolerance must be non-negative");
941 0 return;
942 }
943  
944 5 $colors = Imager::TrimColorList->auto
945 (
946 auto => $auto,
947 tolerance => $tolerance,
948 name => $name,
949 image => $self,
950 );
951 5 ▶ unless ($colors) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($colors) 0 5 5
952 0 $self->_set_error(Imager->errstr);
953 0 return;
954 }
955 }
956  
957 15 ▶ unless (ref $colors) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $colors) 0 15 15
958 0 $self->_set_error("$name: colors must be an arrayref or an Imager::TrimColorList object");
959 0 return;
960 }
961 15 ▶ unless (UNIVERSAL::isa($colors, "Imager::TrimColorList")) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($colors, "Imager::TrimColorList")) 5 10 15
962 5 ▶ unless (Scalar::Util::reftype($colors) eq "ARRAY") {
Branch: 1 branch
BranchTrueFalseTotal
unless (builtin::reftype($colors) eq "ARRAY") 0 5 5
963 0 $self->_set_error("$name: colors must be an arrayref or an Imager::TrimColorList object");
964 0 return;
965 }
966 5 $colors = Imager::TrimColorList->new(@$colors);
967 }
968  
969 15 return i_trim_rect($self->{IMG}, $alpha, $colors);
970 }
971  
972 11 ▶sub trim_rect {
Subroutine trim_rect: called CC=1 SCAR=0.0
Pod undocumented
973 11 my ($self, %hsh) = @_;
974  
975 11 return $self->_trim_rect("trim_rect", %hsh);
976 }
977  
978 4 ▶sub trim {
Subroutine trim: called CC=3 SCAR=11.8
Pod undocumented
979 4 my ($self, %hsh) = @_;
980  
981 4 ▶ my ($left, $top, $right, $bottom) = $self->_trim_rect("trim", %hsh)
Branch: 1 branch
BranchTrueFalseTotal
() = $self->_trim_rect("trim", %hsh) or return 4 0 4
982 or return;
983  
984 4 ▶ if ($left == $self->getwidth) {
Branch: 1 branch
BranchTrueFalseTotal
if ($left == $self->getwidth) { } 0 4 4
985 # the whole image would be trimmed, but we don't support zero
986 # width or height images.
987 0 return $self->crop(width => 1, height => 1);
988 }
989 else {
990 4 my ($w, $h) = i_img_info($self->{IMG});
991 4 return $self->crop(left => $left, right => $w - $right,
992 top => $top, bottom => $h - $bottom);
993 }
994 }
995  
996 42 ▶sub _sametype {
Subroutine _sametype: called CC=7 SCAR=23.8
997 42 my ($self, %opts) = @_;
998  
999 42 ▶ $self->_valid_image
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image or return 42 0 42
1000 or return;
1001  
1002 42 ▶ my $x = $opts{xsize} || $self->getwidth;
Condition33%1/3
$opts{'xsize'} || $self->getwidth
l!l&&r!l&&!r
4200
MC/DC0%0/2
$opts{'xsize'} || $self->getwidth
$opts{'xsize'} $self->getwidth
Truth table33%1/3
A || B
A= $opts{'xsize'}B= $self->getwidth
ABresult
1X1
011
000
1003 42 ▶ my $y = $opts{ysize} || $self->getheight;
Condition33%1/3
$opts{'ysize'} || $self->getheight
l!l&&r!l&&!r
4200
MC/DC0%0/2
$opts{'ysize'} || $self->getheight
$opts{'ysize'} $self->getheight
Truth table33%1/3
A || B
A= $opts{'ysize'}B= $self->getheight
ABresult
1X1
011
000
1004 42 ▶ my $channels = $opts{channels} || $self->getchannels;
Condition33%1/3
$opts{'channels'} || $self->getchannels
l!l&&r!l&&!r
0420
MC/DC0%0/2
$opts{'channels'} || $self->getchannels
$opts{'channels'} $self->getchannels
Truth table33%1/3
A || B
A= $opts{'channels'}B= $self->getchannels
ABresult
1X1
011
000
1005
1006 42 my $out = Imager->new;
1007 42 ▶ if ($channels == $self->getchannels) {
Branch: 1 branch
BranchTrueFalseTotal
if ($channels == $self->getchannels) { } 42 0 42
1008 42 $out->{IMG} = i_sametype($self->{IMG}, $x, $y);
1009 }
1010 else {
1011 0 $out->{IMG} = i_sametype_chans($self->{IMG}, $x, $y, $channels);
1012 }
1013 42 ▶ unless ($out->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($out->{"IMG"}) 0 42 42
1014 0 $self->{ERRSTR} = $self->_error_as_msg;
1015 0 return;
1016 }
1017
1018 42 return $out;
1019 }
1020  
1021 # Sets an image to a certain size and channel number
1022 # if there was previously data in the image it is discarded
1023  
1024 79 my %model_channels =
1025 (
1026 gray => 1,
1027 graya => 2,
1028 rgb => 3,
1029 rgba => 4,
1030 );
1031  
1032 607 ▶sub img_set {
Subroutine img_set: called CC=8 SCAR=20.9
Pod undocumented
1033 607 my $self=shift;
1034  
1035 607 my %hsh=(xsize=>100, ysize=>100, channels=>3, bits=>8, type=>'direct', @_);
1036  
1037 607 undef($self->{IMG});
1038  
1039 607 ▶ if ($hsh{model}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($hsh{"model"}) 8 599 607
1040 8 ▶ if (my $channels = $model_channels{$hsh{model}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $channels = $model_channels{$hsh{'model'}}) { } 8 0 8
1041 8 $hsh{channels} = $channels;
1042 }
1043 else {
1044 0 $self->_set_error("new: unknown value for model '$hsh{model}'");
1045 0 return;
1046 }
1047 }
1048  
1049 607 ▶ if ($hsh{type} eq 'paletted' || $hsh{type} eq 'pseudo') {
Branch: 3 branches
BranchTrueFalseTotal
if ($hsh{'type'} eq 'paletted' or $hsh{'type'} eq 'pseudo') { } 30 577 607
elsif ($hsh{'bits'} eq 'double') { } 70 507 577
elsif ($hsh{'bits'} == 16) { } 27 480 507
Condition100%3/3
$hsh{"type"} eq "paletted" or $hsh{"type"} eq "pseudo"
l!l&&r!l&&!r
291577
MC/DC100%2/2
$hsh{"type"} eq "paletted" or $hsh{"type"} eq "pseudo"
$hsh{"type"} eq "paletted" $hsh{"type"} eq "pseudo"
Truth table100%3/3
A or B
A= $hsh{"type"} eq "paletted"B= $hsh{"type"} eq "pseudo"
ABresult
1X1
011
000
1050 $self->{IMG} = i_img_pal_new($hsh{xsize}, $hsh{ysize}, $hsh{channels},
1051 30 256);
1052 }
1053 elsif ($hsh{bits} eq 'double') {
1054 70 $self->{IMG} = i_img_double_new($hsh{xsize}, $hsh{ysize}, $hsh{channels});
1055 }
1056 elsif ($hsh{bits} == 16) {
1057 27 $self->{IMG} = i_img_16_new($hsh{xsize}, $hsh{ysize}, $hsh{channels});
1058 }
1059 else {
1060 $self->{IMG}= i_img_8_new($hsh{'xsize'}, $hsh{'ysize'},
1061 480 $hsh{'channels'});
1062 }
1063  
1064 607 ▶ unless ($self->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->{"IMG"}) 25 582 607
1065 25 $self->_set_error(Imager->_error_as_msg());
1066 25 return;
1067 }
1068  
1069 582 $self;
1070 }
1071  
1072 # created a masked version of the current image
1073 17 ▶sub masked {
Subroutine masked: called CC=8 SCAR=20.8
Pod undocumented
1074 17 my $self = shift;
1075  
1076 17 ▶ $self->_valid_image("masked")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("masked") or return 16 1 17
1077 or return;
1078  
1079 16 my %opts = (left => 0,
1080 top => 0,
1081 right => $self->getwidth,
1082 bottom => $self->getheight,
1083 @_);
1084 16 ▶ my $mask = $opts{mask} ? $opts{mask}{IMG} : undef;
Branch: 1 branch
BranchTrueFalseTotal
$opts{'mask'} ? : 3 13 16
1085  
1086 16 my ($left, $top, $right, $bottom) = @opts{qw(left top right bottom)};
1087 16 for my $val ($left, $right) {
1088 32 ▶ if ($val < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($val < 0) 3 29 32
1089 3 $val = $self->getwidth() + $val;
1090 }
1091 }
1092 16 for my $val ($top, $bottom) {
1093 32 ▶ if ($val < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($val < 0) 3 29 32
1094 3 $val = $self->getheight() + $val;
1095 }
1096 }
1097  
1098 16 my $result = Imager->new;
1099 16 $result->{IMG} = i_img_masked_new($self->{IMG}, $mask, $left,
1100 $top, $right - $left,
1101 $bottom - $top);
1102 16 ▶ unless ($result->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result->{"IMG"}) 7 9 16
1103 7 $self->_set_error(Imager->_error_as_msg);
1104 7 return;
1105 }
1106  
1107 # keep references to the mask and base images so they don't
1108 # disappear on us
1109 9 $result->{DEPENDS} = [ $self->{IMG}, $mask ];
1110  
1111 9 return $result;
1112 }
1113  
1114 # convert an RGB image into a paletted image
1115 14 ▶sub to_paletted {
Subroutine to_paletted: called CC=6 SCAR=17.9
Pod undocumented
1116 14 my $self = shift;
1117 14 my $opts;
1118 14 ▶ if (@_ != 1 && !ref $_[0]) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_ != 1 and not ref $_[0]) { } 13 1 14
Condition66%2/3
@_ != 1 and not ref $_[0]
!ll&&!rl&&r
1013
MC/DC50%1/2
@_ != 1 and not ref $_[0]
@_ != 1 not ref $_[0]
Truth table66%2/3
A and not(B)
A= @_ != 1B= not ref $_[0]
ABresult
0X0
100
111
1119 13 $opts = { @_ };
1120 }
1121 else {
1122 1 $opts = shift;
1123 }
1124  
1125 14 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 13 14
1126 1 my @caller = caller;
1127 1 warn "to_paletted() called in void context - to_paletted() returns the converted image at $caller[1] line $caller[2]\n";
1128 1 return;
1129 }
1130  
1131 13 ▶ $self->_valid_image("to_paletted")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("to_paletted") or return 12 1 13
1132 or return;
1133  
1134 12 my $result = Imager->new;
1135 12 ▶ unless ($result->{IMG} = i_img_to_pal($self->{IMG}, $opts)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result->{"IMG"} = &i_img_to_pal($self->{"IMG"}, $opts)) 2 10 12
1136 2 $self->_set_error(Imager->_error_as_msg);
1137 2 return;
1138 }
1139  
1140 10 return $result;
1141 }
1142  
1143 7 ▶sub make_palette {
Subroutine make_palette: called CC=5 SCAR=16.1
Pod undocumented
1144 7 my ($class, $quant, @images) = @_;
1145  
1146 7 ▶ unless (@images) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@images) 1 6 7
1147 1 Imager->_set_error("make_palette: supply at least one image");
1148 1 return;
1149 }
1150 6 my $index = 1;
1151 6 for my $img (@images) {
1152 7 ▶ unless ($img->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($img->{"IMG"}) 1 6 7
1153 1 Imager->_set_error("make_palette: image $index is empty");
1154 1 return;
1155 }
1156 6 ++$index;
1157 }
1158  
1159 5 my @cols = i_img_make_palette($quant, map $_->{IMG}, @images);
1160 5 ▶ unless (@cols) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@cols) 1 4 5
1161 1 Imager->_set_error(Imager->_error_as_msg);
1162 1 return;
1163 }
1164 4 return @cols;
1165 }
1166  
1167 # convert a paletted (or any image) to an 8-bit/channel RGB image
1168 3 ▶sub to_rgb8 {
Subroutine to_rgb8: called CC=4 SCAR=14.1
Pod undocumented
1169 3 my $self = shift;
1170  
1171 3 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 2 3
1172 1 my @caller = caller;
1173 1 warn "to_rgb8() called in void context - to_rgb8() returns the converted image at $caller[1] line $caller[2]\n";
1174 1 return;
1175 }
1176  
1177 2 ▶ $self->_valid_image("to_rgb8")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("to_rgb8") or return 1 1 2
1178 or return;
1179  
1180 1 my $result = Imager->new;
1181 1 ▶ unless ($result->{IMG} = i_img_to_rgb($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result->{"IMG"} = &i_img_to_rgb($self->{"IMG"})) 0 1 1
1182 0 $self->_set_error(Imager->_error_as_msg());
1183 0 return;
1184 }
1185  
1186 1 return $result;
1187 }
1188  
1189 # convert a paletted (or any image) to a 16-bit/channel RGB image
1190 9 ▶sub to_rgb16 {
Subroutine to_rgb16: called CC=4 SCAR=16.3
Pod undocumented
1191 9 my $self = shift;
1192  
1193 9 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 0 9 9
1194 0 my @caller = caller;
1195 0 warn "to_rgb16() called in void context - to_rgb16() returns the converted image at $caller[1] line $caller[2]\n";
1196 0 return;
1197 }
1198  
1199 9 ▶ $self->_valid_image("to_rgb16")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("to_rgb16") or return 8 1 9
1200 or return;
1201  
1202 8 my $result = Imager->new;
1203 8 ▶ unless ($result->{IMG} = i_img_to_rgb16($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result->{"IMG"} = &i_img_to_rgb16($self->{"IMG"})) 0 8 8
1204 0 $self->_set_error(Imager->_error_as_msg());
1205 0 return;
1206 }
1207  
1208 8 return $result;
1209 }
1210  
1211 # convert a paletted (or any image) to an double/channel RGB image
1212 3 ▶sub to_rgb_double {
Subroutine to_rgb_double: called CC=4 SCAR=16.3
Pod undocumented
1213 3 my $self = shift;
1214  
1215 3 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 0 3 3
1216 0 my @caller = caller;
1217 0 warn "to_rgb16() called in void context - to_rgb_double() returns the converted image at $caller[1] line $caller[2]\n";
1218 0 return;
1219 }
1220  
1221 3 ▶ $self->_valid_image("to_rgb_double")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("to_rgb_double") or return 2 1 3
1222 or return;
1223  
1224 2 my $result = Imager->new;
1225 2 ▶ unless ($result->{IMG} = i_img_to_drgb($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result->{"IMG"} = &i_img_to_drgb($self->{"IMG"})) 0 2 2
1226 0 $self->_set_error(Imager->_error_as_msg());
1227 0 return;
1228 }
1229  
1230 2 return $result;
1231 }
1232  
1233 29 ▶sub addcolors {
Subroutine addcolors: called CC=5 SCAR=16.1
Pod undocumented
1234 29 my $self = shift;
1235 29 my %opts = (colors=>[], @_);
1236  
1237 29 ▶ $self->_valid_image("addcolors")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("addcolors") or return -1 28 1 29
1238 or return -1;
1239  
1240 28 ▶ my @colors = @{$opts{colors}}
Branch: 1 branch
BranchTrueFalseTotal
my(@colors) = @{$opts{"colors"};} or return undef 28 0 28
1241 or return undef;
1242  
1243 28 for my $color (@colors) {
1244 90 $color = _color($color);
1245 90 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 1 89 90
1246 1 $self->_set_error($Imager::ERRSTR);
1247 1 return;
1248 }
1249 }
1250  
1251 27 return i_addcolors($self->{IMG}, @colors);
1252 }
1253  
1254 12 ▶sub setcolors {
Subroutine setcolors: called CC=5 SCAR=16.1
Pod undocumented
1255 12 my $self = shift;
1256 12 my %opts = (start=>0, colors=>[], @_);
1257  
1258 12 ▶ $self->_valid_image("setcolors")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("setcolors") or return 11 1 12
1259 or return;
1260  
1261 11 ▶ my @colors = @{$opts{colors}}
Branch: 1 branch
BranchTrueFalseTotal
my(@colors) = @{$opts{"colors"};} or return undef 10 1 11
1262 or return undef;
1263  
1264 10 for my $color (@colors) {
1265 14 $color = _color($color);
1266 14 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 1 13 14
1267 1 $self->_set_error($Imager::ERRSTR);
1268 1 return;
1269 }
1270 }
1271  
1272 9 return i_setcolors($self->{IMG}, $opts{start}, @colors);
1273 }
1274  
1275 15 ▶sub getcolors {
Subroutine getcolors: called CC=6 SCAR=18.8
Pod undocumented
1276 15 my $self = shift;
1277 15 my %opts = @_;
1278  
1279 15 ▶ $self->_valid_image("getcolors")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getcolors") or return 14 1 15
1280 or return;
1281  
1282 14 ▶ if (!exists $opts{start} && !exists $opts{count}) {
Branch: 3 branches
BranchTrueFalseTotal
if (not exists $opts{'start'} || exists $opts{'count'}) { } 9 5 14
elsif (not exists $opts{'count'}) { } 5 0 5
elsif (not exists $opts{'start'}) { } 0 0 0
Condition66%2/3
exists $opts{'start'} || exists $opts{'count'}
l!l&&r!l&&!r
509
MC/DC50%1/2
exists $opts{'start'} || exists $opts{'count'}
exists $opts{'start'} exists $opts{'count'}
Truth table66%2/3
A || B
A= exists $opts{'start'}B= exists $opts{'count'}
ABresult
1X1
011
000
1283 # get them all
1284 9 $opts{start} = 0;
1285 9 $opts{count} = $self->colorcount;
1286 }
1287 elsif (!exists $opts{count}) {
1288 5 $opts{count} = 1;
1289 }
1290 elsif (!exists $opts{start}) {
1291 0 $opts{start} = 0;
1292 }
1293  
1294 14 return i_getcolors($self->{IMG}, $opts{start}, $opts{count});
1295 }
1296  
1297 20 ▶sub colorcount {
Subroutine colorcount: called CC=2 SCAR=6.9
Pod undocumented
1298 20 my ($self) = @_;
1299  
1300 20 ▶ $self->_valid_image("colorcount")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("colorcount") or return -1 19 1 20
1301 or return -1;
1302  
1303 19 return i_colorcount($self->{IMG});
1304 }
1305  
1306 3 ▶sub maxcolors {
Subroutine maxcolors: called CC=2 SCAR=6.9
Pod undocumented
1307 3 my $self = shift;
1308  
1309 3 ▶ $self->_valid_image("maxcolors")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("maxcolors") or return -1 2 1 3
1310 or return -1;
1311  
1312 2 i_maxcolors($self->{IMG});
1313 }
1314  
1315 9 ▶sub findcolor {
Subroutine findcolor: called CC=4 SCAR=14.8
Pod undocumented
1316 9 my $self = shift;
1317 9 my %opts = @_;
1318  
1319 9 ▶ $self->_valid_image("findcolor")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("findcolor") or return 8 1 9
1320 or return;
1321  
1322 8 ▶ unless ($opts{color}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"color"}) 0 8 8
1323 0 $self->_set_error("findcolor: no color parameter");
1324 0 return;
1325 }
1326  
1327 my $color = _color($opts{color})
1328 8 ▶ or return;
Branch: 1 branch
BranchTrueFalseTotal
my $color = _color($opts{"color"}) or return 8 0 8
1329  
1330 8 return i_findcolor($self->{IMG}, $color);
1331 }
1332  
1333 61 ▶sub bits {
Subroutine bits: called CC=4 SCAR=13.9
Pod undocumented
1334 61 my $self = shift;
1335  
1336 61 ▶ $self->_valid_image("bits")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("bits") or return 60 1 61
1337 or return;
1338  
1339 60 my $bits = i_img_bits($self->{IMG});
1340 60 ▶ if ($bits && $bits == length(pack("d", 1)) * 8) {
Branch: 1 branch
BranchTrueFalseTotal
if ($bits and $bits == 64) 12 48 60
Condition66%2/3
$bits and $bits == 64
!ll&&!rl&&r
04812
MC/DC50%1/2
$bits and $bits == 64
$bits $bits == 64
Truth table66%2/3
A and B
A= $bitsB= $bits == 64
ABresult
0X0
100
111
1341 12 $bits = 'double';
1342 }
1343 60 return $bits;
1344 }
1345  
1346 70 ▶sub type {
Subroutine type: called CC=3 SCAR=11.0
Pod undocumented
1347 70 my $self = shift;
1348  
1349 70 ▶ $self->_valid_image("type")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("type") or return 69 1 70
1350 or return;
1351  
1352 69 ▶ return i_img_type($self->{IMG}) ? "paletted" : "direct";
Branch: 1 branch
BranchTrueFalseTotal
&i_img_type($self->{'IMG'}) ? : 40 29 69
1353 }
1354  
1355 2 ▶sub virtual {
Subroutine virtual: called CC=2 SCAR=6.9
Pod undocumented
1356 2 my $self = shift;
1357  
1358 2 ▶ $self->_valid_image("virtual")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("virtual") or return 1 1 2
1359 or return;
1360  
1361 1 return i_img_virtual($self->{IMG});
1362 }
1363  
1364 25 ▶sub is_bilevel {
Subroutine is_bilevel: called CC=2 SCAR=6.9
Pod undocumented
1365 25 my ($self) = @_;
1366  
1367 25 ▶ $self->_valid_image("is_bilevel")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("is_bilevel") or return 24 1 25
1368 or return;
1369  
1370 24 return i_img_is_monochrome($self->{IMG});
1371 }
1372  
1373 154 ▶sub tags {
Subroutine tags: called CC=8 SCAR=28.2
Pod undocumented
1374 154 my ($self, %opts) = @_;
1375  
1376 154 ▶ $self->_valid_image("tags")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("tags") or return 153 1 154
1377 or return;
1378  
1379 153 ▶ if (defined $opts{name}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $opts{'name'}) { } 153 0 153
elsif (defined $opts{'code'}) { } 0 0 0
1380 153 my @result;
1381 153 my $start = 0;
1382 153 my $found;
1383 153 ▶ while (defined($found = i_tags_find($self->{IMG}, $opts{name}, $start))) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined($found = &i_tags_find($self->{"IMG"}, $opts{"name"}, $start))) 150 153 303
1384 150 push @result, (i_tags_get($self->{IMG}, $found))[1];
1385 150 $start = $found+1;
1386 }
1387 153 ▶ return wantarray ? @result : $result[0];
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 5 148 153
1388 }
1389 elsif (defined $opts{code}) {
1390 0 my @result;
1391 0 my $start = 0;
1392 0 my $found;
1393 0 ▶ while (defined($found = i_tags_findn($self->{IMG}, $opts{code}, $start))) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined($found = &i_tags_findn($self->{"IMG"}, $opts{"code"}, $start))) 0 0 0
1394 0 push @result, (i_tags_get($self->{IMG}, $found))[1];
1395 0 $start = $found+1;
1396 }
1397 0 return @result;
1398 }
1399 else {
1400 0 ▶ if (wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
if (wantarray) { } 0 0 0
1401 0 return map { [ i_tags_get($self->{IMG}, $_) ] } 0.. i_tags_count($self->{IMG})-1;
1402 }
1403 else {
1404 0 return i_tags_count($self->{IMG});
1405 }
1406 }
1407 }
1408  
1409 79 my $int_re = qr/^(?:0|-[1-9][0-9]*|[1-9][0-9]*)$/;
1410  
1411 55 ▶sub addtag {
Subroutine addtag: called CC=15 SCAR=34.4
Pod undocumented
1412 55 my $self = shift;
1413 55 my %opts = @_;
1414  
1415 55 ▶ $self->_valid_image("addtag")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("addtag") or return 54 1 55
1416 or return;
1417  
1418 54 my $value = $opts{value};
1419 54 ▶ if ($opts{name}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'name'}) { } 52 2 54
elsif ($opts{'code'}) { } 2 0 2
1420 52 ▶ if (defined $value) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $value) { } 52 0 52
elsif (defined $opts{'data'}) { } 0 0 0
1421 52 ▶ if ($value =~ $int_re && $value >= INT_MIN && $value <= INT_MAX) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /$int_re/ and $value >= -2147483648 and $value <= 2147483647) { } 32 20 52
Condition83%5/6
$value =~ /$int_re/ and $value >= '-2147483648' and $value <= 2147483647
!ll&&!rl&&r
17332
$value =~ /$int_re/ and $value >= '-2147483648'
!ll&&!rl&&r
17035
MC/DC66%2/3
$value =~ /$int_re/ and $value >= '-2147483648' and $value <= 2147483647
$value =~ /$int_re/ $value >= '-2147483648' $value <= 2147483647
Truth table75%3/4
A and B and C
A= $value =~ /$int_re/B= $value >= '-2147483648'C= $value <= 2147483647
ABCresult
0XX0
10X0
1100
1111
1422 # add as an int
1423 32 return i_tags_addn($self->{IMG}, $opts{name}, 0, $value);
1424 }
1425 else {
1426 20 return i_tags_add($self->{IMG}, $opts{name}, 0, $value, 0);
1427 }
1428 }
1429 elsif (defined $opts{data}) {
1430 # force addition as a string
1431 0 return i_tags_add($self->{IMG}, $opts{name}, 0, $opts{data}, 0);
1432 }
1433 else {
1434 0 $self->{ERRSTR} = "No value supplied";
1435 0 return undef;
1436 }
1437 }
1438 elsif ($opts{code}) {
1439 2 ▶ warnings::warnif("Imager::tagcodes", "addtag: code parameter is deprecated")
Branch: 1 branch
BranchTrueFalseTotal
if $] >= "5.014" 2 0 2
1440 if $] >= 5.014;
1441 2 ▶ if (defined $value) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $value) { } 2 0 2
elsif (defined $opts{'data'}) { } 0 0 0
1442 2 ▶ if ($value =~ $int_re && $value >= INT_MIN && $value <= INT_MAX) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /$int_re/ and $value >= -2147483648 and $value <= 2147483647) { } 2 0 2
Condition33%2/6
$value =~ /$int_re/ and $value >= '-2147483648' and $value <= 2147483647
!ll&&!rl&&r
002
$value =~ /$int_re/ and $value >= '-2147483648'
!ll&&!rl&&r
002
MC/DC0%0/3
$value =~ /$int_re/ and $value >= '-2147483648' and $value <= 2147483647
$value =~ /$int_re/ $value >= '-2147483648' $value <= 2147483647
Truth table25%1/4
A and B and C
A= $value =~ /$int_re/B= $value >= '-2147483648'C= $value <= 2147483647
ABCresult
0XX0
10X0
1100
1111
1443 # add as a number
1444 2 return i_tags_addn($self->{IMG}, $opts{code}, 0, $opts{value});
1445 }
1446 else {
1447 0 return i_tags_add($self->{IMG}, $opts{code}, 0, $opts{value}, 0);
1448 }
1449 }
1450 elsif (defined $opts{data}) {
1451 # force addition as a string
1452 0 return i_tags_add($self->{IMG}, $opts{code}, 0, $opts{data}, 0);
1453 }
1454 else {
1455 0 $self->{ERRSTR} = "No value supplied";
1456 0 return undef;
1457 }
1458 }
1459 else {
1460 0 return undef;
1461 }
1462 }
1463  
1464 41 ▶sub deltag {
Subroutine deltag: called CC=6 SCAR=24.8
Pod undocumented
1465 41 my $self = shift;
1466 41 my %opts = @_;
1467  
1468 41 ▶ $self->_valid_image("deltag")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("deltag") or return 0 40 1 41
1469 or return 0;
1470  
1471 40 ▶ if (defined $opts{'index'}) {
Branch: 3 branches
BranchTrueFalseTotal
if (defined $opts{'index'}) { } 0 40 40
elsif (defined $opts{'name'}) { } 40 0 40
elsif (defined $opts{'code'}) { } 0 0 0
1472 0 return i_tags_delete($self->{IMG}, $opts{'index'});
1473 }
1474 elsif (defined $opts{name}) {
1475 40 return i_tags_delbyname($self->{IMG}, $opts{name});
1476 }
1477 elsif (defined $opts{code}) {
1478 0 ▶ warnings::warnif("Imager::tagcodes", "deltag: code parameter is deprecated")
Branch: 1 branch
BranchTrueFalseTotal
if $] >= "5.014" 0 0 0
1479 if $] >= 5.014;
1480 0 return i_tags_delbycode($self->{IMG}, $opts{code});
1481 }
1482 else {
1483 0 $self->{ERRSTR} = "Need to supply index, name, or code parameter";
1484 0 return 0;
1485 }
1486 }
1487  
1488 43 ▶sub settag {
Subroutine settag: called CC=8 SCAR=24.4
Pod undocumented
1489 43 my ($self, %opts) = @_;
1490  
1491 43 ▶ $self->_valid_image("settag")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("settag") or return 42 1 43
1492 or return;
1493  
1494 42 ▶ if ($opts{name}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'name'}) { } 40 2 42
elsif (defined $opts{'code'}) { } 2 0 2
1495 40 $self->deltag(name=>$opts{name});
1496 40 return $self->addtag(name=>$opts{name}, value=>$opts{value});
1497 }
1498 elsif (defined $opts{code}) {
1499 2 ▶ warnings::warnif("Imager::tagcodes", "settag: code parameter is deprecated")
Branch: 1 branch
BranchTrueFalseTotal
if $] >= "5.014" 2 0 2
1500 if $] >= 5.014;
1501 2 i_tags_delbycode($self->{IMG}, $opts{code});
1502 2 ▶ if (defined $opts{value}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $opts{'value'}) { } 2 0 2
elsif (defined $opts{'data'}) { } 0 0 0
1503 2 ▶ if ($opts{value} =~ /^\d+$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'value'} =~ /^\d+$/) { } 2 0 2
1504 # add as a number
1505 2 return i_tags_addn($self->{IMG}, $opts{code}, 0, $opts{value});
1506 }
1507 else {
1508 0 return i_tags_add($self->{IMG}, $opts{code}, 0, $opts{value}, 0);
1509 }
1510 }
1511 elsif (defined $opts{data}) {
1512 # force addition as a string
1513 0 return i_tags_add($self->{IMG}, $opts{code}, 0, $opts{data}, 0);
1514 }
1515 else {
1516 0 $self->{ERRSTR} = "No value supplied";
1517 0 return undef;
1518 }
1519 }
1520 else {
1521 0 return undef;
1522 }
1523 }
1524  
1525  
1526 346 ▶sub _get_reader_io {
Subroutine _get_reader_io: called CC=13 SCAR=31.1
1527 346 my ($self, $input) = @_;
1528  
1529 346 ▶ if ($input->{io}) {
Branch: 6 branches
BranchTrueFalseTotal
if ($input->{'io'}) { } 0 346 346
elsif ($input->{'fd'}) { } 4 342 346
elsif ($input->{'fh'}) { } 11 331 342
elsif ($input->{'file'}) { } 176 155 331
elsif ($input->{'data'}) { } 147 8 155
elsif ($input->{'callback'} or $input->{'readcb'}) { } 8 0 8
1530 0 return $input->{io}, undef;
1531 }
1532 elsif ($input->{fd}) {
1533 4 return io_new_fd($input->{fd});
1534 }
1535 elsif ($input->{fh}) {
1536 11 ▶ unless (Scalar::Util::openhandle($input->{fh})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&Scalar::Util::openhandle($input->{"fh"})) 0 11 11
1537 0 $self->_set_error("Handle in fh option not opened");
1538 0 return;
1539 }
1540 11 return Imager::IO->new_fh($input->{fh});
1541 }
1542 elsif ($input->{file}) {
1543 176 my $file;
1544 176 ▶ unless (open $file, "<", $input->{file}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (CORE::open $file, "<", $input->{"file"}) 0 176 176
1545 0 $self->_set_error("Could not open $input->{file}: $!");
1546 0 return;
1547 }
1548 176 binmode $file;
1549 176 return (io_new_fd(fileno($file)), $file);
1550 }
1551 elsif ($input->{data}) {
1552 147 return io_new_buffer($input->{data});
1553 }
1554 ▶ elsif ($input->{callback} || $input->{readcb}) {
Condition33%1/3
$input->{"callback"} or $input->{"readcb"}
l!l&&r!l&&!r
800
MC/DC0%0/2
$input->{"callback"} or $input->{"readcb"}
$input->{"callback"} $input->{"readcb"}
Truth table33%1/3
A or B
A= $input->{"callback"}B= $input->{"readcb"}
ABresult
1X1
011
000
1555 8 ▶ if (!$input->{seekcb}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($input->{"seekcb"}) 0 8 8
1556 0 $self->_set_error("Need a seekcb parameter");
1557 }
1558 8 ▶ my $sizecb = defined $input->{size} ? 0+$input->{size} : $input->{sizecb};
Branch: 1 branch
BranchTrueFalseTotal
defined $input->{'size'} ? : 0 8 8
1559 return io_new_cb($input->{writecb},
1560 $input->{callback} || $input->{readcb},
1561 $input->{seekcb}, $input->{closecb},
1562 8 ▶ $sizecb);
Condition33%1/3
$input->{'callback'} || $input->{'readcb'}
l!l&&r!l&&!r
800
MC/DC0%0/2
$input->{'callback'} || $input->{'readcb'}
$input->{'callback'} $input->{'readcb'}
Truth table33%1/3
A || B
A= $input->{'callback'}B= $input->{'readcb'}
ABresult
1X1
011
000
1563 }
1564 else {
1565 0 $self->_set_error("file/fd/fh/data/callback parameter missing");
1566 0 return;
1567 }
1568 }
1569  
1570 250 ▶sub _get_writer_io {
Subroutine _get_writer_io: called CC=14 SCAR=28.8
1571 250 my ($self, $input) = @_;
1572  
1573 250 ▶ my $buffered = exists $input->{buffered} ? $input->{buffered} : 1;
Branch: 1 branch
BranchTrueFalseTotal
exists $input->{'buffered'} ? : 1 249 250
1574  
1575 250 my $io;
1576 my @extras;
1577 250 ▶ if ($input->{io}) {
Branch: 6 branches
BranchTrueFalseTotal
if ($input->{'io'}) { } 48 202 250
elsif ($input->{'fd'}) { } 0 202 202
elsif ($input->{'fh'}) { } 6 196 202
elsif ($input->{'file'}) { } 131 65 196
elsif ($input->{'data'}) { } 49 16 65
elsif ($input->{'callback'} or $input->{'writecb'}) { } 16 0 16
1578 48 $io = $input->{io};
1579 }
1580 elsif ($input->{fd}) {
1581 0 $io = io_new_fd($input->{fd});
1582 }
1583 elsif ($input->{fh}) {
1584 6 ▶ unless (Scalar::Util::openhandle($input->{fh})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&Scalar::Util::openhandle($input->{"fh"})) 0 6 6
1585 0 $self->_set_error("Handle in fh option not opened");
1586 0 return;
1587 }
1588 6 $io = Imager::IO->new_fh($input->{fh});
1589 }
1590 elsif ($input->{file}) {
1591 131 my $fh;
1592 131 ▶ unless (open $fh, "+>", $input->{file}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (CORE::open $fh, "+>", $input->{"file"}) 0 131 131
1593 0 $self->_set_error("Could not open file $input->{file}: $!");
1594 0 return;
1595 }
1596 131 ▶ binmode($fh) or die;
Branch: 1 branch
BranchTrueFalseTotal
binmode $fh or die 131 0 131
1597 131 $io = io_new_fd(fileno($fh));
1598 131 push @extras, $fh;
1599 }
1600 elsif ($input->{data}) {
1601 49 $io = io_new_bufchain();
1602 }
1603 ▶ elsif ($input->{callback} || $input->{writecb}) {
Condition66%2/3
$input->{"callback"} or $input->{"writecb"}
l!l&&r!l&&!r
880
MC/DC0%0/2
$input->{"callback"} or $input->{"writecb"}
$input->{"callback"} $input->{"writecb"}
Truth table66%2/3
A or B
A= $input->{"callback"}B= $input->{"writecb"}
ABresult
1X1
011
000
1604 $io = io_new_cb($input->{callback} || $input->{writecb},
1605 $input->{readcb}, $input->{seekcb},
1606 16 ▶ $input->{closecb});
Condition66%2/3
$input->{'callback'} || $input->{'writecb'}
l!l&&r!l&&!r
880
MC/DC0%0/2
$input->{'callback'} || $input->{'writecb'}
$input->{'callback'} $input->{'writecb'}
Truth table66%2/3
A || B
A= $input->{'callback'}B= $input->{'writecb'}
ABresult
1X1
011
000
1607 }
1608 else {
1609 0 $self->_set_error("file/fd/fh/data/callback parameter missing");
1610 0 return;
1611 }
1612  
1613 250 ▶ unless ($buffered) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($buffered) 1 249 250
1614 1 $io->set_buffered(0);
1615 }
1616  
1617 250 return ($io, @extras);
1618 }
1619  
1620 188 ▶sub _test_format {
Subroutine _test_format: called CC=1 SCAR=0.0
1621 188 my ($io) = @_;
1622  
1623 188 return i_test_format_probe($io, -1);
1624 }
1625  
1626 1 ▶sub add_file_magic {
Subroutine add_file_magic: called CC=2 SCAR=7.5
Pod undocumented
1627 1 my ($class, %opts) = @_;
1628  
1629 1 my $name = delete $opts{name};
1630 1 my $bits = delete $opts{bits};
1631 1 my $mask = delete $opts{mask};
1632  
1633 1 ▶ unless (i_add_file_magic($name, $bits, $mask)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_add_file_magic($name, $bits, $mask)) 0 1 1
1634 0 Imager->_set_error(Imager->_error_as_msg);
1635 0 return;
1636 }
1637  
1638 1 1;
1639 }
1640  
1641 # Read an image from file
1642  
1643 336 ▶sub read {
Subroutine read: called CC=27 SCAR=33.2
Pod undocumented
1644 336 my $self = shift;
1645 336 my %input=@_;
1646  
1647 336 ▶ if (defined($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $self->{"IMG"}) 29 307 336
1648 # let IIM_DESTROY do the destruction, since the image may be
1649 # referenced from elsewhere
1650 #i_img_destroy($self->{IMG});
1651 29 undef($self->{IMG});
1652 }
1653  
1654 336 ▶ my ($IO, $fh) = $self->_get_reader_io(\%input) or return;
Branch: 1 branch
BranchTrueFalseTotal
() = $self->_get_reader_io(\%input) or return 336 0 336
1655  
1656 336 my $type = $input{'type'};
1657 336 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 151 185 336
1658 151 $type = _test_format($IO);
1659 }
1660  
1661 336 ▶ if ($input{file} && !$type) {
Branch: 1 branch
BranchTrueFalseTotal
if ($input{"file"} and not $type) 1 335 336
Condition100%3/3
$input{"file"} and not $type
!ll&&!rl&&r
1661691
MC/DC100%2/2
$input{"file"} and not $type
$input{"file"} not $type
Truth table100%3/3
A and not(B)
A= $input{"file"}B= not $type
ABresult
0X0
100
111
1662 # guess the type
1663 1 $type = $FORMATGUESS->($input{file});
1664 }
1665  
1666 336 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 2 334 336
1667 2 my $msg = "type parameter missing and it couldn't be determined from the file contents";
1668 2 ▶ $input{file} and $msg .= " or file name";
Branch: 1 branch
BranchTrueFalseTotal
$input{"file"} and $msg .= ' or file name' 1 1 2
1669 2 $self->_set_error($msg);
1670 2 return undef;
1671 }
1672  
1673 334 _reader_autoload($type);
1674  
1675 334 ▶ if ($readers{$type} && $readers{$type}{single}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($readers{$type} and $readers{$type}{"single"}) 96 238 334
Condition66%2/3
$readers{$type} and $readers{$type}{"single"}
!ll&&!rl&&r
238096
MC/DC50%1/2
$readers{$type} and $readers{$type}{"single"}
$readers{$type} $readers{$type}{"single"}
Truth table66%2/3
A and B
A= $readers{$type}B= $readers{$type}{"single"}
ABresult
0X0
100
111
1676 96 return $readers{$type}{single}->($self, $IO, %input);
1677 }
1678  
1679 238 ▶ unless ($formats_low{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($formats_low{$type}) 3 235 238
1680 3 my $read_types = join ', ', sort Imager->read_types();
1681 3 $self->_set_error("format '$type' not supported - formats $read_types available for reading - $reader_load_errors{$type}");
1682 3 return;
1683 }
1684  
1685 235 my $allow_incomplete = $input{allow_incomplete};
1686 235 ▶ defined $allow_incomplete or $allow_incomplete = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $allow_incomplete or $allow_incomplete = 0 19 216 235
1687  
1688 235 ▶ if ( $type eq 'pnm' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "pnm") 83 152 235
1689 83 $self->{IMG}=i_readpnm_wiol( $IO, $allow_incomplete );
1690 83 ▶ if ( !defined($self->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->{"IMG"}) 22 61 83
1691 22 $self->{ERRSTR}='unable to read pnm image: '._error_as_msg();
1692 22 return undef;
1693 }
1694 61 ▶ $self->{DEBUG} && print "loading a pnm file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "loading a pnm file\n" 0 61 61
1695 61 return $self;
1696 }
1697  
1698 152 ▶ if ( $type eq 'bmp' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "bmp") 98 54 152
1699 98 $self->{IMG}=i_readbmp_wiol( $IO, $allow_incomplete );
1700 98 ▶ if ( !defined($self->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->{"IMG"}) 46 52 98
1701 46 $self->{ERRSTR}=$self->_error_as_msg();
1702 46 return undef;
1703 }
1704 52 ▶ $self->{DEBUG} && print "loading a bmp file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "loading a bmp file\n" 0 52 52
1705 }
1706  
1707 106 ▶ if ( $type eq 'tga' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "tga") 24 82 106
1708 24 $self->{IMG}=i_readtga_wiol( $IO, -1 ); # Fixme, check if that length parameter is ever needed
1709 24 ▶ if ( !defined($self->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->{"IMG"}) 6 18 24
1710 6 $self->{ERRSTR}=$self->_error_as_msg();
1711 6 return undef;
1712 }
1713 18 ▶ $self->{DEBUG} && print "loading a tga file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "loading a tga file\n" 0 18 18
1714 }
1715  
1716 100 ▶ if ( $type eq 'raw' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "raw") 30 70 100
1717 30 ▶ unless ( $input{xsize} && $input{ysize} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($input{"xsize"} and $input{"ysize"}) 0 30 30
Condition33%1/3
$input{"xsize"} and $input{"ysize"}
!ll&&!rl&&r
0030
MC/DC0%0/2
$input{"xsize"} and $input{"ysize"}
$input{"xsize"} $input{"ysize"}
Truth table33%1/3
A and B
A= $input{"xsize"}B= $input{"ysize"}
ABresult
0X0
100
111
1718 0 $self->_set_error('missing xsize or ysize parameter for raw');
1719 0 return undef;
1720 }
1721  
1722 30 my $interleave = _first($input{raw_interleave}, $input{interleave});
1723 30 ▶ unless (defined $interleave) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $interleave) 1 29 30
1724 1 my @caller = caller;
1725 1 warn "read(type => 'raw') $caller[2] line $caller[1]: supply interleave or raw_interleave for future compatibility\n";
1726 1 $interleave = 1;
1727 }
1728 30 my $data_ch = _first($input{raw_datachannels}, $input{datachannels}, 3);
1729 30 my $store_ch = _first($input{raw_storechannels}, $input{storechannels}, 3);
1730  
1731 $self->{IMG} = i_readraw_wiol( $IO,
1732 $input{xsize},
1733 $input{ysize},
1734 30 $data_ch,
1735 $store_ch,
1736 $interleave);
1737 30 ▶ if ( !defined($self->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->{"IMG"}) 10 20 30
1738 10 $self->{ERRSTR}=$self->_error_as_msg();
1739 10 return undef;
1740 }
1741 20 ▶ $self->{DEBUG} && print "loading a raw file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "loading a raw file\n" 0 20 20
1742 }
1743  
1744 90 return $self;
1745 }
1746  
1747 31 ▶sub register_reader {
Subroutine register_reader: called CC=6 SCAR=18.7
Pod undocumented
1748 31 my ($class, %opts) = @_;
1749  
1750 defined $opts{type}
1751 31 ▶ or die "register_reader called with no type parameter\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"type"} or die "register_reader called with no type parameter\n" 31 0 31
1752  
1753 31 my $type = $opts{type};
1754  
1755 defined $opts{single} || defined $opts{multiple}
1756 31 ▶ or die "register_reader called with no single or multiple parameter\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"single"} or defined $opts{"multiple"} or die "register_reader called with no single or multiple parameter\n" 31 0 31
Condition33%1/3
defined $opts{"single"} or defined $opts{"multiple"}
l!l&&r!l&&!r
3100
MC/DC0%0/2
defined $opts{"single"} or defined $opts{"multiple"}
defined $opts{"single"} defined $opts{"multiple"}
Truth table33%1/3
A or B
A= defined $opts{"single"}B= defined $opts{"multiple"}
ABresult
1X1
011
000
1757  
1758 31 $readers{$type} = { };
1759 31 ▶ if ($opts{single}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"single"}) 31 0 31
1760 31 $readers{$type}{single} = $opts{single};
1761 }
1762 31 ▶ if ($opts{multiple}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"multiple"}) 26 5 31
1763 26 $readers{$type}{multiple} = $opts{multiple};
1764 }
1765  
1766 31 return 1;
1767 }
1768  
1769 31 ▶sub register_writer {
Subroutine register_writer: called CC=6 SCAR=18.7
Pod undocumented
1770 31 my ($class, %opts) = @_;
1771  
1772 defined $opts{type}
1773 31 ▶ or die "register_writer called with no type parameter\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"type"} or die "register_writer called with no type parameter\n" 31 0 31
1774  
1775 31 my $type = $opts{type};
1776  
1777 defined $opts{single} || defined $opts{multiple}
1778 31 ▶ or die "register_writer called with no single or multiple parameter\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"single"} or defined $opts{"multiple"} or die "register_writer called with no single or multiple parameter\n" 31 0 31
Condition33%1/3
defined $opts{"single"} or defined $opts{"multiple"}
l!l&&r!l&&!r
3100
MC/DC0%0/2
defined $opts{"single"} or defined $opts{"multiple"}
defined $opts{"single"} defined $opts{"multiple"}
Truth table33%1/3
A or B
A= defined $opts{"single"}B= defined $opts{"multiple"}
ABresult
1X1
011
000
1779  
1780 31 $writers{$type} = { };
1781 31 ▶ if ($opts{single}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"single"}) 31 0 31
1782 31 $writers{$type}{single} = $opts{single};
1783 }
1784 31 ▶ if ($opts{multiple}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"multiple"}) 26 5 31
1785 26 $writers{$type}{multiple} = $opts{multiple};
1786 }
1787  
1788 31 return 1;
1789 }
1790  
1791 8 ▶sub read_types {
Subroutine read_types: called CC=1 SCAR=0.0
Pod undocumented
1792 my %types =
1793 (
1794 48 map { $_ => 1 }
1795 keys %readers,
1796 8 grep($file_formats{$_}, keys %formats),
1797 qw(ico sgi), # formats not handled directly, but supplied with Imager
1798 );
1799  
1800 8 return keys %types;
1801 }
1802  
1803 8 ▶sub write_types {
Subroutine write_types: called CC=1 SCAR=0.0
Pod undocumented
1804 my %types =
1805 (
1806 48 map { $_ => 1 }
1807 keys %writers,
1808 8 grep($file_formats{$_}, keys %formats),
1809 qw(ico sgi), # formats not handled directly, but supplied with Imager
1810 );
1811  
1812 8 return keys %types;
1813 }
1814  
1815 73 ▶sub _load_file {
Subroutine _load_file: called CC=6 SCAR=18.0
1816 73 my ($file, $error) = @_;
1817  
1818 73 ▶ if ($attempted_to_load{$file}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($attempted_to_load{$file}) { } 3 70 73
1819 3 ▶ if ($file_load_errors{$file}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($file_load_errors{$file}) { } 3 0 3
1820 3 $$error = $file_load_errors{$file};
1821 3 return 0;
1822 }
1823 else {
1824 0 return 1;
1825 }
1826 }
1827 else {
1828 70 local $SIG{__DIE__};
1829 70 my $loaded = eval {
1830 70 local @INC = @INC;
1831 70 ▶ pop @INC if $INC[-1] eq '.';
Branch: 1 branch
BranchTrueFalseTotal
if $INC[-1] eq "." 69 1 70
1832 70 ++$attempted_to_load{$file};
1833 70 require $file;
1834 13 return 1;
1835 };
1836 70 ▶ if ($loaded) {
Branch: 1 branch
BranchTrueFalseTotal
if ($loaded) { } 13 57 70
1837 13 return 1;
1838 }
1839 else {
1840 57 ▶ my $work = $@ || "Unknown error";
Condition50%1/2
$@ || 'Unknown error'
l!l
570
MC/DC0%0/1
$@ || 'Unknown error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1841 57 chomp $work;
1842 57 $work =~ s/\n?Compilation failed in require at .*Imager\.pm line .*\z//m;
1843 57 $work =~ s/\n/\\n/g;
1844 57 $work =~ s/\s*\.?\z/ loading $file/;
1845 57 $file_load_errors{$file} = $work;
1846 57 $$error = $work;
1847 57 return 0;
1848 }
1849 }
1850 }
1851  
1852 # probes for an Imager::File::whatever module
1853 342 ▶sub _reader_autoload {
Subroutine _reader_autoload: called CC=8 SCAR=20.8
1854 342 my $type = shift;
1855  
1856 342 ▶ return if $formats_low{$type} || $readers{$type};
Branch: 1 branch
BranchTrueFalseTotal
if $formats_low{$type} or $readers{$type} 333 9 342
Condition100%3/3
$formats_low{$type} or $readers{$type}
l!l&&r!l&&!r
236979
MC/DC100%2/2
$formats_low{$type} or $readers{$type}
$formats_low{$type} $readers{$type}
Truth table100%3/3
A or B
A= $formats_low{$type}B= $readers{$type}
ABresult
1X1
011
000
1857  
1858 9 ▶ return unless $type =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $type =~ /^\w+$/ 0 9 9
1859  
1860 9 my $file = "Imager/File/\U$type\E.pm";
1861  
1862 9 my $error;
1863 9 my $loaded = _load_file($file, \$error);
1864 9 ▶ if (!$loaded && $error =~ /^Can't locate /) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $loaded and $error =~ /^Can't locate /) 2 7 9
Condition100%3/3
not $loaded and $error =~ /^Can't locate /
!ll&&!rl&&r
612
MC/DC100%2/2
not $loaded and $error =~ /^Can't locate /
not $loaded $error =~ /^Can't locate /
Truth table100%3/3
not(A) and B
A= not $loadedB= $error =~ /^Can't locate /
ABresult
0X0
100
111
1865 2 my $filer = "Imager/File/\U$type\EReader.pm";
1866 2 $loaded = _load_file($filer, \$error);
1867 2 ▶ if ($error =~ /^Can't locate /) {
Branch: 1 branch
BranchTrueFalseTotal
if ($error =~ /^Can't locate /) 2 0 2
1868 2 $error = "Can't locate $file or $filer";
1869 }
1870 }
1871 9 ▶ unless ($loaded) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($loaded) 3 6 9
1872 3 $reader_load_errors{$type} = $error;
1873 }
1874 }
1875  
1876 # probes for an Imager::File::whatever module
1877 253 ▶sub _writer_autoload {
Subroutine _writer_autoload: called CC=8 SCAR=20.8
1878 253 my $type = shift;
1879  
1880 253 ▶ return if $formats_low{$type} || $writers{$type};
Branch: 1 branch
BranchTrueFalseTotal
if $formats_low{$type} or $writers{$type} 243 10 253
Condition100%3/3
$formats_low{$type} or $writers{$type}
l!l&&r!l&&!r
1776610
MC/DC100%2/2
$formats_low{$type} or $writers{$type}
$formats_low{$type} $writers{$type}
Truth table100%3/3
A or B
A= $formats_low{$type}B= $writers{$type}
ABresult
1X1
011
000
1881  
1882 10 ▶ return unless $type =~ /^\w+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $type =~ /^\w+$/ 0 10 10
1883  
1884 10 my $file = "Imager/File/\U$type\E.pm";
1885  
1886 10 my $error;
1887 10 my $loaded = _load_file($file, \$error);
1888 10 ▶ if (!$loaded && $error =~ /^Can't locate /) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $loaded and $error =~ /^Can't locate /) 2 8 10
Condition100%3/3
not $loaded and $error =~ /^Can't locate /
!ll&&!rl&&r
712
MC/DC100%2/2
not $loaded and $error =~ /^Can't locate /
not $loaded $error =~ /^Can't locate /
Truth table100%3/3
not(A) and B
A= not $loadedB= $error =~ /^Can't locate /
ABresult
0X0
100
111
1889 2 my $filew = "Imager/File/\U$type\EWriter.pm";
1890 2 $loaded = _load_file($filew, \$error);
1891 2 ▶ if ($error =~ /^Can't locate /) {
Branch: 1 branch
BranchTrueFalseTotal
if ($error =~ /^Can't locate /) 2 0 2
1892 2 $error = "Can't locate $file or $filew";
1893 }
1894 }
1895 10 ▶ unless ($loaded) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($loaded) 3 7 10
1896 3 $writer_load_errors{$type} = $error;
1897 }
1898 }
1899  
1900 0 ▶sub _fix_gif_positions {
Subroutine _fix_gif_positions: not called CC=3 SCAR=24.8
1901 0 my ($opts, $opt, $msg, @imgs) = @_;
1902  
1903 0 my $positions = $opts->{'gif_positions'};
1904 0 my $index = 0;
1905 0 for my $pos (@$positions) {
1906 0 my ($x, $y) = @$pos;
1907 0 my $img = $imgs[$index++];
1908 0 $img->settag(name=>'gif_left', value=>$x);
1909 0 ▶ $img->settag(name=>'gif_top', value=>$y) if defined $y;
Branch: 1 branch
BranchTrueFalseTotal
if defined $y 0 0 0
1910 }
1911 0 $$msg .= "replaced with the gif_left and gif_top tags";
1912 }
1913  
1914 79 my %obsolete_opts =
1915 (
1916 gif_each_palette=>'gif_local_map',
1917 interlace => 'gif_interlace',
1918 gif_delays => 'gif_delay',
1919 gif_positions => \&_fix_gif_positions,
1920 gif_loop_count => 'gif_loop',
1921 );
1922  
1923 # options that should be converted to colors
1924 79 my %color_opts = map { $_ => 1 } qw/i_background/;
1925  
1926 472 ▶sub _set_opts {
Subroutine _set_opts: called CC=19 SCAR=46.2
1927 472 my ($self, $opts, $prefix, @imgs) = @_;
1928  
1929 472 for my $opt (keys %$opts) {
1930 4545 my $tagname = $opt;
1931 4545 ▶ if ($obsolete_opts{$opt}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($obsolete_opts{$opt}) 0 4545 4545
1932 0 my $new = $obsolete_opts{$opt};
1933 0 my $msg = "Obsolete option $opt ";
1934 0 ▶ if (ref $new) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $new) { } 0 0 0
1935 0 $new->($opts, $opt, \$msg, @imgs);
1936 }
1937 else {
1938 0 $msg .= "replaced with the $new tag ";
1939 0 $tagname = $new;
1940 }
1941 0 $msg .= "line ".(caller(2))[2]." of file ".(caller(2))[1];
1942 0 ▶ warn $msg if $warn_obsolete && $^W;
Branch: 1 branch
BranchTrueFalseTotal
if $Imager::warn_obsolete and $^W 0 0 0
Condition0%0/3
$Imager::warn_obsolete and $^W
!ll&&!rl&&r
000
MC/DC0%0/2
$Imager::warn_obsolete and $^W
$Imager::warn_obsolete $^W
Truth table0%0/3
A and B
A= $Imager::warn_obsoleteB= $^W
ABresult
0X0
100
111
1943 }
1944 4545 ▶ next unless $tagname =~ /^\Q$prefix/;
Branch: 1 branch
BranchTrueFalseTotal
unless $tagname =~ /^\Q$prefix\E/ 4517 28 4545
1945 28 my $value = $opts->{$opt};
1946 28 ▶ if ($color_opts{$opt}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($color_opts{$opt}) 3 25 28
1947 3 $value = _color($value);
1948 3 ▶ unless ($value) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($value) 0 3 3
1949 0 $self->_set_error($Imager::ERRSTR);
1950 0 return;
1951 }
1952 }
1953 28 ▶ if (ref $value) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $value) { } 3 25 28
1954 3 ▶ if (UNIVERSAL::isa($value, "Imager::Color")) {
Branch: 2 branches
BranchTrueFalseTotal
if (UNIVERSAL::isa($value, 'Imager::Color')) { } 3 0 3
elsif (ref $value eq 'ARRAY') { } 0 0 0
1955 3 my $tag = sprintf("color(%d,%d,%d,%d)", $value->rgba);
1956 3 for my $img (@imgs) {
1957 3 $img->settag(name=>$tagname, value=>$tag);
1958 }
1959 }
1960 elsif (ref($value) eq 'ARRAY') {
1961 0 for my $i (0..$#$value) {
1962 0 my $val = $value->[$i];
1963 0 ▶ if (ref $val) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $val) { } 0 0 0
1964 0 ▶ if (UNIVERSAL::isa($val, "Imager::Color")) {
Branch: 1 branch
BranchTrueFalseTotal
if (UNIVERSAL::isa($val, 'Imager::Color')) { } 0 0 0
1965 0 my $tag = sprintf("color(%d,%d,%d,%d)", $value->rgba);
1966 0 ▶ $i < @imgs and
Branch: 1 branch
BranchTrueFalseTotal
$i < @imgs and $imgs[$i]->settag("name", $tagname, "value", $tag) 0 0 0
1967 $imgs[$i]->settag(name=>$tagname, value=>$tag);
1968 }
1969 else {
1970 0 $self->_set_error("Unknown reference type " . ref($value) .
1971 " supplied in array for $opt");
1972 0 return;
1973 }
1974 }
1975 else {
1976 0 ▶ $i < @imgs
Branch: 1 branch
BranchTrueFalseTotal
$i < @imgs and $imgs[$i]->settag("name", $tagname, "value", $val) 0 0 0
1977 and $imgs[$i]->settag(name=>$tagname, value=>$val);
1978 }
1979 }
1980 }
1981 else {
1982 0 $self->_set_error("Unknown reference type " . ref($value) .
1983 " supplied for $opt");
1984 0 return;
1985 }
1986 }
1987 else {
1988 # set it as a tag for every image
1989 25 for my $img (@imgs) {
1990 25 $img->settag(name=>$tagname, value=>$value);
1991 }
1992 }
1993 }
1994  
1995 472 return 1;
1996 }
1997  
1998 # Write an image to file
1999 244 ▶sub write {
Subroutine write: called CC=30 SCAR=35.7
Pod undocumented
2000 244 my $self = shift;
2001 244 my %input=(jpegquality=>75,
2002 gifquant=>'mc',
2003 lmdither=>6.0,
2004 lmfixed=>[],
2005 idstring=>"",
2006 compress=>1,
2007 wierdpack=>0,
2008 fax_fine=>1, @_);
2009 244 my $rc;
2010  
2011 244 ▶ $self->_valid_image("write")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("write") or return 243 1 244
2012 or return;
2013  
2014 243 ▶ $self->_set_opts(\%input, "i_", $self)
Branch: 1 branch
BranchTrueFalseTotal
$self->_set_opts(\%input, "i_", $self) or return undef 243 0 243
2015 or return undef;
2016  
2017 243 my $type = $input{'type'};
2018 243 ▶ if (!$type and $input{file}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $type and $input{"file"}) 108 135 243
Condition66%2/3
not $type and $input{"file"}
!ll&&!rl&&r
1350108
MC/DC50%1/2
not $type and $input{"file"}
not $type $input{"file"}
Truth table66%2/3
not(A) and B
A= not $typeB= $input{"file"}
ABresult
0X0
100
111
2019 108 $type = $FORMATGUESS->($input{file});
2020 }
2021 243 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 0 243 243
2022 0 $self->{ERRSTR}='type parameter missing and not possible to guess from extension';
2023 0 return undef;
2024 }
2025  
2026 243 _writer_autoload($type);
2027  
2028 243 my ($IO, $fh);
2029 243 ▶ if ($writers{$type} && $writers{$type}{single}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($writers{$type} and $writers{$type}{'single'}) { } 63 180 243
Condition66%2/3
$writers{$type} and $writers{$type}{"single"}
!ll&&!rl&&r
180063
MC/DC50%1/2
$writers{$type} and $writers{$type}{"single"}
$writers{$type} $writers{$type}{"single"}
Truth table66%2/3
A and B
A= $writers{$type}B= $writers{$type}{"single"}
ABresult
0X0
100
111
2030 63 ▶ ($IO, $fh) = $self->_get_writer_io(\%input)
Branch: 1 branch
BranchTrueFalseTotal
() = $self->_get_writer_io(\%input) or return undef 63 0 63
2031 or return undef;
2032  
2033 63 ▶ $writers{$type}{single}->($self, $IO, %input, type => $type)
Branch: 1 branch
BranchTrueFalseTotal
$writers{$type}{"single"}->($self, $IO, %input, "type", $type) or return undef 28 35 63
2034 or return undef;
2035 }
2036 else {
2037 180 ▶ if (!$formats_low{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($formats_low{$type}) 3 177 180
2038 3 my $write_types = join ', ', sort Imager->write_types();
2039 3 $self->_set_error("format '$type' not supported - formats $write_types available for writing - $writer_load_errors{$type}");
2040 3 return undef;
2041 }
2042
2043 177 ▶ ($IO, $fh) = $self->_get_writer_io(\%input, $type)
Branch: 1 branch
BranchTrueFalseTotal
() = $self->_get_writer_io(\%input, $type) or return undef 177 0 177
2044 or return undef;
2045
2046 177 ▶ if ( $type eq 'pnm' ) {
Branch: 4 branches
BranchTrueFalseTotal
if ($type eq 'pnm') { } 129 48 177
elsif ($type eq 'raw') { } 10 38 48
elsif ($type eq 'bmp') { } 21 17 38
elsif ($type eq 'tga') { } 17 0 17
2047 129 ▶ $self->_set_opts(\%input, "pnm_", $self)
Branch: 1 branch
BranchTrueFalseTotal
$self->_set_opts(\%input, "pnm_", $self) or return undef 129 0 129
2048 or return undef;
2049 129 ▶ if ( ! i_writeppm_wiol($self->{IMG},$IO) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_writeppm_wiol($self->{"IMG"}, $IO)) 5 124 129
2050 5 $self->{ERRSTR} = $self->_error_as_msg();
2051 5 return undef;
2052 }
2053 124 ▶ $self->{DEBUG} && print "writing a pnm file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "writing a pnm file\n" 0 124 124
2054 }
2055 elsif ( $type eq 'raw' ) {
2056 10 ▶ $self->_set_opts(\%input, "raw_", $self)
Branch: 1 branch
BranchTrueFalseTotal
$self->_set_opts(\%input, "raw_", $self) or return undef 10 0 10
2057 or return undef;
2058 10 ▶ if ( !i_writeraw_wiol($self->{IMG},$IO) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_writeraw_wiol($self->{"IMG"}, $IO)) 4 6 10
2059 4 $self->{ERRSTR} = $self->_error_as_msg();
2060 4 return undef;
2061 }
2062 6 ▶ $self->{DEBUG} && print "writing a raw file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "writing a raw file\n" 0 6 6
2063 }
2064 elsif ( $type eq 'bmp' ) {
2065 21 ▶ $self->_set_opts(\%input, "bmp_", $self)
Branch: 1 branch
BranchTrueFalseTotal
$self->_set_opts(\%input, "bmp_", $self) or return undef 21 0 21
2066 or return undef;
2067 21 ▶ if ( !i_writebmp_wiol($self->{IMG}, $IO) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_writebmp_wiol($self->{"IMG"}, $IO)) 12 9 21
2068 12 $self->{ERRSTR} = $self->_error_as_msg;
2069 12 return undef;
2070 }
2071 9 ▶ $self->{DEBUG} && print "writing a bmp file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "writing a bmp file\n" 0 9 9
2072 }
2073 elsif ( $type eq 'tga' ) {
2074 17 ▶ $self->_set_opts(\%input, "tga_", $self)
Branch: 1 branch
BranchTrueFalseTotal
$self->_set_opts(\%input, "tga_", $self) or return undef 17 0 17
2075 or return undef;
2076
2077 17 ▶ if ( !i_writetga_wiol($self->{IMG}, $IO, $input{wierdpack}, $input{compress}, $input{idstring}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_writetga_wiol($self->{"IMG"}, $IO, $input{"wierdpack"}, $input{"compress"}, $input{"idstring"})) 4 13 17
2078 4 $self->{ERRSTR}=$self->_error_as_msg();
2079 4 return undef;
2080 }
2081 13 ▶ $self->{DEBUG} && print "writing a tga file\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "writing a tga file\n" 0 13 13
2082 }
2083 }
2084  
2085 180 ▶ if (exists $input{'data'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $input{"data"}) 38 142 180
2086 38 my $data = io_slurp($IO);
2087 38 ▶ if (!$data) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($data) 0 38 38
2088 0 $self->{ERRSTR}='Could not slurp from buffer';
2089 0 return undef;
2090 }
2091 38 ${$input{data}} = $data;
2092 }
2093 180 return $self;
2094 }
2095  
2096 13 ▶sub write_multi {
Subroutine write_multi: called CC=20 SCAR=37.8
Pod undocumented
2097 13 my ($class, $opts, @images) = @_;
2098  
2099 13 my $type = $opts->{type};
2100  
2101 13 ▶ if (!$type && $opts->{'file'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $type and $opts->{"file"}) 2 11 13
Condition66%2/3
not $type and $opts->{"file"}
!ll&&!rl&&r
1102
MC/DC50%1/2
not $type and $opts->{"file"}
not $type $opts->{"file"}
Truth table66%2/3
not(A) and B
A= not $typeB= $opts->{"file"}
ABresult
0X0
100
111
2102 2 $type = $FORMATGUESS->($opts->{'file'});
2103 }
2104 13 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 0 13 13
2105 0 $class->_set_error('type parameter missing and not possible to guess from extension');
2106 0 return;
2107 }
2108 # translate to ImgRaw
2109 13 my $index = 1;
2110 13 for my $img (@images) {
2111 23 ▶ unless (ref $img && Scalar::Util::blessed($img) && $img->isa("Imager")) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $img and builtin::blessed($img) and $img->isa("Imager")) 2 21 23
Condition83%5/6
ref $img and builtin::blessed($img) and $img->isa("Imager")
!ll&&!rl&&r
1121
ref $img and builtin::blessed($img)
!ll&&!rl&&r
1022
MC/DC66%2/3
ref $img and builtin::blessed($img) and $img->isa("Imager")
ref $img builtin::blessed($img) $img->isa("Imager")
Truth table75%3/4
A and B and C
A= ref $imgB= builtin::blessed($img)C= $img->isa("Imager")
ABCresult
0XX0
10X0
1100
1111
2112 2 $class->_set_error("write_multi: image $index is not an Imager image object");
2113 2 return;
2114 }
2115 21 ▶ unless ($img->_valid_image("write_multi")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($img->_valid_image("write_multi")) 1 20 21
2116 1 $class->_set_error($img->errstr . " (image $index)");
2117 1 return;
2118 }
2119 20 ++$index;
2120 }
2121 10 ▶ $class->_set_opts($opts, "i_", @images)
Branch: 1 branch
BranchTrueFalseTotal
$class->_set_opts($opts, "i_", @images) or return 10 0 10
2122 or return;
2123 10 my @work = map $_->{IMG}, @images;
2124  
2125 10 _writer_autoload($type);
2126  
2127 10 my ($IO, $file);
2128 10 ▶ if ($writers{$type} && $writers{$type}{multiple}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($writers{$type} and $writers{$type}{'multiple'}) { } 10 0 10
Condition33%1/3
$writers{$type} and $writers{$type}{"multiple"}
!ll&&!rl&&r
0010
MC/DC0%0/2
$writers{$type} and $writers{$type}{"multiple"}
$writers{$type} $writers{$type}{"multiple"}
Truth table33%1/3
A and B
A= $writers{$type}B= $writers{$type}{"multiple"}
ABresult
0X0
100
111
2129 10 ▶ ($IO, $file) = $class->_get_writer_io($opts, $type)
Branch: 1 branch
BranchTrueFalseTotal
() = $class->_get_writer_io($opts, $type) or return undef 10 0 10
2130 or return undef;
2131  
2132 10 ▶ $writers{$type}{multiple}->($class, $IO, $opts, @images)
Branch: 1 branch
BranchTrueFalseTotal
$writers{$type}{"multiple"}->($class, $IO, $opts, @images) or return undef 4 6 10
2133 or return undef;
2134 }
2135 else {
2136 0 ▶ if (!$formats{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($Imager::formats{$type}) 0 0 0
2137 0 my $write_types = join ', ', sort Imager->write_types();
2138 0 $class->_set_error("format '$type' not supported - formats $write_types available for writing");
2139 0 return undef;
2140 }
2141
2142 0 ▶ ($IO, $file) = $class->_get_writer_io($opts, $type)
Branch: 1 branch
BranchTrueFalseTotal
() = $class->_get_writer_io($opts, $type) or return undef 0 0 0
2143 or return undef;
2144
2145 0 if (0) { # eventually PNM in here, now that TIFF/GIF are elsewhere
2146 }
2147 else {
2148 0 ▶ if (@images == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (@images == 1) { } 0 0 0
2149 0 ▶ unless ($images[0]->write(%$opts, io => $IO, type => $type)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($images[0]->write(%$opts, "io", $IO, "type", $type)) 0 0 0
2150 0 return 1;
2151 }
2152 }
2153 else {
2154 0 $ERRSTR = "Sorry, write_multi doesn't support $type yet";
2155 0 return 0;
2156 }
2157 }
2158 }
2159  
2160 4 ▶ if (exists $opts->{'data'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts->{"data"}) 2 2 4
2161 2 my $data = io_slurp($IO);
2162 2 ▶ if (!$data) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($data) 0 2 2
2163 0 Imager->_set_error('Could not slurp from buffer');
2164 0 return undef;
2165 }
2166 2 ${$opts->{data}} = $data;
2167 }
2168 4 return 1;
2169 }
2170  
2171 # read multiple images from a file
2172 10 ▶sub read_multi {
Subroutine read_multi: called CC=14 SCAR=29.6
Pod undocumented
2173 10 my ($class, %opts) = @_;
2174  
2175 10 ▶ my ($IO, $file) = $class->_get_reader_io(\%opts, $opts{'type'})
Branch: 1 branch
BranchTrueFalseTotal
() = $class->_get_reader_io(\%opts, $opts{"type"}) or return 10 0 10
2176 or return;
2177  
2178 10 my $type = $opts{'type'};
2179 10 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 6 4 10
2180 6 $type = _test_format($IO);
2181 }
2182  
2183 10 ▶ if ($opts{file} && !$type) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"file"} and not $type) 1 9 10
Condition100%3/3
$opts{"file"} and not $type
!ll&&!rl&&r
451
MC/DC100%2/2
$opts{"file"} and not $type
$opts{"file"} not $type
Truth table100%3/3
A and not(B)
A= $opts{"file"}B= not $type
ABresult
0X0
100
111
2184 # guess the type
2185 1 $type = $FORMATGUESS->($opts{file});
2186 }
2187  
2188 10 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 2 8 10
2189 2 my $msg = "type parameter missing and it couldn't be determined from the file contents";
2190 2 ▶ $opts{file} and $msg .= " or file name";
Branch: 1 branch
BranchTrueFalseTotal
$opts{"file"} and $msg .= ' or file name' 1 1 2
2191 2 Imager->_set_error($msg);
2192 2 return;
2193 }
2194  
2195 8 _reader_autoload($type);
2196  
2197 8 ▶ if ($readers{$type} && $readers{$type}{multiple}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($readers{$type} and $readers{$type}{"multiple"}) 7 1 8
Condition66%2/3
$readers{$type} and $readers{$type}{"multiple"}
!ll&&!rl&&r
107
MC/DC50%1/2
$readers{$type} and $readers{$type}{"multiple"}
$readers{$type} $readers{$type}{"multiple"}
Truth table66%2/3
A and B
A= $readers{$type}B= $readers{$type}{"multiple"}
ABresult
0X0
100
111
2198 7 return $readers{$type}{multiple}->($IO, %opts);
2199 }
2200  
2201 1 ▶ unless ($formats{$type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($Imager::formats{$type}) 0 1 1
2202 0 my $read_types = join ', ', sort Imager->read_types();
2203 0 Imager->_set_error("format '$type' not supported - formats $read_types available for reading");
2204 0 return;
2205 }
2206  
2207 1 my @imgs;
2208 1 ▶ if ($type eq 'pnm') {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq 'pnm') { } 1 0 1
2209 1 ▶ @imgs = i_readpnm_multi_wiol($IO, $opts{allow_incomplete}||0);
Condition50%1/2
$opts{'allow_incomplete'} || 0
l!l
01
MC/DC0%0/1
$opts{'allow_incomplete'} || 0
$opts{'allow_incomplete'}
Truth table50%1/2
A
A= $opts{'allow_incomplete'}
Aresult
11
00
2210 }
2211 else {
2212 0 my $img = Imager->new;
2213 0 ▶ if ($img->read(%opts, io => $IO, type => $type)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($img->read(%opts, "io", $IO, "type", $type)) 0 0 0
2214 0 return ( $img );
2215 }
2216 0 Imager->_set_error($img->errstr);
2217 0 return;
2218 }
2219  
2220 1 ▶ if (!@imgs) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@imgs) 0 1 1
2221 0 $ERRSTR = _error_as_msg();
2222 0 return;
2223 }
2224 return map {
2225 1 bless { IMG=>$_, DEBUG=>$DEBUG, ERRSTR=>undef }, 'Imager'
2226 } @imgs;
2227 }
2228  
2229 # Destroy an Imager object
2230  
2231 1468 ▶sub DESTROY {
Subroutine DESTROY: called CC=2 SCAR=6.9
2232 1468 my $self=shift;
2233 # delete $instances{$self};
2234 1468 ▶ if (defined($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $self->{'IMG'}) { } 1251 217 1468
2235 # the following is now handled by the XS DESTROY method for
2236 # Imager::ImgRaw object
2237 # Re-enabling this will break virtual images
2238 # tested for in t/t020masked.t
2239 # i_img_destroy($self->{IMG});
2240 1251 undef($self->{IMG});
2241 } else {
2242 # print "Destroy Called on an empty image!\n"; # why did I put this here??
2243 }
2244 }
2245  
2246 # Perform an inplace filter of an image
2247 # that is the image will be overwritten with the data
2248  
2249 106 ▶sub filter {
Subroutine filter: called CC=14 SCAR=27.5
Pod undocumented
2250 106 my $self=shift;
2251 106 my %input=@_;
2252 106 my %hsh;
2253  
2254 106 ▶ $self->_valid_image("filter")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("filter") or return 105 1 106
2255 or return;
2256  
2257 0 ▶ if (!$input{'type'}) { $self->{ERRSTR}='type parameter missing'; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless ($input{"type"}) 0 105 105
2258  
2259 105 ▶ if (!exists $filters{$input{'type'}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $Imager::filters{$input{"type"}}) 0 105 105
2260 0 $self->{ERRSTR}='type parameter not matching any filter'; return undef;
2261 }
2262  
2263 105 ▶ if ($filters{$input{'type'}}{names}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($Imager::filters{$input{"type"}}{"names"}) 10 95 105
2264 10 my $names = $filters{$input{'type'}}{names};
2265 10 for my $name (keys %$names) {
2266 40 ▶ if (defined $input{$name} && exists $names->{$name}{$input{$name}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $input{$name} and exists $names->{$name}{$input{$name}}) 12 28 40
Condition66%2/3
defined $input{$name} and exists $names->{$name}{$input{$name}}
!ll&&!rl&&r
28012
MC/DC50%1/2
defined $input{$name} and exists $names->{$name}{$input{$name}}
defined $input{$name} exists $names->{$name}{$input{$name}}
Truth table66%2/3
A and B
A= defined $input{$name}B= exists $names->{$name}{$input{$name}}
ABresult
0X0
100
111
2267 12 $input{$name} = $names->{$name}{$input{$name}};
2268 }
2269 }
2270 }
2271 105 ▶ if (defined($filters{$input{'type'}}{defaults})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $Imager::filters{$input{'type'}}{'defaults'}) { } 104 1 105
2272 %hsh=( image => $self->{IMG},
2273 imager => $self,
2274 104 %{$filters{$input{'type'}}{defaults}},
2275 %input );
2276 } else {
2277 %hsh=( image => $self->{IMG},
2278 1 imager => $self,
2279 %input );
2280 }
2281  
2282 105 my @cs=@{$filters{$input{'type'}}{callseq}};
2283  
2284 105 for(@cs) {
2285 334 ▶ if (!defined($hsh{$_})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $hsh{$_}) 0 334 334
2286 0 $self->{ERRSTR}="missing parameter '$_' for filter ".$input{'type'}; return undef;
2287 }
2288 }
2289  
2290 105 eval {
2291 105 local $SIG{__DIE__}; # we don't want this processed by confess, etc
2292 105 &{$filters{$input{'type'}}{callsub}}(%hsh);
2293 };
2294 105 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 4 101 105
2295 4 chomp($self->{ERRSTR} = $@);
2296 4 return;
2297 }
2298  
2299 101 my @b=keys %hsh;
2300  
2301 101 ▶ $self->{DEBUG} && print "callseq is: @cs\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "callseq is: @cs\n" 0 101 101
2302 101 ▶ $self->{DEBUG} && print "matching callseq is: @b\n";
Branch: 1 branch
BranchTrueFalseTotal
$self->{"DEBUG"} and print "matching callseq is: @b\n" 0 101 101
2303  
2304 101 return $self;
2305 }
2306  
2307 4 ▶sub register_filter {
Subroutine register_filter: called CC=5 SCAR=16.8
Pod undocumented
2308 4 my $class = shift;
2309 4 my %hsh = ( defaults => {}, @_ );
2310  
2311 defined $hsh{type}
2312 4 ▶ or die "register_filter() with no type\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $hsh{"type"} or die "register_filter() with no type\n" 4 0 4
2313 defined $hsh{callsub}
2314 4 ▶ or die "register_filter() with no callsub\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $hsh{"callsub"} or die "register_filter() with no callsub\n" 4 0 4
2315 defined $hsh{callseq}
2316 4 ▶ or die "register_filter() with no callseq\n";
Branch: 1 branch
BranchTrueFalseTotal
defined $hsh{"callseq"} or die "register_filter() with no callseq\n" 4 0 4
2317  
2318 exists $filters{$hsh{type}}
2319 4 ▶ and return;
Branch: 1 branch
BranchTrueFalseTotal
exists $Imager::filters{$hsh{"type"}} and return 0 4 4
2320  
2321 4 $filters{$hsh{type}} = \%hsh;
2322  
2323 4 return 1;
2324 }
2325  
2326 62 ▶sub scale_calculate {
Subroutine scale_calculate: called CC=31 SCAR=36.4
Pod undocumented
2327 62 my $self = shift;
2328  
2329 62 my %opts = ('type'=>'max', @_);
2330  
2331 # none of these should be references
2332 62 for my $name (qw/xpixels ypixels xscalefactor yscalefactor width height/) {
2333 367 ▶ if (defined $opts{$name} && ref $opts{$name}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $opts{$name} and ref $opts{$name}) 1 366 367
Condition100%3/3
defined $opts{$name} and ref $opts{$name}
!ll&&!rl&&r
293731
MC/DC100%2/2
defined $opts{$name} and ref $opts{$name}
defined $opts{$name} ref $opts{$name}
Truth table100%3/3
A and B
A= defined $opts{$name}B= ref $opts{$name}
ABresult
0X0
100
111
2334 1 $self->_set_error("scale_calculate: $name parameter cannot be a reference");
2335 1 return;
2336 }
2337 }
2338  
2339 61 my ($x_scale, $y_scale);
2340 61 my $width = $opts{width};
2341 61 my $height = $opts{height};
2342 61 ▶ if (ref $self) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) { } 59 2 61
2343 59 ▶ defined $width or $width = $self->getwidth;
Branch: 1 branch
BranchTrueFalseTotal
defined $width or $width = $self->getwidth 0 59 59
2344 59 ▶ defined $height or $height = $self->getheight;
Branch: 1 branch
BranchTrueFalseTotal
defined $height or $height = $self->getheight 0 59 59
2345 }
2346 else {
2347 2 ▶ unless (defined $width && defined $height) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $width and defined $height) 1 1 2
Condition66%2/3
defined $width and defined $height
!ll&&!rl&&r
101
MC/DC50%1/2
defined $width and defined $height
defined $width defined $height
Truth table66%2/3
A and B
A= defined $widthB= defined $height
ABresult
0X0
100
111
2348 1 $self->_set_error("scale_calculate: width and height parameters must be supplied when called as a class method");
2349 1 return;
2350 }
2351 }
2352  
2353 60 ▶ if ($opts{'xscalefactor'} && $opts{'yscalefactor'}) {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'xscalefactor'} and $opts{'yscalefactor'}) { } 8 52 60
elsif ($opts{'xscalefactor'}) { } 3 49 52
elsif ($opts{'yscalefactor'}) { } 3 46 49
Condition100%3/3
$opts{"xscalefactor"} and $opts{"yscalefactor"}
!ll&&!rl&&r
4938
MC/DC100%2/2
$opts{"xscalefactor"} and $opts{"yscalefactor"}
$opts{"xscalefactor"} $opts{"yscalefactor"}
Truth table100%3/3
A and B
A= $opts{"xscalefactor"}B= $opts{"yscalefactor"}
ABresult
0X0
100
111
2354 8 $x_scale = $opts{'xscalefactor'};
2355 8 $y_scale = $opts{'yscalefactor'};
2356 }
2357 elsif ($opts{'xscalefactor'}) {
2358 3 $x_scale = $opts{'xscalefactor'};
2359 3 ▶ $y_scale = $opts{'scalefactor'} || $x_scale;
Condition33%1/3
$opts{'scalefactor'} || $x_scale
l!l&&r!l&&!r
030
MC/DC0%0/2
$opts{'scalefactor'} || $x_scale
$opts{'scalefactor'} $x_scale
Truth table33%1/3
A || B
A= $opts{'scalefactor'}B= $x_scale
ABresult
1X1
011
000
2360 }
2361 elsif ($opts{'yscalefactor'}) {
2362 3 $y_scale = $opts{'yscalefactor'};
2363 3 ▶ $x_scale = $opts{'scalefactor'} || $y_scale;
Condition33%1/3
$opts{'scalefactor'} || $y_scale
l!l&&r!l&&!r
030
MC/DC0%0/2
$opts{'scalefactor'} || $y_scale
$opts{'scalefactor'} $y_scale
Truth table33%1/3
A || B
A= $opts{'scalefactor'}B= $y_scale
ABresult
1X1
011
000
2364 }
2365 else {
2366 46 ▶ $x_scale = $y_scale = $opts{'scalefactor'} || 0.5;
Condition100%2/2
$opts{'scalefactor'} || 0.5
l!l
1432
MC/DC100%1/1
$opts{'scalefactor'} || 0.5
$opts{'scalefactor'}
Truth table100%2/2
A
A= $opts{'scalefactor'}
Aresult
11
00
2367 }
2368  
2369 # work out the scaling
2370 60 ▶ if ($opts{xpixels} and $opts{ypixels} and $opts{'type'}) {
Branch: 4 branches
BranchTrueFalseTotal
if ($opts{'xpixels'} and $opts{'ypixels'} and $opts{'type'}) { } 20 40 60
elsif ($opts{'xpixels'}) { } 6 34 40
elsif ($opts{'ypixels'}) { } 3 31 34
elsif ($opts{'constrain'} and ref $opts{'constrain'} and $opts{'constrain'}->can('constrain')) { } 0 62 62
Condition83%5/6
$opts{"xpixels"} and $opts{"ypixels"} and $opts{"type"}
!ll&&!rl&&r
40020
$opts{"xpixels"} and $opts{"ypixels"}
!ll&&!rl&&r
34620
MC/DC66%2/3
$opts{"xpixels"} and $opts{"ypixels"} and $opts{"type"}
$opts{"xpixels"} $opts{"ypixels"} $opts{"type"}
Truth table75%3/4
A and B and C
A= $opts{"xpixels"}B= $opts{"ypixels"}C= $opts{"type"}
ABCresult
0XX0
10X0
1100
1111
2371 my ($xpix, $ypix)=( $opts{xpixels} / $width ,
2372 20 $opts{ypixels} / $height );
2373 20 ▶ if ($opts{'type'} eq 'min') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'type'} eq 'min') { } 3 17 20
elsif ($opts{'type'} eq 'max') { } 9 8 17
elsif ($opts{'type'} eq 'nonprop' or $opts{'type'} eq 'non-proportional') { } 7 1 8
2374 3 $x_scale = $y_scale = _min($xpix,$ypix);
2375 }
2376 elsif ($opts{'type'} eq 'max') {
2377 9 $x_scale = $y_scale = _max($xpix,$ypix);
2378 }
2379 ▶ elsif ($opts{'type'} eq 'nonprop' || $opts{'type'} eq 'non-proportional') {
Condition66%2/3
$opts{"type"} eq "nonprop" or $opts{"type"} eq "non-proportional"
l!l&&r!l&&!r
701
MC/DC50%1/2
$opts{"type"} eq "nonprop" or $opts{"type"} eq "non-proportional"
$opts{"type"} eq "nonprop" $opts{"type"} eq "non-proportional"
Truth table66%2/3
A or B
A= $opts{"type"} eq "nonprop"B= $opts{"type"} eq "non-proportional"
ABresult
1X1
011
000
2380 7 $x_scale = $xpix;
2381 7 $y_scale = $ypix;
2382 }
2383 else {
2384 1 $self->_set_error('invalid value for type parameter');
2385 1 return;
2386 }
2387 } elsif ($opts{xpixels}) {
2388 6 $x_scale = $y_scale = $opts{xpixels} / $width;
2389 }
2390 elsif ($opts{ypixels}) {
2391 3 $x_scale = $y_scale = $opts{ypixels}/$height;
2392 }
2393 ▶ elsif ($opts{constrain} && ref $opts{constrain}
Condition33%2/6
$opts{"constrain"} and ref $opts{"constrain"} and $opts{"constrain"}->can("constrain")
!ll&&!rl&&r
3100
$opts{"constrain"} and ref $opts{"constrain"}
!ll&&!rl&&r
3100
MC/DC0%0/3
$opts{"constrain"} and ref $opts{"constrain"} and $opts{"constrain"}->can("constrain")
$opts{"constrain"} ref $opts{"constrain"} $opts{"constrain"}->can("constrain")
Truth table25%1/4
A and B and C
A= $opts{"constrain"}B= ref $opts{"constrain"}C= $opts{"constrain"}->can("constrain")
ABCresult
0XX0
10X0
1100
1111
2394 && $opts{constrain}->can('constrain')) {
2395 # we've been passed an Image::Math::Constrain object or something
2396 # that looks like one
2397 0 my $scalefactor;
2398 (undef, undef, $scalefactor)
2399 0 = $opts{constrain}->constrain($self->getwidth, $self->getheight);
2400 0 ▶ unless ($scalefactor) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($scalefactor) 0 0 0
2401 0 $self->_set_error('constrain method failed on constrain parameter');
2402 0 return;
2403 }
2404 0 $x_scale = $y_scale = $scalefactor;
2405 }
2406  
2407 59 my $new_width = int($x_scale * $width + 0.5);
2408 59 ▶ $new_width > 0 or $new_width = 1;
Branch: 1 branch
BranchTrueFalseTotal
$new_width > 0 or $new_width = 1 56 3 59
2409 59 my $new_height = int($y_scale * $height + 0.5);
2410 59 ▶ $new_height > 0 or $new_height = 1;
Branch: 1 branch
BranchTrueFalseTotal
$new_height > 0 or $new_height = 1 56 3 59
2411  
2412 59 return ($x_scale, $y_scale, $new_width, $new_height);
2413
2414 }
2415  
2416 # Scale an image to requested size and return the scaled version
2417  
2418 61 ▶sub scale {
Subroutine scale: called CC=11 SCAR=25.2
Pod undocumented
2419 61 my $self=shift;
2420 61 my %opts = (qtype=>'normal' ,@_);
2421 61 my $img = Imager->new();
2422 61 my $tmp = Imager->new();
2423  
2424 61 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 60 61
2425 1 my @caller = caller;
2426 1 warn "scale() called in void context - scale() returns the scaled image at $caller[1] line $caller[2]\n";
2427 1 return;
2428 }
2429  
2430 60 ▶ $self->_valid_image("scale")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("scale") or return 59 1 60
2431 or return;
2432  
2433 59 ▶ my ($x_scale, $y_scale, $new_width, $new_height) =
Branch: 1 branch
BranchTrueFalseTotal
() = $self->scale_calculate(%opts) or return 57 2 59
2434 $self->scale_calculate(%opts)
2435 or return;
2436  
2437 57 ▶ if ($opts{qtype} eq 'normal') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'qtype'} eq 'normal') { } 18 39 57
elsif ($opts{'qtype'} eq 'preview') { } 18 21 39
elsif ($opts{'qtype'} eq 'mixing') { } 20 1 21
2438 18 $tmp->{IMG} = i_scaleaxis($self->{IMG}, $x_scale, 0);
2439 18 ▶ if ( !defined($tmp->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $tmp->{"IMG"}) 0 18 18
2440 0 $self->{ERRSTR} = 'unable to scale image: ' . $self->_error_as_msg;
2441 0 return undef;
2442 }
2443 18 $img->{IMG}=i_scaleaxis($tmp->{IMG}, $y_scale, 1);
2444 18 ▶ if ( !defined($img->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 0 18 18
2445 0 $self->{ERRSTR}='unable to scale image: ' . $self->_error_as_msg;
2446 0 return undef;
2447 }
2448  
2449 18 return $img;
2450 }
2451 elsif ($opts{'qtype'} eq 'preview') {
2452 18 $img->{IMG} = i_scale_nn($self->{IMG}, $x_scale, $y_scale);
2453 18 ▶ if ( !defined($img->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 0 18 18
2454 0 $self->{ERRSTR}='unable to scale image';
2455 0 return undef;
2456 }
2457 18 return $img;
2458 }
2459 elsif ($opts{'qtype'} eq 'mixing') {
2460 20 $img->{IMG} = i_scale_mixing($self->{IMG}, $new_width, $new_height);
2461 20 ▶ unless ($img->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($img->{"IMG"}) 0 20 20
2462 0 $self->_set_error(Imager->_error_as_msg);
2463 0 return;
2464 }
2465 20 return $img;
2466 }
2467 else {
2468 1 $self->_set_error('invalid value for qtype parameter');
2469 1 return undef;
2470 }
2471 }
2472  
2473 # Scales only along the X axis
2474  
2475 11 ▶sub scaleX {
Subroutine scaleX: called CC=6 SCAR=18.4
Pod undocumented
2476 11 my $self = shift;
2477 11 my %opts = ( scalefactor=>0.5, @_ );
2478  
2479 11 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 10 11
2480 1 my @caller = caller;
2481 1 warn "scaleX() called in void context - scaleX() returns the scaled image at $caller[1] line $caller[2]\n";
2482 1 return;
2483 }
2484  
2485 10 ▶ $self->_valid_image("scaleX")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("scaleX") or return 9 1 10
2486 or return;
2487  
2488 9 my $img = Imager->new();
2489  
2490 9 my $scalefactor = $opts{scalefactor};
2491  
2492 9 ▶ if ($opts{pixels}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"pixels"}) 3 6 9
2493 3 $scalefactor = $opts{pixels} / $self->getwidth();
2494 }
2495  
2496 9 ▶ unless ($self->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->{"IMG"}) 0 9 9
2497 0 $self->{ERRSTR}='empty input image';
2498 0 return undef;
2499 }
2500  
2501 9 $img->{IMG} = i_scaleaxis($self->{IMG}, $scalefactor, 0);
2502  
2503 9 ▶ if ( !defined($img->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 0 9 9
2504 0 $self->{ERRSTR} = 'unable to scale image';
2505 0 return undef;
2506 }
2507  
2508 9 return $img;
2509 }
2510  
2511 # Scales only along the Y axis
2512  
2513 11 ▶sub scaleY {
Subroutine scaleY: called CC=6 SCAR=18.4
Pod undocumented
2514 11 my $self = shift;
2515 11 my %opts = ( scalefactor => 0.5, @_ );
2516  
2517 11 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 10 11
2518 1 my @caller = caller;
2519 1 warn "scaleY() called in void context - scaleY() returns the scaled image at $caller[1] line $caller[2]\n";
2520 1 return;
2521 }
2522  
2523 10 ▶ $self->_valid_image("scaleY")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("scaleY") or return 9 1 10
2524 or return;
2525  
2526 9 my $img = Imager->new();
2527  
2528 9 my $scalefactor = $opts{scalefactor};
2529  
2530 9 ▶ if ($opts{pixels}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"pixels"}) 3 6 9
2531 3 $scalefactor = $opts{pixels} / $self->getheight();
2532 }
2533  
2534 9 ▶ unless ($self->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->{"IMG"}) 0 9 9
2535 0 $self->{ERRSTR} = 'empty input image';
2536 0 return undef;
2537 }
2538 9 $img->{IMG}=i_scaleaxis($self->{IMG}, $scalefactor, 1);
2539  
2540 9 ▶ if ( !defined($img->{IMG}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 0 9 9
2541 0 $self->{ERRSTR} = 'unable to scale image';
2542 0 return undef;
2543 }
2544  
2545 9 return $img;
2546 }
2547  
2548 # Transform returns a spatial transformation of the input image
2549 # this moves pixels to a new location in the returned image.
2550 # NOTE - should make a utility function to check transforms for
2551 # stack overruns
2552  
2553 79 our $I2P;
2554  
2555 0 ▶sub transform {
Subroutine transform: not called CC=25 SCAR=64.8
Pod undocumented
2556 0 my $self=shift;
2557 0 my %opts=@_;
2558 0 my (@op,@ropx,@ropy,$iop,$or,@parm,$expr,@xt,@yt,@pt,$numre);
2559  
2560 # print Dumper(\%opts);
2561 # xopcopdes
2562  
2563 0 ▶ $self->_valid_image("transform")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("transform") or return 0 0 0
2564 or return;
2565  
2566 0 ▶ if ( $opts{'xexpr'} and $opts{'yexpr'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"xexpr"} and $opts{"yexpr"}) 0 0 0
Condition0%0/3
$opts{"xexpr"} and $opts{"yexpr"}
!ll&&!rl&&r
000
MC/DC0%0/2
$opts{"xexpr"} and $opts{"yexpr"}
$opts{"xexpr"} $opts{"yexpr"}
Truth table0%0/3
A and B
A= $opts{"xexpr"}B= $opts{"yexpr"}
ABresult
0X0
100
111
2567 0 ▶ if (!$I2P) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($Imager::I2P) 0 0 0
2568 {
2569 0 local @INC = @INC;
2570 0 ▶ pop @INC if $INC[-1] eq '.';
Branch: 1 branch
BranchTrueFalseTotal
if $INC[-1] eq "." 0 0 0
2571 0 eval ("use Affix::Infix2Postfix;");
2572 }
2573  
2574 0 ▶ if ( $@ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 0 0
2575 0 $self->{ERRSTR}='transform: expr given and Affix::Infix2Postfix is not avaliable.';
2576 0 return undef;
2577 }
2578 0 $I2P=Affix::Infix2Postfix->new('ops'=>[{op=>'+',trans=>'Add'},
2579 {op=>'-',trans=>'Sub'},
2580 {op=>'*',trans=>'Mult'},
2581 {op=>'/',trans=>'Div'},
2582 {op=>'-','type'=>'unary',trans=>'u-'},
2583 {op=>'**'},
2584 {op=>'func','type'=>'unary'}],
2585 'grouping'=>[qw( \( \) )],
2586 'func'=>[qw( sin cos )],
2587 'vars'=>[qw( x y )]
2588 );
2589 }
2590  
2591 0 @xt=$I2P->translate($opts{'xexpr'});
2592 0 @yt=$I2P->translate($opts{'yexpr'});
2593  
2594 0 $numre=$I2P->{'numre'};
2595 0 @pt=(0,0);
2596  
2597 0 ▶ for(@xt) { if (/$numre/) { push(@pt,$_); push(@{$opts{'xopcodes'}},'Parm',$#pt); } else { push(@{$opts{'xopcodes'}},$_); } }
Branch: 1 branch
BranchTrueFalseTotal
if (/$numre/) { } 0 0 0
2598 0 ▶ for(@yt) { if (/$numre/) { push(@pt,$_); push(@{$opts{'yopcodes'}},'Parm',$#pt); } else { push(@{$opts{'yopcodes'}},$_); } }
Branch: 1 branch
BranchTrueFalseTotal
if (/$numre/) { } 0 0 0
2599 0 @{$opts{'parm'}}=@pt;
2600 }
2601  
2602 # print Dumper(\%opts);
2603  
2604 0 ▶ if ( !exists $opts{'xopcodes'} or @{$opts{'xopcodes'}}==0) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $opts{"xopcodes"} or @{$opts{"xopcodes"};} == 0) 0 0 0
Condition0%0/3
not exists $opts{"xopcodes"} or @{$opts{"xopcodes"};} == 0
l!l&&r!l&&!r
000
MC/DC0%0/2
not exists $opts{"xopcodes"} or @{$opts{"xopcodes"};} == 0
not exists $opts{"xopcodes"} @{$opts{"xopcodes"};} == 0
Truth table0%0/3
not(A) or B
A= not exists $opts{"xopcodes"}B= @{$opts{"xopcodes"};} == 0
ABresult
1X1
011
000
2605 0 $self->{ERRSTR}='transform: no xopcodes given.';
2606 0 return undef;
2607 }
2608  
2609 0 @op=@{$opts{'xopcodes'}};
2610 0 for $iop (@op) {
2611 0 ▶ if (!defined ($OPCODES{$iop}) and ($iop !~ /^\d+$/) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/) 0 0 0
Condition0%0/3
defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/
l!l&&r!l&&!r
000
MC/DC0%0/2
defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/
defined $Imager::OPCODES{$iop} $iop =~ /^\d+$/
Truth table0%0/3
A or B
A= defined $Imager::OPCODES{$iop}B= $iop =~ /^\d+$/
ABresult
1X1
011
000
2612 0 $self->{ERRSTR}="transform: illegal opcode '$_'.";
2613 0 return undef;
2614 }
2615 0 ▶ push(@ropx,(exists $OPCODES{$iop}) ? @{$OPCODES{$iop}} : $iop );
Branch: 1 branch
BranchTrueFalseTotal
exists $Imager::OPCODES{$iop} ? : 0 0 0
2616 }
2617  
2618  
2619 # yopcopdes
2620  
2621 0 ▶ if ( !exists $opts{'yopcodes'} or @{$opts{'yopcodes'}}==0) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $opts{"yopcodes"} or @{$opts{"yopcodes"};} == 0) 0 0 0
Condition0%0/3
not exists $opts{"yopcodes"} or @{$opts{"yopcodes"};} == 0
l!l&&r!l&&!r
000
MC/DC0%0/2
not exists $opts{"yopcodes"} or @{$opts{"yopcodes"};} == 0
not exists $opts{"yopcodes"} @{$opts{"yopcodes"};} == 0
Truth table0%0/3
not(A) or B
A= not exists $opts{"yopcodes"}B= @{$opts{"yopcodes"};} == 0
ABresult
1X1
011
000
2622 0 $self->{ERRSTR}='transform: no yopcodes given.';
2623 0 return undef;
2624 }
2625  
2626 0 @op=@{$opts{'yopcodes'}};
2627 0 for $iop (@op) {
2628 0 ▶ if (!defined ($OPCODES{$iop}) and ($iop !~ /^\d+$/) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/) 0 0 0
Condition0%0/3
defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/
l!l&&r!l&&!r
000
MC/DC0%0/2
defined $Imager::OPCODES{$iop} or $iop =~ /^\d+$/
defined $Imager::OPCODES{$iop} $iop =~ /^\d+$/
Truth table0%0/3
A or B
A= defined $Imager::OPCODES{$iop}B= $iop =~ /^\d+$/
ABresult
1X1
011
000
2629 0 $self->{ERRSTR}="transform: illegal opcode '$_'.";
2630 0 return undef;
2631 }
2632 0 ▶ push(@ropy,(exists $OPCODES{$iop}) ? @{$OPCODES{$iop}} : $iop );
Branch: 1 branch
BranchTrueFalseTotal
exists $Imager::OPCODES{$iop} ? : 0 0 0
2633 }
2634  
2635 #parameters
2636  
2637 0 ▶ if ( !exists $opts{'parm'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"parm"}) 0 0 0
2638 0 $self->{ERRSTR}='transform: no parameter arg given.';
2639 0 return undef;
2640 }
2641  
2642 # print Dumper(\@ropx);
2643 # print Dumper(\@ropy);
2644 # print Dumper(\@ropy);
2645  
2646 0 my $img = Imager->new();
2647 0 $img->{IMG}=i_transform($self->{IMG},\@ropx,\@ropy,$opts{'parm'});
2648 0 ▶ if ( !defined($img->{IMG}) ) { $self->{ERRSTR}='transform: failed'; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 0 0 0
2649 0 return $img;
2650 }
2651  
2652  
2653 30 ▶sub transform2 {
Subroutine transform2: called CC=14 SCAR=27.5
Pod undocumented
2654 30 my ($opts, @imgs) = @_;
2655
2656 30 require "Imager/Expr.pm";
2657  
2658 30 $opts->{variables} = [ qw(x y) ];
2659 30 my ($width, $height) = @{$opts}{qw(width height)};
2660 30 ▶ if (@imgs) {
Branch: 1 branch
BranchTrueFalseTotal
if (@imgs) 26 4 30
2661 26 my $index = 1;
2662 26 for my $img (@imgs) {
2663 28 ▶ unless ($img->_valid_image("transform2")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($img->_valid_image("transform2")) 1 27 28
2664 1 Imager->_set_error($img->errstr . " (input image $index)");
2665 1 return;
2666 }
2667 27 ++$index;
2668 }
2669  
2670 25 ▶ $width ||= $imgs[0]->getwidth();
Condition33%1/3
$width ||= $imgs[0]->getwidth
l!l&&r!l&&!r
0250
MC/DC0%0/2
$width ||= $imgs[0]->getwidth
$width $imgs[0]->getwidth
Truth table33%1/3
A ||= B
A= $widthB= $imgs[0]->getwidth
ABresult
1X1
011
000
2671 25 ▶ $height ||= $imgs[0]->getheight();
Condition33%1/3
$height ||= $imgs[0]->getheight
l!l&&r!l&&!r
0250
MC/DC0%0/2
$height ||= $imgs[0]->getheight
$height $imgs[0]->getheight
Truth table33%1/3
A ||= B
A= $heightB= $imgs[0]->getheight
ABresult
1X1
011
000
2672 25 my $img_num = 1;
2673 25 for my $img (@imgs) {
2674 26 $opts->{constants}{"w$img_num"} = $img->getwidth();
2675 26 $opts->{constants}{"h$img_num"} = $img->getheight();
2676 26 $opts->{constants}{"cx$img_num"} = $img->getwidth()/2;
2677 26 $opts->{constants}{"cy$img_num"} = $img->getheight()/2;
2678 26 ++$img_num;
2679 }
2680 }
2681 29 ▶ if ($width) {
Branch: 1 branch
BranchTrueFalseTotal
if ($width) { } 28 1 29
2682 28 $opts->{constants}{w} = $width;
2683 28 $opts->{constants}{cx} = $width/2;
2684 }
2685 else {
2686 1 $Imager::ERRSTR = "No width supplied";
2687 1 return;
2688 }
2689 28 ▶ if ($height) {
Branch: 1 branch
BranchTrueFalseTotal
if ($height) { } 28 0 28
2690 28 $opts->{constants}{h} = $height;
2691 28 $opts->{constants}{cy} = $height/2;
2692 }
2693 else {
2694 0 $Imager::ERRSTR = "No height supplied";
2695 0 return;
2696 }
2697 28 my $code = Imager::Expr->new($opts);
2698 28 ▶ if (!$code) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($code) 0 28 28
2699 0 $Imager::ERRSTR = Imager::Expr::error();
2700 0 return;
2701 }
2702 28 ▶ my $channels = $opts->{channels} || 3;
Condition100%2/2
$opts->{'channels'} || 3
l!l
127
MC/DC100%1/1
$opts->{'channels'} || 3
$opts->{'channels'}
Truth table100%2/2
A
A= $opts->{'channels'}
Aresult
11
00
2703 28 ▶ unless ($channels >= 1 && $channels <= 4) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($channels >= 1 and $channels <= 4) 0 28 28
Condition33%1/3
$channels >= 1 and $channels <= 4
!ll&&!rl&&r
0028
MC/DC0%0/2
$channels >= 1 and $channels <= 4
$channels >= 1 $channels <= 4
Truth table33%1/3
A and B
A= $channels >= 1B= $channels <= 4
ABresult
0X0
100
111
2704 0 return Imager->_set_error("channels must be an integer between 1 and 4");
2705 }
2706  
2707 28 my $img = Imager->new();
2708 $img->{IMG} = i_transform2($opts->{width}, $opts->{height},
2709 $channels, $code->code(),
2710 $code->nregs(), $code->cregs(),
2711 28 [ map { $_->{IMG} } @imgs ]);
2712 28 ▶ if (!defined $img->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $img->{"IMG"}) 1 27 28
2713 1 $Imager::ERRSTR = Imager->_error_as_msg();
2714 1 return;
2715 }
2716  
2717 27 return $img;
2718 }
2719  
2720 22 ▶sub rubthrough {
Subroutine rubthrough: called CC=9 SCAR=22.1
Pod undocumented
2721 22 my $self=shift;
2722 22 my %opts= @_;
2723  
2724 22 ▶ $self->_valid_image("rubthrough")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("rubthrough") or return 21 1 22
2725 or return;
2726  
2727 21 ▶ unless ($opts{src} && $opts{src}->_valid_image("rubthrough")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"src"} and $opts{"src"}->_valid_image("rubthrough")) 1 20 21
Condition66%2/3
$opts{"src"} and $opts{"src"}->_valid_image("rubthrough")
!ll&&!rl&&r
0120
MC/DC50%1/2
$opts{"src"} and $opts{"src"}->_valid_image("rubthrough")
$opts{"src"} $opts{"src"}->_valid_image("rubthrough")
Truth table66%2/3
A and B
A= $opts{"src"}B= $opts{"src"}->_valid_image("rubthrough")
ABresult
0X0
100
111
2728 1 $self->{ERRSTR} = $opts{src}{ERRSTR} . ' (for src)';
2729 1 return;
2730 }
2731  
2732 %opts = (src_minx => 0,
2733 src_miny => 0,
2734 src_maxx => $opts{src}->getwidth(),
2735 20 src_maxy => $opts{src}->getheight(),
2736 %opts);
2737  
2738 20 my $tx = $opts{tx};
2739 20 ▶ defined $tx or $tx = $opts{left};
Branch: 1 branch
BranchTrueFalseTotal
defined $tx or $tx = $opts{"left"} 2 18 20
2740 20 ▶ defined $tx or $tx = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $tx or $tx = 0 18 2 20
2741  
2742 20 my $ty = $opts{ty};
2743 20 ▶ defined $ty or $ty = $opts{top};
Branch: 1 branch
BranchTrueFalseTotal
defined $ty or $ty = $opts{"top"} 2 18 20
2744 20 ▶ defined $ty or $ty = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $ty or $ty = 0 18 2 20
2745  
2746 20 ▶ unless (i_rubthru($self->{IMG}, $opts{src}->{IMG}, $tx, $ty,
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_rubthru($self->{"IMG"}, $opts{"src"}{"IMG"}, $tx, $ty, $opts{"src_minx"}, $opts{"src_miny"}, $opts{"src_maxx"}, $opts{"src_maxy"})) 0 20 20
2747 $opts{src_minx}, $opts{src_miny},
2748 $opts{src_maxx}, $opts{src_maxy})) {
2749 0 $self->_set_error($self->_error_as_msg());
2750 0 return undef;
2751 }
2752  
2753 20 return $self;
2754 }
2755  
2756 58 ▶sub compose {
Subroutine compose: called CC=26 SCAR=33.4
Pod undocumented
2757 58 my $self = shift;
2758 58 my %opts =
2759 (
2760 opacity => 1.0,
2761 mask_left => 0,
2762 mask_top => 0,
2763 @_
2764 );
2765  
2766 58 ▶ $self->_valid_image("compose")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("compose") or return 57 1 58
2767 or return;
2768  
2769 57 ▶ unless ($opts{src}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"src"}) 0 57 57
2770 0 $self->_set_error("compose: src parameter missing");
2771 0 return;
2772 }
2773
2774 57 ▶ unless ($opts{src}->_valid_image("compose")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"src"}->_valid_image("compose")) 1 56 57
2775 1 $self->_set_error($opts{src}->errstr . " (for src)");
2776 1 return;
2777 }
2778 56 my $src = $opts{src};
2779  
2780 56 my $left = $opts{left};
2781 56 ▶ defined $left or $left = $opts{tx};
Branch: 1 branch
BranchTrueFalseTotal
defined $left or $left = $opts{"tx"} 0 56 56
2782 56 ▶ defined $left or $left = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $left or $left = 0 47 9 56
2783  
2784 56 my $top = $opts{top};
2785 56 ▶ defined $top or $top = $opts{ty};
Branch: 1 branch
BranchTrueFalseTotal
defined $top or $top = $opts{"ty"} 0 56 56
2786 56 ▶ defined $top or $top = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $top or $top = 0 47 9 56
2787  
2788 56 my $src_left = $opts{src_left};
2789 56 ▶ defined $src_left or $src_left = $opts{src_minx};
Branch: 1 branch
BranchTrueFalseTotal
defined $src_left or $src_left = $opts{"src_minx"} 8 48 56
2790 56 ▶ defined $src_left or $src_left = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $src_left or $src_left = 0 8 48 56
2791  
2792 56 my $src_top = $opts{src_top};
2793 56 ▶ defined $src_top or $src_top = $opts{src_miny};
Branch: 1 branch
BranchTrueFalseTotal
defined $src_top or $src_top = $opts{"src_miny"} 8 48 56
2794 56 ▶ defined $src_top or $src_top = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $src_top or $src_top = 0 8 48 56
2795  
2796 56 my $width = $opts{width};
2797 56 ▶ if (!defined $width && defined $opts{src_maxx}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $width and defined $opts{"src_maxx"}) 0 56 56
Condition66%2/3
not defined $width and defined $opts{"src_maxx"}
!ll&&!rl&&r
4520
MC/DC0%0/2
not defined $width and defined $opts{"src_maxx"}
not defined $width defined $opts{"src_maxx"}
Truth table66%2/3
not(A) and B
A= not defined $widthB= defined $opts{"src_maxx"}
ABresult
0X0
100
111
2798 0 $width = $opts{src_maxx} - $src_left;
2799 }
2800 56 ▶ defined $width or $width = $src->getwidth() - $src_left;
Branch: 1 branch
BranchTrueFalseTotal
defined $width or $width = $src->getwidth - $src_left 4 52 56
2801  
2802 56 my $height = $opts{height};
2803 56 ▶ if (!defined $height && defined $opts{src_maxy}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $height and defined $opts{"src_maxy"}) 0 56 56
Condition66%2/3
not defined $height and defined $opts{"src_maxy"}
!ll&&!rl&&r
4520
MC/DC0%0/2
not defined $height and defined $opts{"src_maxy"}
not defined $height defined $opts{"src_maxy"}
Truth table66%2/3
not(A) and B
A= not defined $heightB= defined $opts{"src_maxy"}
ABresult
0X0
100
111
2804 0 $height = $opts{src_maxy} - $src_top;
2805 }
2806 56 ▶ defined $height or $height = $src->getheight() - $src_top;
Branch: 1 branch
BranchTrueFalseTotal
defined $height or $height = $src->getheight - $src_top 4 52 56
2807  
2808 56 my $combine = $self->_combine($opts{combine}, 'normal');
2809  
2810 56 ▶ if ($opts{mask}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'mask'}) { } 31 25 56
2811 31 ▶ unless ($opts{mask}->_valid_image("compose")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"mask"}->_valid_image("compose")) 1 30 31
2812 1 $self->_set_error($opts{mask}->errstr . " (for mask)");
2813 1 return;
2814 }
2815  
2816 30 my $mask_left = $opts{mask_left};
2817 30 ▶ defined $mask_left or $mask_left = $opts{mask_minx};
Branch: 1 branch
BranchTrueFalseTotal
defined $mask_left or $mask_left = $opts{"mask_minx"} 30 0 30
2818 30 ▶ defined $mask_left or $mask_left = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $mask_left or $mask_left = 0 30 0 30
2819
2820 30 my $mask_top = $opts{mask_top};
2821 30 ▶ defined $mask_top or $mask_top = $opts{mask_miny};
Branch: 1 branch
BranchTrueFalseTotal
defined $mask_top or $mask_top = $opts{"mask_miny"} 30 0 30
2822 30 ▶ defined $mask_top or $mask_top = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $mask_top or $mask_top = 0 30 0 30
2823  
2824 30 ▶ unless (i_compose_mask($self->{IMG}, $src->{IMG}, $opts{mask}{IMG},
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_compose_mask($self->{"IMG"}, $src->{"IMG"}, $opts{"mask"}{"IMG"}, $left, $top, $src_left, $src_top, $mask_left, $mask_top, $width, $height, $combine, $opts{"opacity"})) 10 20 30
2825 $left, $top, $src_left, $src_top,
2826 $mask_left, $mask_top, $width, $height,
2827 $combine, $opts{opacity})) {
2828 10 $self->_set_error(Imager->_error_as_msg);
2829 10 return;
2830 }
2831 }
2832 else {
2833 25 ▶ unless (i_compose($self->{IMG}, $src->{IMG}, $left, $top, $src_left, $src_top,
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_compose($self->{"IMG"}, $src->{"IMG"}, $left, $top, $src_left, $src_top, $width, $height, $combine, $opts{"opacity"})) 10 15 25
2834 $width, $height, $combine, $opts{opacity})) {
2835 10 $self->_set_error(Imager->_error_as_msg);
2836 10 return;
2837 }
2838 }
2839  
2840 35 return $self;
2841 }
2842  
2843 144 ▶sub flip {
Subroutine flip: called CC=5 SCAR=17.1
Pod undocumented
2844 144 my $self = shift;
2845 144 my %opts = @_;
2846  
2847 144 ▶ $self->_valid_image("flip")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("flip") or return 143 1 144
2848 or return;
2849  
2850 143 my %xlate = (h=>0, v=>1, hv=>2, vh=>2);
2851 143 my $dir;
2852 143 ▶ return () unless defined $opts{'dir'} and defined $xlate{$opts{'dir'}};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $opts{"dir"} and defined $xlate{$opts{"dir"}} 0 143 143
Condition33%1/3
defined $opts{"dir"} and defined $xlate{$opts{"dir"}}
!ll&&!rl&&r
00143
MC/DC0%0/2
defined $opts{"dir"} and defined $xlate{$opts{"dir"}}
defined $opts{"dir"} defined $xlate{$opts{"dir"}}
Truth table33%1/3
A and B
A= defined $opts{"dir"}B= defined $xlate{$opts{"dir"}}
ABresult
0X0
100
111
2853 143 $dir = $xlate{$opts{'dir'}};
2854 143 ▶ return $self if i_flipxy($self->{IMG}, $dir);
Branch: 1 branch
BranchTrueFalseTotal
if &i_flipxy($self->{"IMG"}, $dir) 143 0 143
2855 0 return ();
2856 }
2857  
2858 43 ▶sub rotate {
Subroutine rotate: called CC=16 SCAR=30.4
Pod undocumented
2859 43 my $self = shift;
2860 43 my %opts = @_;
2861  
2862 43 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 42 43
2863 1 my @caller = caller;
2864 1 warn "rotate() called in void context - rotate() returns the rotated image at $caller[1] line $caller[2]\n";
2865 1 return;
2866 }
2867  
2868 42 ▶ $self->_valid_image("rotate")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("rotate") or return 41 1 42
2869 or return;
2870  
2871 41 ▶ if (defined $opts{right}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $opts{'right'}) { } 30 11 41
elsif (defined $opts{'radians'} or defined $opts{'degrees'}) { } 11 0 11
2872 30 my $degrees = $opts{right};
2873 30 ▶ if ($degrees < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($degrees < 0) 0 30 30
2874 0 $degrees += 360 * int(((-$degrees)+360)/360);
2875 }
2876 30 $degrees = $degrees % 360;
2877 30 ▶ if ($degrees == 0) {
Branch: 2 branches
BranchTrueFalseTotal
if ($degrees == 0) { } 2 28 30
elsif ($degrees == 90 or $degrees == 180 or $degrees == 270) { } 28 0 28
2878 2 return $self->copy();
2879 }
2880 ▶ elsif ($degrees == 90 || $degrees == 180 || $degrees == 270) {
Condition83%5/6
$degrees == 90 or $degrees == 180 or $degrees == 270
l!l&&r!l&&!r
18100
$degrees == 90 or $degrees == 180
l!l&&r!l&&!r
13510
MC/DC0%0/3
$degrees == 90 or $degrees == 180 or $degrees == 270
$degrees == 90 $degrees == 180 $degrees == 270
Truth table75%3/4
A or B or C
A= $degrees == 90B= $degrees == 180C= $degrees == 270
ABCresult
1XX1
01X1
0011
0000
2881 28 my $result = Imager->new();
2882 28 ▶ if ($result->{IMG} = i_rotate90($self->{IMG}, $degrees)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->{'IMG'} = &i_rotate90($self->{'IMG'}, $degrees)) { } 28 0 28
2883 28 return $result;
2884 }
2885 else {
2886 0 $self->{ERRSTR} = $self->_error_as_msg();
2887 0 return undef;
2888 }
2889 }
2890 else {
2891 0 $self->{ERRSTR} = "Parameter 'right' must be a multiple of 90 degrees";
2892 0 return undef;
2893 }
2894 }
2895 ▶ elsif (defined $opts{radians} || defined $opts{degrees}) {
Condition33%1/3
defined $opts{"radians"} or defined $opts{"degrees"}
l!l&&r!l&&!r
0110
MC/DC0%0/2
defined $opts{"radians"} or defined $opts{"degrees"}
defined $opts{"radians"} defined $opts{"degrees"}
Truth table33%1/3
A or B
A= defined $opts{"radians"}B= defined $opts{"degrees"}
ABresult
1X1
011
000
2896 11 ▶ my $amount = $opts{radians} || $opts{degrees} * 3.14159265358979 / 180;
Condition33%1/3
$opts{'radians'} || $opts{'degrees'} * 3.14159265358979 / 180
l!l&&r!l&&!r
0110
MC/DC0%0/2
$opts{'radians'} || $opts{'degrees'} * 3.14159265358979 / 180
$opts{'radians'} $opts{'degrees'} * 3.14159265358979 / 180
Truth table33%1/3
A || B
A= $opts{'radians'}B= $opts{'degrees'} * 3.14159265358979 / 180
ABresult
1X1
011
000
2897  
2898 11 my $back = $opts{back};
2899 11 my $result = Imager->new;
2900 11 ▶ if ($back) {
Branch: 1 branch
BranchTrueFalseTotal
if ($back) { } 6 5 11
2901 6 $back = _color($back);
2902 6 ▶ unless ($back) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($back) 1 5 6
2903 1 $self->_set_error(Imager->errstr);
2904 1 return undef;
2905 }
2906  
2907 5 $result->{IMG} = i_rotate_exact($self->{IMG}, $amount, $back);
2908 }
2909 else {
2910 5 $result->{IMG} = i_rotate_exact($self->{IMG}, $amount);
2911 }
2912 10 ▶ if ($result->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->{'IMG'}) { } 10 0 10
2913 10 return $result;
2914 }
2915 else {
2916 0 $self->{ERRSTR} = $self->_error_as_msg();
2917 0 return undef;
2918 }
2919 }
2920 else {
2921 0 $self->{ERRSTR} = "Only the 'right', 'radians' and 'degrees' parameters are available";
2922 0 return undef;
2923 }
2924 }
2925  
2926 5 ▶sub matrix_transform {
Subroutine matrix_transform: called CC=9 SCAR=23.4
Pod undocumented
2927 5 my $self = shift;
2928 5 my %opts = @_;
2929  
2930 5 ▶ $self->_valid_image("matrix_transform")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("matrix_transform") or return 4 1 5
2931 or return;
2932  
2933 4 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 3 4
2934 1 my @caller = caller;
2935 1 warn "copy() called in void context - copy() returns the copied image at $caller[1] line $caller[2]\n";
2936 1 return;
2937 }
2938  
2939 3 ▶ if ($opts{matrix}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'matrix'}) { } 3 0 3
2940 3 ▶ my $xsize = $opts{xsize} || $self->getwidth;
Condition33%1/3
$opts{'xsize'} || $self->getwidth
l!l&&r!l&&!r
030
MC/DC0%0/2
$opts{'xsize'} || $self->getwidth
$opts{'xsize'} $self->getwidth
Truth table33%1/3
A || B
A= $opts{'xsize'}B= $self->getwidth
ABresult
1X1
011
000
2941 3 ▶ my $ysize = $opts{ysize} || $self->getheight;
Condition33%1/3
$opts{'ysize'} || $self->getheight
l!l&&r!l&&!r
030
MC/DC0%0/2
$opts{'ysize'} || $self->getheight
$opts{'ysize'} $self->getheight
Truth table33%1/3
A || B
A= $opts{'ysize'}B= $self->getheight
ABresult
1X1
011
000
2942  
2943 3 my $result = Imager->new;
2944 3 ▶ if ($opts{back}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'back'}) { } 1 2 3
2945 $result->{IMG} = i_matrix_transform($self->{IMG}, $xsize, $ysize,
2946 $opts{matrix}, $opts{back})
2947 1 ▶ or return undef;
Branch: 1 branch
BranchTrueFalseTotal
$result->{"IMG"} = &i_matrix_transform($self->{"IMG"}, $xsize, $ysize, $opts{"matrix"}, $opts{"back"}) or return undef 1 0 1
2948 }
2949 else {
2950 $result->{IMG} = i_matrix_transform($self->{IMG}, $xsize, $ysize,
2951 $opts{matrix})
2952 2 ▶ or return undef;
Branch: 1 branch
BranchTrueFalseTotal
$result->{"IMG"} = &i_matrix_transform($self->{"IMG"}, $xsize, $ysize, $opts{"matrix"}) or return undef 2 0 2
2953 }
2954  
2955 3 return $result;
2956 }
2957 else {
2958 0 $self->{ERRSTR} = "matrix parameter required";
2959 0 return undef;
2960 }
2961 }
2962  
2963 # blame Leolo :)
2964 79 *yatf = \&matrix_transform;
2965  
2966 # These two are supported for legacy code only
2967  
2968 331 ▶sub i_color_new {
Subroutine i_color_new: called CC=1 SCAR=0.0
Pod undocumented
2969 331 return Imager::Color->new(@_);
2970 }
2971  
2972 0 ▶sub i_color_set {
Subroutine i_color_set: not called CC=1 SCAR=6.9
Pod undocumented
2973 0 return Imager::Color::set(@_);
2974 }
2975  
2976 # Draws a box between the specified corner points.
2977 1043 ▶sub box {
Subroutine box: called CC=19 SCAR=30.0
Pod undocumented
2978 1043 my $self=shift;
2979 1043 my $raw = $self->{IMG};
2980  
2981 1043 ▶ $self->_valid_image("box")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("box") or return 1042 1 1043
2982 or return;
2983  
2984 1042 my %opts = @_;
2985  
2986 1042 my ($xmin, $ymin, $xmax, $ymax);
2987 1042 ▶ if (exists $opts{'box'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts{'box'}) { } 597 445 1042
2988 597 $xmin = _min($opts{'box'}->[0],$opts{'box'}->[2]);
2989 597 $xmax = _max($opts{'box'}->[0],$opts{'box'}->[2]);
2990 597 $ymin = _min($opts{'box'}->[1],$opts{'box'}->[3]);
2991 597 $ymax = _max($opts{'box'}->[1],$opts{'box'}->[3]);
2992 }
2993 else {
2994 445 ▶ defined($xmin = $opts{xmin}) or $xmin = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined($xmin = $opts{"xmin"}) or $xmin = 0 140 305 445
2995 445 ▶ defined($xmax = $opts{xmax}) or $xmax = $self->getwidth()-1;
Branch: 1 branch
BranchTrueFalseTotal
defined($xmax = $opts{"xmax"}) or $xmax = $self->getwidth - 1 141 304 445
2996 445 ▶ defined($ymin = $opts{ymin}) or $ymin = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined($ymin = $opts{"ymin"}) or $ymin = 0 125 320 445
2997 445 ▶ defined($ymax = $opts{ymax}) or $ymax = $self->getheight()-1;
Branch: 1 branch
BranchTrueFalseTotal
defined($ymax = $opts{"ymax"}) or $ymax = $self->getheight - 1 127 318 445
2998 }
2999  
3000 1042 ▶ if ($opts{filled}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'filled'}) { } 923 119 1042
elsif ($opts{'fill'}) { } 115 4 119
3001 923 my $color = $opts{'color'};
3002  
3003 923 ▶ if (defined $color) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $color) { } 921 2 923
3004 921 ▶ unless (_is_color_object($color)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&_is_color_object($color)) 161 760 921
3005 161 $color = _color($color);
3006 161 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 161 161
3007 0 $self->{ERRSTR} = $Imager::ERRSTR;
3008 0 return;
3009 }
3010 }
3011 }
3012 else {
3013 2 $color = i_color_new(255,255,255,255);
3014 }
3015  
3016 923 ▶ if ($color->isa("Imager::Color")) {
Branch: 1 branch
BranchTrueFalseTotal
if ($color->isa('Imager::Color')) { } 886 37 923
3017 886 i_box_filled($raw, $xmin, $ymin,$xmax, $ymax, $color);
3018 }
3019 else {
3020 37 i_box_filledf($raw, $xmin, $ymin,$xmax, $ymax, $color);
3021 }
3022 }
3023 elsif ($opts{fill}) {
3024 115 ▶ unless (UNIVERSAL::isa($opts{fill}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 8 107 115
3025 # assume it's a hash ref
3026 8 require 'Imager/Fill.pm';
3027 8 ▶ unless ($opts{fill} = Imager::Fill->new(%{$opts{fill}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 0 8 8
3028 0 $self->{ERRSTR} = $Imager::ERRSTR;
3029 0 return undef;
3030 }
3031 }
3032 115 i_box_cfill($raw, $xmin, $ymin, $xmax, $ymax, $opts{fill}{fill});
3033 }
3034 else {
3035 4 my $color = $opts{'color'};
3036 4 ▶ if (defined $color) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $color) { } 3 1 4
3037 3 ▶ unless (_is_color_object($color)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&_is_color_object($color)) 2 1 3
3038 2 $color = _color($color);
3039 2 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 2 2
3040 0 $self->{ERRSTR} = $Imager::ERRSTR;
3041 0 return;
3042 }
3043 }
3044 }
3045 else {
3046 1 $color = i_color_new(255, 255, 255, 255);
3047 }
3048 4 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 4 4
3049 0 $self->{ERRSTR} = $Imager::ERRSTR;
3050 0 return;
3051 }
3052 4 i_box($raw, $xmin, $ymin, $xmax, $ymax, $color);
3053 }
3054  
3055 1042 return $self;
3056 }
3057  
3058 274 ▶sub arc {
Subroutine arc: called CC=22 SCAR=31.8
Pod undocumented
3059 274 my $self=shift;
3060  
3061 274 ▶ $self->_valid_image("arc")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("arc") or return 273 1 274
3062 or return;
3063  
3064 273 my $dflcl= [ 255, 255, 255, 255];
3065 273 my $good = 1;
3066 273 my %opts=
3067 (
3068 color=>$dflcl,
3069 'r'=>_min($self->getwidth(),$self->getheight())/3,
3070 'x'=>$self->getwidth()/2,
3071 'y'=>$self->getheight()/2,
3072 'd1'=>0, 'd2'=>361,
3073 filled => 1,
3074 @_,
3075 );
3076 273 ▶ if ($opts{aa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'aa'}) { } 133 140 273
3077 133 ▶ if ($opts{fill}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'fill'}) { } 2 131 133
elsif ($opts{'filled'}) { } 33 98 131
3078 2 ▶ unless (UNIVERSAL::isa($opts{fill}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 2 0 2
3079 # assume it's a hash ref
3080 2 require 'Imager/Fill.pm';
3081 2 ▶ unless ($opts{fill} = Imager::Fill->new(%{$opts{fill}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 0 2 2
3082 0 $self->{ERRSTR} = $Imager::ERRSTR;
3083 0 return;
3084 }
3085 }
3086 2 ▶ if ($opts{d1} == 0 && $opts{d2} == 361) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'d1'} == 0 and $opts{'d2'} == 361) { } 1 1 2
Condition66%2/3
$opts{"d1"} == 0 and $opts{"d2"} == 361
!ll&&!rl&&r
101
MC/DC50%1/2
$opts{"d1"} == 0 and $opts{"d2"} == 361
$opts{"d1"} == 0 $opts{"d2"} == 361
Truth table66%2/3
A and B
A= $opts{"d1"} == 0B= $opts{"d2"} == 361
ABresult
0X0
100
111
3087 i_circle_aa_fill($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{'r'},
3088 1 $opts{fill}{fill});
3089 }
3090 else {
3091 i_arc_aa_cfill($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},$opts{'d1'},
3092 1 $opts{'d2'}, $opts{fill}{fill});
3093 }
3094 }
3095 elsif ($opts{filled}) {
3096 33 my $color = _color($opts{'color'});
3097 33 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 33 33
3098 0 $self->{ERRSTR} = $Imager::ERRSTR;
3099 0 return;
3100 }
3101 33 ▶ if ($opts{d1} == 0 && $opts{d2} == 361 && $opts{aa}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'d1'} == 0 and $opts{'d2'} == 361 and $opts{'aa'}) { } 8 25 33
Condition100%6/6
$opts{"d1"} == 0 and $opts{"d2"} == 361 and $opts{"aa"}
!ll&&!rl&&r
2517
$opts{"d1"} == 0 and $opts{"d2"} == 361
!ll&&!rl&&r
2418
MC/DC66%2/3
$opts{"d1"} == 0 and $opts{"d2"} == 361 and $opts{"aa"}
$opts{"d1"} == 0 $opts{"d2"} == 361 $opts{"aa"}
Truth table75%3/4
A and B and C
A= $opts{"d1"} == 0B= $opts{"d2"} == 361C= $opts{"aa"}
ABCresult
0XX0
10X0
1100
1111
3102 8 i_circle_aa($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{'r'},
3103 $color);
3104 }
3105 else {
3106 i_arc_aa($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},
3107 25 $opts{'d1'}, $opts{'d2'}, $color);
3108 }
3109 }
3110 else {
3111 98 my $color = _color($opts{'color'});
3112 98 ▶ if ($opts{d2} - $opts{d1} >= 360) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'d2'} - $opts{'d1'} >= 360) { } 25 73 98
3113 25 $good = i_circle_out_aa($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{'r'}, $color);
3114 }
3115 else {
3116 73 $good = i_arc_out_aa($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{'r'}, $opts{'d1'}, $opts{'d2'}, $color);
3117 }
3118 }
3119 }
3120 else {
3121 140 ▶ if ($opts{fill}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'fill'}) { } 10 130 140
3122 10 ▶ unless (UNIVERSAL::isa($opts{fill}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 10 0 10
3123 # assume it's a hash ref
3124 10 require 'Imager/Fill.pm';
3125 10 ▶ unless ($opts{fill} = Imager::Fill->new(%{$opts{fill}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 1 9 10
3126 1 $self->{ERRSTR} = $Imager::ERRSTR;
3127 1 return;
3128 }
3129 }
3130 i_arc_cfill($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},$opts{'d1'},
3131 9 $opts{'d2'}, $opts{fill}{fill});
3132 }
3133 else {
3134 130 my $color = _color($opts{'color'});
3135 130 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 130 130
3136 0 $self->{ERRSTR} = $Imager::ERRSTR;
3137 0 return;
3138 }
3139 130 ▶ if ($opts{filled}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'filled'}) { } 68 62 130
3140 i_arc($self->{IMG},$opts{'x'},$opts{'y'},$opts{'r'},
3141 68 $opts{'d1'}, $opts{'d2'}, $color);
3142 }
3143 else {
3144 62 ▶ if ($opts{d1} == 0 && $opts{d2} == 361) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'d1'} == 0 and $opts{'d2'} == 361) { } 13 49 62
Condition100%3/3
$opts{"d1"} == 0 and $opts{"d2"} == 361
!ll&&!rl&&r
47213
MC/DC100%2/2
$opts{"d1"} == 0 and $opts{"d2"} == 361
$opts{"d1"} == 0 $opts{"d2"} == 361
Truth table100%3/3
A and B
A= $opts{"d1"} == 0B= $opts{"d2"} == 361
ABresult
0X0
100
111
3145 13 $good = i_circle_out($self->{IMG}, $opts{x}, $opts{y}, $opts{r}, $color);
3146 }
3147 else {
3148 49 $good = i_arc_out($self->{IMG}, $opts{x}, $opts{y}, $opts{r}, $opts{d1}, $opts{d2}, $color);
3149 }
3150 }
3151 }
3152 }
3153 271 ▶ unless ($good) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($good) 0 271 271
3154 0 $self->_set_error($self->_error_as_msg);
3155 0 return;
3156 }
3157  
3158 271 return $self;
3159 }
3160  
3161 # Draws a line from one point to the other
3162 # the endpoint is set if the endp parameter is set which it is by default.
3163 # to turn of the endpoint being set use endp=>0 when calling line.
3164  
3165 289 ▶sub line {
Subroutine line: called CC=9 SCAR=25.3
Pod undocumented
3166 289 my $self=shift;
3167 289 my $dflcl=i_color_new(0,0,0,0);
3168 289 my %opts=(color=>$dflcl,
3169 endp => 1,
3170 @_);
3171  
3172 289 ▶ $self->_valid_image("line")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("line") or return 288 1 289
3173 or return;
3174  
3175 0 ▶ unless (exists $opts{x1} and exists $opts{y1}) { $self->{ERRSTR}='missing begining coord'; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x1"} and exists $opts{"y1"}) 0 288 288
Condition33%1/3
exists $opts{"x1"} and exists $opts{"y1"}
!ll&&!rl&&r
00288
MC/DC0%0/2
exists $opts{"x1"} and exists $opts{"y1"}
exists $opts{"x1"} exists $opts{"y1"}
Truth table33%1/3
A and B
A= exists $opts{"x1"}B= exists $opts{"y1"}
ABresult
0X0
100
111
3176 0 ▶ unless (exists $opts{x2} and exists $opts{y2}) { $self->{ERRSTR}='missing ending coord'; return undef; }
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x2"} and exists $opts{"y2"}) 0 288 288
Condition33%1/3
exists $opts{"x2"} and exists $opts{"y2"}
!ll&&!rl&&r
00288
MC/DC0%0/2
exists $opts{"x2"} and exists $opts{"y2"}
exists $opts{"x2"} exists $opts{"y2"}
Truth table33%1/3
A and B
A= exists $opts{"x2"}B= exists $opts{"y2"}
ABresult
0X0
100
111
3177  
3178 288 my $color = _color($opts{'color'});
3179 288 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 288 288
3180 0 $self->{ERRSTR} = $Imager::ERRSTR;
3181 0 return;
3182 }
3183  
3184 288 ▶ $opts{antialias} = $opts{aa} if defined $opts{aa};
Branch: 1 branch
BranchTrueFalseTotal
if defined $opts{"aa"} 145 143 288
3185 288 ▶ if ($opts{antialias}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'antialias'}) { } 146 142 288
3186 i_line_aa($self->{IMG},$opts{x1}, $opts{y1}, $opts{x2}, $opts{y2},
3187 146 $color, $opts{endp});
3188 } else {
3189 i_line($self->{IMG},$opts{x1}, $opts{y1}, $opts{x2}, $opts{y2},
3190 142 $color, $opts{endp});
3191 }
3192 288 return $self;
3193 }
3194  
3195 # Draws a line between an ordered set of points - It more or less just transforms this
3196 # into a list of lines.
3197  
3198 6 ▶sub polyline {
Subroutine polyline: called CC=13 SCAR=25.8
Pod undocumented
3199 6 my $self=shift;
3200 6 my ($pt,$ls,@points);
3201 6 my $dflcl=i_color_new(0,0,0,0);
3202 6 my %opts=(color=>$dflcl,@_);
3203  
3204 6 ▶ $self->_valid_image("polyline")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("polyline") or return 5 1 6
3205 or return;
3206  
3207 5 ▶ if (exists($opts{points})) { @points=@{$opts{points}}; }
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts{"points"}) 1 4 5
3208 5 ▶ if (!exists($opts{points}) and exists($opts{'x'}) and exists($opts{'y'}) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $opts{"points"} and exists $opts{"x"} and exists $opts{"y"}) 4 1 5
Condition66%4/6
not exists $opts{"points"} and exists $opts{"x"} and exists $opts{"y"}
!ll&&!rl&&r
104
not exists $opts{"points"} and exists $opts{"x"}
!ll&&!rl&&r
104
MC/DC33%1/3
not exists $opts{"points"} and exists $opts{"x"} and exists $opts{"y"}
not exists $opts{"points"} exists $opts{"x"} exists $opts{"y"}
Truth table50%2/4
not(A) and B and C
A= not exists $opts{"points"}B= exists $opts{"x"}C= exists $opts{"y"}
ABCresult
0XX0
10X0
1100
1111
3209 4 @points=map { [ $opts{'x'}->[$_],$opts{'y'}->[$_] ] } (0..(scalar @{$opts{'x'}}-1));
3210 }
3211  
3212 # print Dumper(\@points);
3213  
3214 5 my $color = _color($opts{'color'});
3215 5 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 5 5
3216 0 $self->{ERRSTR} = $Imager::ERRSTR;
3217 0 return;
3218 }
3219 5 ▶ $opts{antialias} = $opts{aa} if defined $opts{aa};
Branch: 1 branch
BranchTrueFalseTotal
if defined $opts{"aa"} 1 4 5
3220 5 ▶ if ($opts{antialias}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'antialias'}) { } 2 3 5
3221 2 for $pt(@points) {
3222 6 ▶ if (defined($ls)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $ls) 4 2 6
3223 4 i_line_aa($self->{IMG},$ls->[0],$ls->[1],$pt->[0],$pt->[1],$color, 1);
3224 }
3225 6 $ls=$pt;
3226 }
3227 } else {
3228 3 for $pt(@points) {
3229 266 ▶ if (defined($ls)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $ls) 263 3 266
3230 263 i_line($self->{IMG},$ls->[0],$ls->[1],$pt->[0],$pt->[1],$color,1);
3231 }
3232 266 $ls=$pt;
3233 }
3234 }
3235 5 return $self;
3236 }
3237  
3238 11 ▶sub polygon {
Subroutine polygon: called CC=11 SCAR=24.9
Pod undocumented
3239 11 my $self = shift;
3240 11 my ($pt,$ls,@points);
3241 11 my $dflcl = i_color_new(0,0,0,0);
3242 11 my %opts = (color=>$dflcl, @_);
3243  
3244 11 ▶ $self->_valid_image("polygon")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("polygon") or return 10 1 11
3245 or return;
3246  
3247 10 ▶ if (exists($opts{points})) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts{"points"}) 8 2 10
3248 8 $opts{'x'} = [ map { $_->[0] } @{$opts{points}} ];
3249 8 $opts{'y'} = [ map { $_->[1] } @{$opts{points}} ];
3250 }
3251  
3252 10 ▶ if (!exists $opts{'x'} or !exists $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x"} and exists $opts{"y"}) 0 10 10
Condition33%1/3
exists $opts{"x"} and exists $opts{"y"}
!ll&&!rl&&r
0010
MC/DC0%0/2
exists $opts{"x"} and exists $opts{"y"}
exists $opts{"x"} exists $opts{"y"}
Truth table33%1/3
A and B
A= exists $opts{"x"}B= exists $opts{"y"}
ABresult
0X0
100
111
3253 0 $self->{ERRSTR} = 'no points array, or x and y arrays.'; return undef;
3254 }
3255  
3256 10 my $mode = _first($opts{mode}, 0);
3257  
3258 10 ▶ if ($opts{'fill'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'fill'}) { } 4 6 10
3259 4 ▶ unless (UNIVERSAL::isa($opts{'fill'}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 3 1 4
3260 # assume it's a hash ref
3261 3 require 'Imager/Fill.pm';
3262 3 ▶ unless ($opts{'fill'} = Imager::Fill->new(%{$opts{'fill'}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 0 3 3
3263 0 $self->{ERRSTR} = $Imager::ERRSTR;
3264 0 return undef;
3265 }
3266 }
3267 4 ▶ unless (i_poly_aa_cfill_m($self->{IMG}, $opts{'x'}, $opts{'y'},
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_poly_aa_cfill_m($self->{"IMG"}, $opts{"x"}, $opts{"y"}, $mode, $opts{"fill"}{"fill"})) 1 3 4
3268 $mode, $opts{'fill'}{'fill'})) {
3269 1 return $self->_set_error($self->_error_as_msg);
3270 }
3271 }
3272 else {
3273 6 my $color = _color($opts{'color'});
3274 6 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 6 6
3275 0 $self->{ERRSTR} = $Imager::ERRSTR;
3276 0 return;
3277 }
3278 6 ▶ unless (i_poly_aa_m($self->{IMG}, $opts{'x'}, $opts{'y'}, $mode, $color)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_poly_aa_m($self->{"IMG"}, $opts{"x"}, $opts{"y"}, $mode, $color)) 1 5 6
3279 1 return $self->_set_error($self->_error_as_msg);
3280 }
3281 }
3282  
3283 8 return $self;
3284 }
3285  
3286 6 ▶sub polypolygon {
Subroutine polypolygon: called CC=15 SCAR=45.3
Pod undocumented
3287 6 my ($self, %opts) = @_;
3288  
3289 6 ▶ $self->_valid_image("polypolygon")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("polypolygon") or return 6 0 6
3290 or return;
3291  
3292 6 my $points = $opts{points};
3293 6 ▶ $points
Branch: 1 branch
BranchTrueFalseTotal
$points or return $self->_set_error("polypolygon: missing required points") 6 0 6
3294 or return $self->_set_error("polypolygon: missing required points");
3295  
3296 6 my $mode = _first($opts{mode}, "evenodd");
3297  
3298 6 ▶ if ($opts{filled}) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'filled'}) { } 6 0 6
elsif ($opts{'fill'}) { } 0 0 0
3299 6 ▶ my $color = _color(_first($opts{color}, [ 0, 0, 0, 0 ]))
Branch: 1 branch
BranchTrueFalseTotal
my $color = _color(_first($opts{"color"}, [0, 0, 0, 0])) or return $self->_set_error($Imager::ERRSTR) 6 0 6
3300 or return $self->_set_error($Imager::ERRSTR);
3301  
3302 6 ▶ i_poly_poly_aa($self->{IMG}, $points, $mode, $color)
Branch: 1 branch
BranchTrueFalseTotal
&i_poly_poly_aa($self->{"IMG"}, $points, $mode, $color) or return $self->_set_error($self->_error_as_msg) 6 0 6
3303 or return $self->_set_error($self->_error_as_msg);
3304 }
3305 elsif ($opts{fill}) {
3306 0 my $fill = $opts{fill};
3307 0 ▶ $self->_valid_fill($fill, "polypolygon")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_fill($fill, "polypolygon") or return 0 0 0
3308 or return;
3309  
3310 i_poly_poly_aa_cfill($self->{IMG}, $points, $mode, $fill->{fill})
3311 0 ▶ or return $self->_set_error($self->_error_as_msg);
Branch: 1 branch
BranchTrueFalseTotal
&i_poly_poly_aa_cfill($self->{"IMG"}, $points, $mode, $fill->{"fill"}) or return $self->_set_error($self->_error_as_msg) 0 0 0
3312 }
3313 else {
3314 0 ▶ my $color = _color(_first($opts{color}, [ 0, 0, 0, 255 ]))
Branch: 1 branch
BranchTrueFalseTotal
my $color = _color(_first($opts{"color"}, [0, 0, 0, 255])) or return $self->_set_error($Imager::ERRSTR) 0 0 0
3315 or return $self->_set_error($Imager::ERRSTR);
3316  
3317 0 my $rimg = $self->{IMG};
3318  
3319 0 ▶ if (_first($opts{aa}, 1)) {
Branch: 1 branch
BranchTrueFalseTotal
if (_first($opts{'aa'}, 1)) { } 0 0 0
3320 0 for my $poly (@$points) {
3321 0 my $xp = $poly->[0];
3322 0 my $yp = $poly->[1];
3323 0 for my $i (0 .. $#$xp - 1) {
3324 0 i_line_aa($rimg, $xp->[$i], $yp->[$i], $xp->[$i+1], $yp->[$i+1],
3325 $color, 0);
3326 }
3327 0 i_line_aa($rimg, $xp->[$#$xp], $yp->[$#$yp], $xp->[0], $yp->[0],
3328 $color, 0);
3329 }
3330 }
3331 else {
3332 0 for my $poly (@$points) {
3333 0 my $xp = $poly->[0];
3334 0 my $yp = $poly->[1];
3335 0 for my $i (0 .. $#$xp - 1) {
3336 0 i_line($rimg, $xp->[$i], $yp->[$i], $xp->[$i+1], $yp->[$i+1],
3337 $color, 0);
3338 }
3339 0 i_line($rimg, $xp->[$#$xp], $yp->[$#$yp], $xp->[0], $yp->[0],
3340 $color, 0);
3341 }
3342 }
3343 }
3344  
3345 6 return $self;
3346 }
3347  
3348 # this the multipoint bezier curve
3349 # this is here more for testing that actual usage since
3350 # this is not a good algorithm. Usually the curve would be
3351 # broken into smaller segments and each done individually.
3352  
3353 0 ▶sub polybezier {
Subroutine polybezier: not called CC=6 SCAR=37.4
Pod undocumented
3354 0 my $self=shift;
3355 0 my ($pt,$ls,@points);
3356 0 my $dflcl=i_color_new(0,0,0,0);
3357 0 my %opts=(color=>$dflcl,@_);
3358  
3359 0 ▶ $self->_valid_image("polybezier")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("polybezier") or return 0 0 0
3360 or return;
3361  
3362 0 ▶ if (exists $opts{points}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts{"points"}) 0 0 0
3363 0 $opts{'x'}=map { $_->[0]; } @{$opts{'points'}};
3364 0 $opts{'y'}=map { $_->[1]; } @{$opts{'points'}};
3365 }
3366  
3367 0 ▶ unless ( @{$opts{'x'}} and @{$opts{'x'}} == @{$opts{'y'}} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@{$opts{"x"};} and @{$opts{"x"};} == @{$opts{"y"};}) 0 0 0
Condition0%0/3
@{$opts{"x"};} and @{$opts{"x"};} == @{$opts{"y"};}
!ll&&!rl&&r
000
MC/DC0%0/2
@{$opts{"x"};} and @{$opts{"x"};} == @{$opts{"y"};}
@{$opts{"x"};} @{$opts{"x"};} == @{$opts{"y"};}
Truth table0%0/3
A and B
A= @{$opts{"x"};}B= @{$opts{"x"};} == @{$opts{"y"};}
ABresult
0X0
100
111
3368 0 $self->{ERRSTR}='Missing or invalid points.';
3369 0 return;
3370 }
3371  
3372 0 my $color = _color($opts{'color'});
3373 0 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 0 0
3374 0 $self->{ERRSTR} = $Imager::ERRSTR;
3375 0 return;
3376 }
3377 0 i_bezier_multi($self->{IMG},$opts{'x'},$opts{'y'},$color);
3378 0 return $self;
3379 }
3380  
3381 90 ▶sub flood_fill {
Subroutine flood_fill: called CC=16 SCAR=33.4
Pod undocumented
3382 90 my $self = shift;
3383 90 my %opts = ( color=>Imager::Color->new(255, 255, 255), @_ );
3384 90 my $rc;
3385  
3386 90 ▶ $self->_valid_image("flood_fill")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("flood_fill") or return 89 1 90
3387 or return;
3388  
3389 89 ▶ unless (exists $opts{'x'} && exists $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x"} and exists $opts{"y"}) 0 89 89
Condition33%1/3
exists $opts{"x"} and exists $opts{"y"}
!ll&&!rl&&r
0089
MC/DC0%0/2
exists $opts{"x"} and exists $opts{"y"}
exists $opts{"x"} exists $opts{"y"}
Truth table33%1/3
A and B
A= exists $opts{"x"}B= exists $opts{"y"}
ABresult
0X0
100
111
3390 0 $self->{ERRSTR} = "missing seed x and y parameters";
3391 0 return undef;
3392 }
3393  
3394 89 ▶ if ($opts{border}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'border'}) { } 2 87 89
3395 2 my $border = _color($opts{border});
3396 2 ▶ unless ($border) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($border) 0 2 2
3397 0 $self->_set_error($Imager::ERRSTR);
3398 0 return;
3399 }
3400 2 ▶ if ($opts{fill}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'fill'}) { } 1 1 2
3401 1 ▶ unless (UNIVERSAL::isa($opts{fill}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 1 0 1
3402 # assume it's a hash ref
3403 1 require Imager::Fill;
3404 1 ▶ unless ($opts{fill} = Imager::Fill->new(%{$opts{fill}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 0 1 1
3405 0 $self->{ERRSTR} = $Imager::ERRSTR;
3406 0 return;
3407 }
3408 }
3409 $rc = i_flood_cfill_border($self->{IMG}, $opts{'x'}, $opts{'y'},
3410 1 $opts{fill}{fill}, $border);
3411 }
3412 else {
3413 1 my $color = _color($opts{'color'});
3414 1 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 1 1
3415 0 $self->{ERRSTR} = $Imager::ERRSTR;
3416 0 return;
3417 }
3418 1 $rc = i_flood_fill_border($self->{IMG}, $opts{'x'}, $opts{'y'},
3419 $color, $border);
3420 }
3421 2 ▶ if ($rc) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rc) { } 2 0 2
3422 2 return $self;
3423 }
3424 else {
3425 0 $self->{ERRSTR} = $self->_error_as_msg();
3426 0 return;
3427 }
3428 }
3429 else {
3430 87 ▶ if ($opts{fill}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'fill'}) { } 1 86 87
3431 1 ▶ unless (UNIVERSAL::isa($opts{fill}, 'Imager::Fill')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (UNIVERSAL::isa($opts{"fill"}, "Imager::Fill")) 1 0 1
3432 # assume it's a hash ref
3433 1 require 'Imager/Fill.pm';
3434 1 ▶ unless ($opts{fill} = Imager::Fill->new(%{$opts{fill}})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"fill"} = "Imager::Fill"->new(%{$opts{"fill"};})) 0 1 1
3435 0 $self->{ERRSTR} = $Imager::ERRSTR;
3436 0 return;
3437 }
3438 }
3439 1 $rc = i_flood_cfill($self->{IMG}, $opts{'x'}, $opts{'y'}, $opts{fill}{fill});
3440 }
3441 else {
3442 86 my $color = _color($opts{'color'});
3443 86 ▶ unless ($color) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color) 0 86 86
3444 0 $self->{ERRSTR} = $Imager::ERRSTR;
3445 0 return;
3446 }
3447 86 $rc = i_flood_fill($self->{IMG}, $opts{'x'}, $opts{'y'}, $color);
3448 }
3449 87 ▶ if ($rc) {
Branch: 1 branch
BranchTrueFalseTotal
if ($rc) { } 87 0 87
3450 87 return $self;
3451 }
3452 else {
3453 0 $self->{ERRSTR} = $self->_error_as_msg();
3454 0 return;
3455 }
3456 }
3457 }
3458  
3459 140 ▶sub setpixel {
Subroutine setpixel: called CC=25 SCAR=32.2
Pod undocumented
3460 140 my ($self, %opts) = @_;
3461  
3462 140 ▶ $self->_valid_image("setpixel")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("setpixel") or return 139 1 140
3463 or return;
3464  
3465 139 my $color = $opts{color};
3466 139 ▶ unless (defined $color) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $color) 1 138 139
3467 1 $color = $self->{fg};
3468 1 ▶ defined $color or $color = NC(255, 255, 255);
Branch: 1 branch
BranchTrueFalseTotal
defined $color or $color = NC(255, 255, 255) 0 1 1
3469 }
3470  
3471 139 ▶ unless (ref $color && UNIVERSAL::isa($color, "Imager::Color")) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $color and UNIVERSAL::isa($color, "Imager::Color")) 95 44 139
Condition100%3/3
ref $color and UNIVERSAL::isa($color, "Imager::Color")
!ll&&!rl&&r
514444
MC/DC100%2/2
ref $color and UNIVERSAL::isa($color, "Imager::Color")
ref $color UNIVERSAL::isa($color, "Imager::Color")
Truth table100%3/3
A and B
A= ref $colorB= UNIVERSAL::isa($color, "Imager::Color")
ABresult
0X0
100
111
3472 95 ▶ unless ($color = _color($color, 'setpixel')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($color = _color($color, "setpixel")) 1 94 95
3473 1 $self->_set_error("setpixel: " . Imager->errstr);
3474 1 return;
3475 }
3476 }
3477  
3478 138 ▶ unless (exists $opts{'x'} && exists $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x"} and exists $opts{"y"}) 2 136 138
Condition100%3/3
exists $opts{"x"} and exists $opts{"y"}
!ll&&!rl&&r
11136
MC/DC100%2/2
exists $opts{"x"} and exists $opts{"y"}
exists $opts{"x"} exists $opts{"y"}
Truth table100%3/3
A and B
A= exists $opts{"x"}B= exists $opts{"y"}
ABresult
0X0
100
111
3479 2 $self->_set_error('setpixel: missing x or y parameter');
3480 2 return;
3481 }
3482  
3483 136 my $x = $opts{'x'};
3484 136 my $y = $opts{'y'};
3485 136 ▶ if (ref $x || ref $y) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $x or ref $y) { } 10 126 136
Condition100%3/3
ref $x or ref $y
l!l&&r!l&&!r
82126
MC/DC100%2/2
ref $x or ref $y
ref $x ref $y
Truth table100%3/3
A or B
A= ref $xB= ref $y
ABresult
1X1
011
000
3486 10 ▶ $x = ref $x ? $x : [ $x ];
Branch: 1 branch
BranchTrueFalseTotal
ref $x ? : 8 2 10
3487 10 ▶ $y = ref $y ? $y : [ $y ];
Branch: 1 branch
BranchTrueFalseTotal
ref $y ? : 8 2 10
3488 10 ▶ unless (@$x) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@$x) 1 9 10
3489 1 $self->_set_error("setpixel: x is a reference to an empty array");
3490 1 return;
3491 }
3492 9 ▶ unless (@$y) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@$y) 1 8 9
3493 1 $self->_set_error("setpixel: y is a reference to an empty array");
3494 1 return;
3495 }
3496  
3497 # make both the same length, replicating the last element
3498 8 ▶ if (@$x < @$y) {
Branch: 2 branches
BranchTrueFalseTotal
if (@$x < @$y) { } 1 7 8
elsif (@$y < @$x) { } 1 6 7
3499 1 $x = [ @$x, ($x->[-1]) x (@$y - @$x) ];
3500 }
3501 elsif (@$y < @$x) {
3502 1 $y = [ @$y, ($y->[-1]) x (@$x - @$y) ];
3503 }
3504  
3505 8 my $set = 0;
3506 8 ▶ if ($color->isa('Imager::Color')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($color->isa('Imager::Color')) { } 6 2 8
3507 6 for my $i (0..$#$x) {
3508 24 ▶ i_ppix($self->{IMG}, $x->[$i], $y->[$i], $color)
Branch: 1 branch
BranchTrueFalseTotal
&i_ppix($self->{"IMG"}, $x->[$i], $y->[$i], $color) or ++$set 2 22 24
3509 or ++$set;
3510 }
3511 }
3512 else {
3513 2 for my $i (0..$#$x) {
3514 8 ▶ i_ppixf($self->{IMG}, $x->[$i], $y->[$i], $color)
Branch: 1 branch
BranchTrueFalseTotal
&i_ppixf($self->{"IMG"}, $x->[$i], $y->[$i], $color) or ++$set 2 6 8
3515 or ++$set;
3516 }
3517 }
3518  
3519 8 return $set;
3520 }
3521 else {
3522 126 ▶ if ($color->isa('Imager::Color')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($color->isa('Imager::Color')) { } 95 31 126
3523 95 ▶ i_ppix($self->{IMG}, $x, $y, $color)
Branch: 1 branch
BranchTrueFalseTotal
&i_ppix($self->{"IMG"}, $x, $y, $color) and return "0 but true" 18 77 95
3524 and return "0 but true";
3525 }
3526 else {
3527 31 ▶ i_ppixf($self->{IMG}, $x, $y, $color)
Branch: 1 branch
BranchTrueFalseTotal
&i_ppixf($self->{"IMG"}, $x, $y, $color) and return "0 but true" 18 13 31
3528 and return "0 but true";
3529 }
3530  
3531 90 return 1;
3532 }
3533 }
3534  
3535 254 ▶sub getpixel {
Subroutine getpixel: called CC=21 SCAR=30.4
Pod undocumented
3536 254 my $self = shift;
3537  
3538 254 my %opts = ( "type"=>'8bit', @_);
3539  
3540 254 ▶ $self->_valid_image("getpixel")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getpixel") or return 253 1 254
3541 or return;
3542  
3543 253 ▶ unless (exists $opts{'x'} && exists $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"x"} and exists $opts{"y"}) 2 251 253
Condition100%3/3
exists $opts{"x"} and exists $opts{"y"}
!ll&&!rl&&r
11251
MC/DC100%2/2
exists $opts{"x"} and exists $opts{"y"}
exists $opts{"x"} exists $opts{"y"}
Truth table100%3/3
A and B
A= exists $opts{"x"}B= exists $opts{"y"}
ABresult
0X0
100
111
3544 2 $self->_set_error('getpixel: missing x or y parameter');
3545 2 return;
3546 }
3547  
3548 251 my $x = $opts{'x'};
3549 251 my $y = $opts{'y'};
3550 251 my $type = $opts{'type'};
3551 251 ▶ if (ref $x || ref $y) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $x or ref $y) { } 19 232 251
Condition100%3/3
ref $x or ref $y
l!l&&r!l&&!r
172232
MC/DC100%2/2
ref $x or ref $y
ref $x ref $y
Truth table100%3/3
A or B
A= ref $xB= ref $y
ABresult
1X1
011
000
3552 19 ▶ $x = ref $x ? $x : [ $x ];
Branch: 1 branch
BranchTrueFalseTotal
ref $x ? : 17 2 19
3553 19 ▶ $y = ref $y ? $y : [ $y ];
Branch: 1 branch
BranchTrueFalseTotal
ref $y ? : 15 4 19
3554 19 ▶ unless (@$x) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@$x) 1 18 19
3555 1 $self->_set_error("getpixel: x is a reference to an empty array");
3556 1 return;
3557 }
3558 18 ▶ unless (@$y) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@$y) 1 17 18
3559 1 $self->_set_error("getpixel: y is a reference to an empty array");
3560 1 return;
3561 }
3562  
3563 # make both the same length, replicating the last element
3564 17 ▶ if (@$x < @$y) {
Branch: 2 branches
BranchTrueFalseTotal
if (@$x < @$y) { } 1 16 17
elsif (@$y < @$x) { } 3 13 16
3565 1 $x = [ @$x, ($x->[-1]) x (@$y - @$x) ];
3566 }
3567 elsif (@$y < @$x) {
3568 3 $y = [ @$y, ($y->[-1]) x (@$x - @$y) ];
3569 }
3570  
3571 17 my @result;
3572 17 ▶ if ($type eq '8bit') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq '8bit') { } 13 4 17
elsif ($type eq 'float' or $type eq 'double') { } 3 1 4
3573 13 for my $i (0..$#$x) {
3574 40 push(@result, i_get_pixel($self->{IMG}, $x->[$i], $y->[$i]));
3575 }
3576 }
3577 ▶ elsif ($type eq 'float' || $type eq 'double') {
Condition66%2/3
$type eq "float" or $type eq "double"
l!l&&r!l&&!r
301
MC/DC50%1/2
$type eq "float" or $type eq "double"
$type eq "float" $type eq "double"
Truth table66%2/3
A or B
A= $type eq "float"B= $type eq "double"
ABresult
1X1
011
000
3578 3 for my $i (0..$#$x) {
3579 10 push(@result, i_gpixf($self->{IMG}, $x->[$i], $y->[$i]));
3580 }
3581 }
3582 else {
3583 1 $self->_set_error("getpixel: type must be '8bit' or 'float'");
3584 1 return;
3585 }
3586 16 ▶ return wantarray ? @result : \@result;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 16 0 16
3587 }
3588 else {
3589 232 ▶ if ($type eq '8bit') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq '8bit') { } 210 22 232
elsif ($type eq 'float' or $type eq 'double') { } 21 1 22
3590 210 return i_get_pixel($self->{IMG}, $x, $y);
3591 }
3592 ▶ elsif ($type eq 'float' || $type eq 'double') {
Condition100%3/3
$type eq "float" or $type eq "double"
l!l&&r!l&&!r
1921
MC/DC100%2/2
$type eq "float" or $type eq "double"
$type eq "float" $type eq "double"
Truth table100%3/3
A or B
A= $type eq "float"B= $type eq "double"
ABresult
1X1
011
000
3593 21 return i_gpixf($self->{IMG}, $x, $y);
3594 }
3595 else {
3596 1 $self->_set_error("getpixel: type must be '8bit' or 'float'");
3597 1 return;
3598 }
3599 }
3600 }
3601  
3602 39 ▶sub getscanline {
Subroutine getscanline: called CC=8 SCAR=20.9
Pod undocumented
3603 39 my $self = shift;
3604 39 my %opts = ( type => '8bit', x=>0, @_);
3605  
3606 39 ▶ $self->_valid_image("getscanline")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getscanline") or return 38 1 39
3607 or return;
3608  
3609 38 ▶ defined $opts{width} or $opts{width} = $self->getwidth - $opts{x};
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"width"} or $opts{"width"} = $self->getwidth - $opts{"x"} 21 17 38
3610  
3611 38 ▶ unless (defined $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $opts{"y"}) 1 37 38
3612 1 $self->_set_error("missing y parameter");
3613 1 return;
3614 }
3615  
3616 37 ▶ if ($opts{type} eq '8bit') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'type'} eq '8bit') { } 16 21 37
elsif ($opts{'type'} eq 'float') { } 12 9 21
elsif ($opts{'type'} eq 'index') { } 8 1 9
3617 return i_glin($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3618 16 $opts{'y'});
3619 }
3620 elsif ($opts{type} eq 'float') {
3621 return i_glinf($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3622 12 $opts{'y'});
3623 }
3624 elsif ($opts{type} eq 'index') {
3625 8 ▶ unless (i_img_type($self->{IMG})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (&i_img_type($self->{"IMG"})) 0 8 8
3626 0 $self->_set_error("type => index only valid on paletted images");
3627 0 return;
3628 }
3629 return i_gpal($self->{IMG}, $opts{x}, $opts{x} + $opts{width},
3630 8 $opts{'y'});
3631 }
3632 else {
3633 1 $self->_set_error("invalid type parameter - must be '8bit' or 'float'");
3634 1 return;
3635 }
3636 }
3637  
3638 215 ▶sub setscanline {
Subroutine setscanline: called CC=14 SCAR=27.1
Pod undocumented
3639 215 my $self = shift;
3640 215 my %opts = ( x=>0, @_);
3641  
3642 215 ▶ $self->_valid_image("setscanline")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("setscanline") or return 214 1 215
3643 or return;
3644  
3645 214 ▶ unless (defined $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $opts{"y"}) 0 214 214
3646 0 $self->_set_error("missing y parameter");
3647 0 return;
3648 }
3649  
3650 214 ▶ if (!$opts{type}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"type"}) 200 14 214
3651 200 ▶ if (ref $opts{pixels} && @{$opts{pixels}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $opts{'pixels'} and @{$opts{'pixels'};}) { } 49 151 200
Condition66%2/3
ref $opts{"pixels"} and @{$opts{"pixels"};}
!ll&&!rl&&r
151049
MC/DC50%1/2
ref $opts{"pixels"} and @{$opts{"pixels"};}
ref $opts{"pixels"} @{$opts{"pixels"};}
Truth table66%2/3
A and B
A= ref $opts{"pixels"}B= @{$opts{"pixels"};}
ABresult
0X0
100
111
3652 # try to guess the type
3653 49 ▶ if ($opts{pixels}[0]->isa('Imager::Color')) {
Branch: 2 branches
BranchTrueFalseTotal
if ($opts{'pixels'}[0]->isa('Imager::Color')) { } 32 17 49
elsif ($opts{'pixels'}[0]->isa('Imager::Color::Float')) { } 17 0 17
3654 32 $opts{type} = '8bit';
3655 }
3656 elsif ($opts{pixels}[0]->isa('Imager::Color::Float')) {
3657 17 $opts{type} = 'float';
3658 }
3659 else {
3660 0 $self->_set_error("missing type parameter and could not guess from pixels");
3661 0 return;
3662 }
3663 }
3664 else {
3665 # default
3666 151 $opts{type} = '8bit';
3667 }
3668 }
3669  
3670 214 ▶ if ($opts{type} eq '8bit') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'type'} eq '8bit') { } 183 31 214
elsif ($opts{'type'} eq 'float') { } 18 13 31
elsif ($opts{'type'} eq 'index') { } 13 0 13
3671 183 ▶ if (ref $opts{pixels}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $opts{'pixels'}) { } 32 151 183
3672 32 return i_plin($self->{IMG}, $opts{x}, $opts{'y'}, @{$opts{pixels}});
3673 }
3674 else {
3675 151 return i_plin($self->{IMG}, $opts{x}, $opts{'y'}, $opts{pixels});
3676 }
3677 }
3678 elsif ($opts{type} eq 'float') {
3679 18 ▶ if (ref $opts{pixels}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $opts{'pixels'}) { } 17 1 18
3680 17 return i_plinf($self->{IMG}, $opts{x}, $opts{'y'}, @{$opts{pixels}});
3681 }
3682 else {
3683 1 return i_plinf($self->{IMG}, $opts{x}, $opts{'y'}, $opts{pixels});
3684 }
3685 }
3686 elsif ($opts{type} eq 'index') {
3687 13 ▶ if (ref $opts{pixels}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $opts{'pixels'}) { } 9 4 13
3688 9 return i_ppal($self->{IMG}, $opts{x}, $opts{'y'}, @{$opts{pixels}});
3689 }
3690 else {
3691 4 return i_ppal_p($self->{IMG}, $opts{x}, $opts{'y'}, $opts{pixels});
3692 }
3693 }
3694 else {
3695 0 $self->_set_error("invalid type parameter - must be '8bit' or 'float'");
3696 0 return;
3697 }
3698 }
3699  
3700 483 ▶sub getsamples {
Subroutine getsamples: called CC=14 SCAR=27.1
Pod undocumented
3701 483 my $self = shift;
3702 483 my %opts = ( type => '8bit', x=>0, offset => 0, @_);
3703  
3704 483 ▶ $self->_valid_image("getsamples")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getsamples") or return 482 1 483
3705 or return;
3706  
3707 482 ▶ defined $opts{width} or $opts{width} = $self->getwidth - $opts{x};
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"width"} or $opts{"width"} = $self->getwidth - $opts{"x"} 73 409 482
3708  
3709 482 ▶ unless (defined $opts{'y'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $opts{"y"}) 0 482 482
3710 0 $self->_set_error("missing y parameter");
3711 0 return;
3712 }
3713
3714 482 ▶ if ($opts{target}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'target'}) { } 87 395 482
3715 87 my $target = $opts{target};
3716 87 my $offset = $opts{offset};
3717 87 ▶ if ($opts{type} eq '8bit') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'type'} eq '8bit') { } 29 58 87
elsif ($opts{'type'} eq 'float') { } 29 29 58
elsif ($opts{'type'} =~ /^(\d+)bit$/) { } 29 0 29
3718 my @samples = i_gsamp($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3719 $opts{y}, $opts{channels}, $self->{ERRSTR})
3720 29 ▶ or return;
Branch: 1 branch
BranchTrueFalseTotal
my(@samples) = &i_gsamp($self->{"IMG"}, $opts{"x"}, $opts{"x"} + $opts{"width"}, $opts{"y"}, $opts{"channels"}, $self->{"ERRSTR"}) or return 1 28 29
3721 1 @{$target}[$offset .. $offset + @samples - 1] = @samples;
3722 1 return scalar(@samples);
3723 }
3724 elsif ($opts{type} eq 'float') {
3725 my @samples = i_gsampf($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3726 29 $opts{y}, $opts{channels}, $self->{ERRSTR});
3727 29 @{$target}[$offset .. $offset + @samples - 1] = @samples;
3728 29 return scalar(@samples);
3729 }
3730 elsif ($opts{type} =~ /^(\d+)bit$/) {
3731 29 my $bits = $1;
3732  
3733 29 my @data;
3734 my $count = i_gsamp_bits($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3735 $opts{y}, $bits, $target,
3736 29 $offset, $opts{channels}, $self->{ERRSTR});
3737 29 ▶ unless (defined $count) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $count) 28 1 29
3738 28 $self->_set_error(Imager->_error_as_msg);
3739 28 return;
3740 }
3741  
3742 1 return $count;
3743 }
3744 else {
3745 0 $self->_set_error("invalid type parameter - must be '8bit' or 'float'");
3746 0 return;
3747 }
3748 }
3749 else {
3750 395 ▶ if ($opts{type} eq '8bit') {
Branch: 3 branches
BranchTrueFalseTotal
if ($opts{'type'} eq '8bit') { } 325 70 395
elsif ($opts{'type'} eq 'float') { } 42 28 70
elsif ($opts{'type'} =~ /^(\d+)bit$/) { } 28 0 28
3751 return i_gsamp($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3752 325 $opts{y}, $opts{channels}, $self->{ERRSTR});
3753 }
3754 elsif ($opts{type} eq 'float') {
3755 return i_gsampf($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3756 42 $opts{y}, $opts{channels}, $self->{ERRSTR});
3757 }
3758 elsif ($opts{type} =~ /^(\d+)bit$/) {
3759 28 my $bits = $1;
3760  
3761 28 my @data;
3762 i_gsamp_bits($self->{IMG}, $opts{x}, $opts{x}+$opts{width},
3763 $opts{y}, $bits, \@data, 0, $opts{channels},
3764 $self->{ERRSTR})
3765 28 ▶ or return;
Branch: 1 branch
BranchTrueFalseTotal
&i_gsamp_bits($self->{"IMG"}, $opts{"x"}, $opts{"x"} + $opts{"width"}, $opts{"y"}, $bits, \@data, 0, $opts{"channels"}, $self->{"ERRSTR"}) or return 0 28 28
3766 0 return @data;
3767 }
3768 else {
3769 0 $self->_set_error("invalid type parameter - must be '8bit' or 'float'");
3770 0 return;
3771 }
3772 }
3773 }
3774  
3775 15 ▶sub setsamples {
Subroutine setsamples: called CC=13 SCAR=25.7
Pod undocumented
3776 15 my $self = shift;
3777  
3778 15 ▶ $self->_valid_image("setsamples")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("setsamples") or return 14 1 15
3779 or return;
3780  
3781 14 my %opts = ( x => 0, offset => 0 );
3782 14 my $data_index;
3783 # avoid duplicating the data parameter, it may be a large scalar
3784 14 my $i = 0;
3785 14 ▶ while ($i < @_ -1) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @_ - 1) 48 14 62
3786 48 ▶ if ($_[$i] eq 'data') {
Branch: 1 branch
BranchTrueFalseTotal
if ($_[$i] eq 'data') { } 13 35 48
3787 13 $data_index = $i+1;
3788 }
3789 else {
3790 35 $opts{$_[$i]} = $_[$i+1];
3791 }
3792  
3793 48 $i += 2;
3794 }
3795  
3796 14 ▶ unless(defined $data_index) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $data_index) 1 13 14
3797 1 $self->_set_error('setsamples: data parameter missing');
3798 1 return;
3799 }
3800 13 ▶ unless (defined $_[$data_index]) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $_[$data_index]) 1 12 13
3801 1 $self->_set_error('setsamples: data parameter not defined');
3802 1 return;
3803 }
3804  
3805 12 my $type = $opts{type};
3806 12 ▶ defined $type or $type = '8bit';
Branch: 1 branch
BranchTrueFalseTotal
defined $type or $type = "8bit" 7 5 12
3807  
3808 my $width = defined $opts{width} ? $opts{width}
3809 12 ▶ : $self->getwidth() - $opts{x};
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{'width'} ? : 0 12 12
3810  
3811 12 my $count;
3812 12 ▶ if ($type eq '8bit') {
Branch: 3 branches
BranchTrueFalseTotal
if ($type eq '8bit') { } 5 7 12
elsif ($type eq 'float') { } 5 2 7
elsif ($type =~ /^([0-9]+)bit$/) { } 1 1 2
3813 $count = i_psamp($self->{IMG}, $opts{x}, $opts{y}, $opts{channels},
3814 5 $_[$data_index], $opts{offset}, $width);
3815 }
3816 elsif ($type eq 'float') {
3817 $count = i_psampf($self->{IMG}, $opts{x}, $opts{y}, $opts{channels},
3818 5 $_[$data_index], $opts{offset}, $width);
3819 }
3820 elsif ($type =~ /^([0-9]+)bit$/) {
3821 1 my $bits = $1;
3822  
3823 1 ▶ unless (ref $_[$data_index]) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $_[$data_index]) 0 1 1
3824 0 $self->_set_error("setsamples: data must be an array ref for type not 8bit or float");
3825 0 return;
3826 }
3827  
3828 $count = i_psamp_bits($self->{IMG}, $opts{x}, $opts{y}, $bits,
3829 $opts{channels}, $_[$data_index], $opts{offset},
3830 1 $width);
3831 }
3832 else {
3833 1 $self->_set_error('setsamples: type parameter invalid');
3834 1 return;
3835 }
3836  
3837 11 ▶ unless (defined $count) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $count) 4 7 11
3838 4 $self->_set_error(Imager->_error_as_msg);
3839 4 return;
3840 }
3841  
3842 7 return $count;
3843 }
3844  
3845 # make an identity matrix of the given size
3846 6 ▶sub _identity {
Subroutine _identity: called CC=2 SCAR=6.9
3847 6 my ($size) = @_;
3848  
3849 6 my $matrix = [ map { [ (0) x $size ] } 1..$size ];
3850 6 for my $c (0 .. ($size-1)) {
3851 24 $matrix->[$c][$c] = 1;
3852 }
3853 6 return $matrix;
3854 }
3855  
3856 # general function to convert an image
3857 28 ▶sub convert {
Subroutine convert: called CC=28 SCAR=42.4
Pod undocumented
3858 28 my ($self, %opts) = @_;
3859 28 my $matrix;
3860  
3861 28 ▶ $self->_valid_image("convert")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("convert") or return 27 1 28
3862 or return;
3863  
3864 27 ▶ unless (defined wantarray) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined wantarray) 1 26 27
3865 1 my @caller = caller;
3866 1 warn "convert() called in void context - convert() returns the converted image at $caller[1] line $caller[2]\n";
3867 1 return;
3868 }
3869  
3870 # the user can either specify a matrix or preset
3871 # the matrix overrides the preset
3872 26 ▶ if (!exists($opts{matrix})) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $opts{'matrix'}) { } 24 2 26
3873 24 ▶ unless (exists($opts{preset})) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $opts{'preset'}) { } 24 0 24
3874 0 $self->{ERRSTR} = "convert() needs a matrix or preset";
3875 0 return;
3876 }
3877 else {
3878 24 ▶ if ($opts{preset} eq 'gray' || $opts{preset} eq 'grey') {
Branch: 8 branches
BranchTrueFalseTotal
if ($opts{'preset'} eq 'gray' or $opts{'preset'} eq 'grey') { } 6 18 24
elsif ($opts{'preset'} eq 'noalpha') { } 2 16 18
elsif ($opts{'preset'} eq 'red' or $opts{'preset'} eq 'channel0') { } 0 16 16
elsif ($opts{'preset'} eq 'green' or $opts{'preset'} eq 'channel1') { } 0 16 16
elsif ($opts{'preset'} eq 'blue' or $opts{'preset'} eq 'channel2') { } 3 13 16
elsif ($opts{'preset'} eq 'alpha') { } 0 13 13
elsif ($opts{'preset'} eq 'rgb') { } 9 4 13
elsif ($opts{'preset'} eq 'addalpha') { } 4 0 4
Condition100%3/3
$opts{"preset"} eq "gray" or $opts{"preset"} eq "grey"
l!l&&r!l&&!r
1518
MC/DC100%2/2
$opts{"preset"} eq "gray" or $opts{"preset"} eq "grey"
$opts{"preset"} eq "gray" $opts{"preset"} eq "grey"
Truth table100%3/3
A or B
A= $opts{"preset"} eq "gray"B= $opts{"preset"} eq "grey"
ABresult
1X1
011
000
3879 # convert to greyscale, keeping the alpha channel if any
3880 6 ▶ if ($self->getchannels == 3) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->getchannels == 3) { } 6 0 6
elsif ($self->getchannels == 4) { } 0 0 0
3881 6 $matrix = [ [ 0.222, 0.707, 0.071 ] ];
3882 }
3883 elsif ($self->getchannels == 4) {
3884 # preserve the alpha channel
3885 0 $matrix = [ [ 0.222, 0.707, 0.071, 0 ],
3886 [ 0, 0, 0, 1 ] ];
3887 }
3888 else {
3889 # an identity
3890 0 $matrix = _identity($self->getchannels);
3891 }
3892 }
3893 elsif ($opts{preset} eq 'noalpha') {
3894 # strip the alpha channel
3895 2 ▶ if ($self->getchannels == 2 or $self->getchannels == 4) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->getchannels == 2 or $self->getchannels == 4) { } 2 0 2
Condition33%1/3
$self->getchannels == 2 or $self->getchannels == 4
l!l&&r!l&&!r
020
MC/DC0%0/2
$self->getchannels == 2 or $self->getchannels == 4
$self->getchannels == 2 $self->getchannels == 4
Truth table33%1/3
A or B
A= $self->getchannels == 2B= $self->getchannels == 4
ABresult
1X1
011
000
3896 2 $matrix = _identity($self->getchannels);
3897 2 pop(@$matrix); # lose the alpha entry
3898 }
3899 else {
3900 0 $matrix = _identity($self->getchannels);
3901 }
3902 }
3903 ▶ elsif ($opts{preset} eq 'red' || $opts{preset} eq 'channel0') {
Condition33%1/3
$opts{"preset"} eq "red" or $opts{"preset"} eq "channel0"
l!l&&r!l&&!r
0016
MC/DC0%0/2
$opts{"preset"} eq "red" or $opts{"preset"} eq "channel0"
$opts{"preset"} eq "red" $opts{"preset"} eq "channel0"
Truth table33%1/3
A or B
A= $opts{"preset"} eq "red"B= $opts{"preset"} eq "channel0"
ABresult
1X1
011
000
3904 # extract channel 0
3905 0 $matrix = [ [ 1 ] ];
3906 }
3907 ▶ elsif ($opts{preset} eq 'green' || $opts{preset} eq 'channel1') {
Condition33%1/3
$opts{"preset"} eq "green" or $opts{"preset"} eq "channel1"
l!l&&r!l&&!r
0016
MC/DC0%0/2
$opts{"preset"} eq "green" or $opts{"preset"} eq "channel1"
$opts{"preset"} eq "green" $opts{"preset"} eq "channel1"
Truth table33%1/3
A or B
A= $opts{"preset"} eq "green"B= $opts{"preset"} eq "channel1"
ABresult
1X1
011
000
3908 0 $matrix = [ [ 0, 1 ] ];
3909 }
3910 ▶ elsif ($opts{preset} eq 'blue' || $opts{preset} eq 'channel2') {
Condition66%2/3
$opts{"preset"} eq "blue" or $opts{"preset"} eq "channel2"
l!l&&r!l&&!r
3013
MC/DC50%1/2
$opts{"preset"} eq "blue" or $opts{"preset"} eq "channel2"
$opts{"preset"} eq "blue" $opts{"preset"} eq "channel2"
Truth table66%2/3
A or B
A= $opts{"preset"} eq "blue"B= $opts{"preset"} eq "channel2"
ABresult
1X1
011
000
3911 3 $matrix = [ [ 0, 0, 1 ] ];
3912 }
3913 elsif ($opts{preset} eq 'alpha') {
3914 0 ▶ if ($self->getchannels == 2 or $self->getchannels == 4) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->getchannels == 2 or $self->getchannels == 4) { } 0 0 0
Condition0%0/3
$self->getchannels == 2 or $self->getchannels == 4
l!l&&r!l&&!r
000
MC/DC0%0/2
$self->getchannels == 2 or $self->getchannels == 4
$self->getchannels == 2 $self->getchannels == 4
Truth table0%0/3
A or B
A= $self->getchannels == 2B= $self->getchannels == 4
ABresult
1X1
011
000
3915 0 $matrix = [ [ (0) x ($self->getchannels-1), 1 ] ];
3916 }
3917 else {
3918 # the alpha is just 1 <shrug>
3919 0 $matrix = [ [ (0) x $self->getchannels, 1 ] ];
3920 }
3921 }
3922 elsif ($opts{preset} eq 'rgb') {
3923 9 ▶ if ($self->getchannels == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->getchannels == 1) { } 8 1 9
elsif ($self->getchannels == 2) { } 1 0 1
3924 8 $matrix = [ [ 1 ], [ 1 ], [ 1 ] ];
3925 }
3926 elsif ($self->getchannels == 2) {
3927 # preserve the alpha channel
3928 1 $matrix = [ [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], [ 0, 1 ] ];
3929 }
3930 else {
3931 0 $matrix = _identity($self->getchannels);
3932 }
3933 }
3934 elsif ($opts{preset} eq 'addalpha') {
3935 4 ▶ if ($self->getchannels == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->getchannels == 1) { } 0 4 4
elsif ($self->getchannels == 3) { } 4 0 4
3936 0 $matrix = _identity(2);
3937 }
3938 elsif ($self->getchannels == 3) {
3939 4 $matrix = _identity(4);
3940 }
3941 else {
3942 0 $matrix = _identity($self->getchannels);
3943 }
3944 }
3945 else {
3946 0 $self->{ERRSTR} = "Unknown convert preset $opts{preset}";
3947 0 return undef;
3948 }
3949 }
3950 }
3951 else {
3952 2 $matrix = $opts{matrix};
3953 }
3954  
3955 26 my $new = Imager->new;
3956 26 $new->{IMG} = i_convert($self->{IMG}, $matrix);
3957 26 ▶ unless ($new->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($new->{"IMG"}) 1 25 26
3958 # most likely a bad matrix
3959 1 i_push_error(0, "convert");
3960 1 $self->{ERRSTR} = _error_as_msg();
3961 1 return undef;
3962 }
3963 25 return $new;
3964 }
3965  
3966 # combine channels from multiple input images, a class method
3967 14 ▶sub combine {
Subroutine combine: called CC=7 SCAR=19.5
Pod undocumented
3968 14 my ($class, %opts) = @_;
3969  
3970 14 my $src = delete $opts{src};
3971 14 ▶ unless ($src) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($src) 1 13 14
3972 1 $class->_set_error("src parameter missing");
3973 1 return;
3974 }
3975 13 my @imgs;
3976 13 my $index = 0;
3977 13 for my $img (@$src) {
3978 21 ▶ unless (eval { $img->isa("Imager") }) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eval { do { $img->isa("Imager") } }) 1 20 21
3979 1 $class->_set_error("src must contain image objects");
3980 1 return;
3981 }
3982 20 ▶ unless ($img->_valid_image("combine")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($img->_valid_image("combine")) 1 19 20
3983 1 $Imager::ERRSTR = $img->{ERRSTR} . " (src->[$index])";
3984 1 return;
3985 }
3986 19 push @imgs, $img->{IMG};
3987 }
3988 11 my $result;
3989 11 ▶ if (my $channels = delete $opts{channels}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $channels = delete $opts{'channels'}) { } 4 7 11
3990 4 $result = i_combine(\@imgs, $channels);
3991 }
3992 else {
3993 7 $result = i_combine(\@imgs);
3994 }
3995 11 ▶ unless ($result) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result) 4 7 11
3996 4 $class->_set_error($class->_error_as_msg);
3997 4 return;
3998 }
3999  
4000 7 my $img = $class->new;
4001 7 $img->{IMG} = $result;
4002  
4003 7 return $img;
4004 }
4005  
4006  
4007 # general function to map an image through lookup tables
4008  
4009 6 ▶sub map {
Subroutine map: called CC=8 SCAR=21.4
Pod undocumented
4010 6 my ($self, %opts) = @_;
4011 6 my @chlist = qw( red green blue alpha );
4012  
4013 6 ▶ $self->_valid_image("map")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("map") or return 5 1 6
4014 or return;
4015  
4016 5 ▶ if (!exists($opts{'maps'})) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $opts{"maps"}) 1 4 5
4017 # make maps from channel maps
4018 1 my $chnum;
4019 1 for $chnum (0..$#chlist) {
4020 4 ▶ if (exists $opts{$chlist[$chnum]}) {
Branch: 2 branches
BranchTrueFalseTotal
if (exists $opts{$chlist[$chnum]}) { } 3 1 4
elsif (exists $opts{'all'}) { } 0 1 1
4021 3 $opts{'maps'}[$chnum] = $opts{$chlist[$chnum]};
4022 } elsif (exists $opts{'all'}) {
4023 0 $opts{'maps'}[$chnum] = $opts{'all'};
4024 }
4025 }
4026 }
4027 5 ▶ if ($opts{'maps'} and $self->{IMG}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"maps"} and $self->{"IMG"}) 5 0 5
Condition33%1/3
$opts{"maps"} and $self->{"IMG"}
!ll&&!rl&&r
005
MC/DC0%0/2
$opts{"maps"} and $self->{"IMG"}
$opts{"maps"} $self->{"IMG"}
Truth table33%1/3
A and B
A= $opts{"maps"}B= $self->{"IMG"}
ABresult
0X0
100
111
4028 5 i_map($self->{IMG}, $opts{'maps'} );
4029 }
4030 5 return $self;
4031 }
4032  
4033 7 ▶sub difference {
Subroutine difference: called CC=6 SCAR=18.0
Pod undocumented
4034 7 my ($self, %opts) = @_;
4035  
4036 7 ▶ $self->_valid_image("difference")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("difference") or return 6 1 7
4037 or return;
4038  
4039 6 ▶ defined $opts{mindist} or $opts{mindist} = 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"mindist"} or $opts{"mindist"} = 0 2 4 6
4040  
4041 defined $opts{other}
4042 6 ▶ or return $self->_set_error("No 'other' parameter supplied");
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"other"} or return $self->_set_error("No 'other' parameter supplied") 6 0 6
4043 6 ▶ unless ($opts{other}->_valid_image("difference")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"other"}->_valid_image("difference")) 1 5 6
4044 1 $self->_set_error($opts{other}->errstr . " (other image)");
4045 1 return;
4046 }
4047  
4048 5 my $result = Imager->new;
4049 $result->{IMG} = i_diff_image($self->{IMG}, $opts{other}{IMG},
4050 $opts{mindist})
4051 5 ▶ or return $self->_set_error($self->_error_as_msg());
Branch: 1 branch
BranchTrueFalseTotal
$result->{"IMG"} = &i_diff_image($self->{"IMG"}, $opts{"other"}{"IMG"}, $opts{"mindist"}) or return $self->_set_error($self->_error_as_msg) 5 0 5
4052  
4053 5 return $result;
4054 }
4055  
4056 1 ▶sub rgb_difference {
Subroutine rgb_difference: called CC=5 SCAR=18.1
Pod undocumented
4057 1 my ($self, %opts) = @_;
4058  
4059 1 ▶ $self->_valid_image("rgb_difference")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("rgb_difference") or return 1 0 1
4060 or return;
4061  
4062 defined $opts{other}
4063 1 ▶ or return $self->_set_error("No 'other' parameter supplied");
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{"other"} or return $self->_set_error("No 'other' parameter supplied") 1 0 1
4064 1 ▶ unless ($opts{other}->_valid_image("rgb_difference")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"other"}->_valid_image("rgb_difference")) 0 1 1
4065 0 $self->_set_error($opts{other}->errstr . " (other image)");
4066 0 return;
4067 }
4068  
4069 1 my $result = Imager->new;
4070 $result->{IMG} = i_rgbdiff_image($self->{IMG}, $opts{other}{IMG})
4071 1 ▶ or return $self->_set_error($self->_error_as_msg());
Branch: 1 branch
BranchTrueFalseTotal
$result->{"IMG"} = &i_rgbdiff_image($self->{"IMG"}, $opts{"other"}{"IMG"}) or return $self->_set_error($self->_error_as_msg) 1 0 1
4072  
4073 1 return $result;
4074 }
4075  
4076 # destructive border - image is shrunk by one pixel all around
4077  
4078 0 ▶sub border {
Subroutine border: not called CC=1 SCAR=6.9
Pod undocumented
4079 0 my ($self,%opts)=@_;
4080 0 my($tx,$ty)=($self->getwidth()-1,$self->getheight()-1);
4081 0 $self->polyline('x'=>[0,$tx,$tx,0,0],'y'=>[0,0,$ty,$ty,0],%opts);
4082 }
4083  
4084  
4085 # Get the width of an image
4086  
4087 2296 ▶sub getwidth {
Subroutine getwidth: called CC=2 SCAR=6.9
Pod undocumented
4088 2296 my $self = shift;
4089  
4090 2296 ▶ $self->_valid_image("getwidth")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getwidth") or return 2295 1 2296
4091 or return;
4092  
4093 2295 return i_img_get_width($self->{IMG});
4094 }
4095  
4096 # Get the height of an image
4097  
4098 1859 ▶sub getheight {
Subroutine getheight: called CC=2 SCAR=6.9
Pod undocumented
4099 1859 my $self = shift;
4100  
4101 1859 ▶ $self->_valid_image("getheight")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getheight") or return 1858 1 1859
4102 or return;
4103  
4104 1858 return i_img_get_height($self->{IMG});
4105 }
4106  
4107 # Get number of channels in an image
4108  
4109 719 ▶sub getchannels {
Subroutine getchannels: called CC=2 SCAR=6.9
Pod undocumented
4110 719 my $self = shift;
4111  
4112 719 ▶ $self->_valid_image("getchannels")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getchannels") or return 718 1 719
4113 or return;
4114  
4115 718 return i_img_getchannels($self->{IMG});
4116 }
4117  
4118 79 my @model_names = qw(unknown gray graya rgb rgba);
4119  
4120 7 ▶sub colormodel {
Subroutine colormodel: called CC=3 SCAR=11.0
Pod undocumented
4121 7 my ($self, %opts) = @_;
4122  
4123 7 ▶ $self->_valid_image("colormodel")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("colormodel") or return 6 1 7
4124 or return;
4125  
4126 6 my $model = i_img_color_model($self->{IMG});
4127  
4128 6 ▶ return $opts{numeric} ? $model : $model_names[$model];
Branch: 1 branch
BranchTrueFalseTotal
$opts{'numeric'} ? : 1 5 6
4129 }
4130  
4131 10 ▶sub colorchannels {
Subroutine colorchannels: called CC=2 SCAR=6.9
Pod undocumented
4132 10 my ($self) = @_;
4133  
4134 10 ▶ $self->_valid_image("colorchannels")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("colorchannels") or return 9 1 10
4135 or return;
4136  
4137 9 return i_img_color_channels($self->{IMG});
4138 }
4139  
4140 10 ▶sub alphachannel {
Subroutine alphachannel: called CC=2 SCAR=6.9
Pod undocumented
4141 10 my ($self) = @_;
4142  
4143 10 ▶ $self->_valid_image("alphachannel")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("alphachannel") or return 9 1 10
4144 or return;
4145  
4146 9 return scalar(i_img_alpha_channel($self->{IMG}));
4147 }
4148  
4149 # Get channel mask
4150  
4151 2 ▶sub getmask {
Subroutine getmask: called CC=2 SCAR=6.9
Pod undocumented
4152 2 my $self = shift;
4153  
4154 2 ▶ $self->_valid_image("getmask")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getmask") or return 1 1 2
4155 or return;
4156  
4157 1 return i_img_getmask($self->{IMG});
4158 }
4159  
4160 # Set channel mask
4161  
4162 28 ▶sub setmask {
Subroutine setmask: called CC=4 SCAR=14.6
Pod undocumented
4163 28 my $self = shift;
4164 28 my %opts = @_;
4165  
4166 28 ▶ warnings::warnif("Imager::channelmask", "setmask: image channel masks are deprecated")
Branch: 1 branch
BranchTrueFalseTotal
if $] >= "5.014" 28 0 28
4167 if $] >= 5.014;
4168  
4169 28 ▶ $self->_valid_image("setmask")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("setmask") or return 27 1 28
4170 or return;
4171  
4172 27 ▶ unless (defined $opts{mask}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $opts{"mask"}) 0 27 27
4173 0 $self->_set_error("mask parameter required");
4174 0 return;
4175 }
4176  
4177 27 i_img_setmask( $self->{IMG} , $opts{mask} );
4178  
4179 27 1;
4180 }
4181  
4182 # Get number of colors in an image
4183  
4184 10 ▶sub getcolorcount {
Subroutine getcolorcount: called CC=3 SCAR=11.0
Pod undocumented
4185 10 my $self=shift;
4186 10 my %opts=('maxcolors'=>2**30,@_);
4187  
4188 10 ▶ $self->_valid_image("getcolorcount")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getcolorcount") or return 9 1 10
4189 or return;
4190  
4191 9 my $rc=i_count_colors($self->{IMG},$opts{'maxcolors'});
4192 9 ▶ return ($rc==-1? undef : $rc);
Branch: 1 branch
BranchTrueFalseTotal
$rc == -1 ? : 1 8 9
4193 }
4194  
4195 # Returns a reference to a hash. The keys are colour named (packed) and the
4196 # values are the number of pixels in this colour.
4197 4 ▶sub getcolorusagehash {
Subroutine getcolorusagehash: called CC=9 SCAR=23.2
Pod undocumented
4198 4 my $self = shift;
4199  
4200 4 ▶ $self->_valid_image("getcolorusagehash")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getcolorusagehash") or return 3 1 4
4201 or return;
4202  
4203 3 my %opts = ( maxcolors => 2**30, @_ );
4204 3 my $max_colors = $opts{maxcolors};
4205 3 ▶ unless (defined $max_colors && $max_colors > 0) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $max_colors and $max_colors > 0) 0 3 3
Condition33%1/3
defined $max_colors and $max_colors > 0
!ll&&!rl&&r
003
MC/DC0%0/2
defined $max_colors and $max_colors > 0
defined $max_colors $max_colors > 0
Truth table33%1/3
A and B
A= defined $max_colorsB= $max_colors > 0
ABresult
0X0
100
111
4206 0 $self->_set_error('maxcolors must be a positive integer');
4207 0 return;
4208 }
4209  
4210 3 my $channels= $self->getchannels;
4211 # We don't want to look at the alpha channel, because some gifs using it
4212 # doesn't define it for every colour (but only for some)
4213 3 ▶ $channels -= 1 if $channels == 2 or $channels == 4;
Branch: 1 branch
BranchTrueFalseTotal
if $channels == 2 or $channels == 4 0 3 3
Condition33%1/3
$channels == 2 or $channels == 4
l!l&&r!l&&!r
003
MC/DC0%0/2
$channels == 2 or $channels == 4
$channels == 2 $channels == 4
Truth table33%1/3
A or B
A= $channels == 2B= $channels == 4
ABresult
1X1
011
000
4214 3 my %color_use;
4215 3 my $height = $self->getheight;
4216 3 for my $y (0 .. $height - 1) {
4217 126 my $colors = $self->getsamples('y' => $y, channels => [ 0 .. $channels - 1 ]);
4218 126 ▶ while (length $colors) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $colors) 6300 126 6426
4219 6300 $color_use{ substr($colors, 0, $channels, '') }++;
4220 }
4221 126 ▶ keys %color_use > $max_colors
Branch: 1 branch
BranchTrueFalseTotal
keys %color_use > $max_colors and return 1 125 126
4222 and return;
4223 }
4224 2 return \%color_use;
4225 }
4226  
4227 # This will return a ordered array of the colour usage. Kind of the sorted
4228 # version of the values of the hash returned by getcolorusagehash.
4229 # You might want to add safety checks and change the names, etc...
4230 6 ▶sub getcolorusage {
Subroutine getcolorusage: called CC=4 SCAR=15.2
Pod undocumented
4231 6 my $self = shift;
4232  
4233 6 ▶ $self->_valid_image("getcolorusage")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("getcolorusage") or return 5 1 6
4234 or return;
4235  
4236 5 my %opts = ( maxcolors => 2**30, @_ );
4237 5 my $max_colors = $opts{maxcolors};
4238 5 ▶ unless (defined $max_colors && $max_colors > 0) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $max_colors and $max_colors > 0) 0 5 5
Condition33%1/3
defined $max_colors and $max_colors > 0
!ll&&!rl&&r
005
MC/DC0%0/2
defined $max_colors and $max_colors > 0
defined $max_colors $max_colors > 0
Truth table33%1/3
A and B
A= defined $max_colorsB= $max_colors > 0
ABresult
0X0
100
111
4239 0 $self->_set_error('maxcolors must be a positive integer');
4240 0 return;
4241 }
4242  
4243 5 return i_get_anonymous_color_histo($self->{IMG}, $max_colors);
4244 }
4245  
4246 # draw string to an image
4247  
4248 1 ▶sub string {
Subroutine string: called CC=6 SCAR=33.9
Pod undocumented
4249 1 my $self = shift;
4250  
4251 1 ▶ $self->_valid_image("string")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("string") or return 0 1 1
4252 or return;
4253  
4254 0 my %input=('x'=>0, 'y'=>0, @_);
4255 0 ▶ defined($input{string}) or $input{string} = $input{text};
Branch: 1 branch
BranchTrueFalseTotal
defined $input{"string"} or $input{"string"} = $input{"text"} 0 0 0
4256  
4257 0 ▶ unless(defined $input{string}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $input{"string"}) 0 0 0
4258 0 $self->{ERRSTR}="missing required parameter 'string'";
4259 0 return;
4260 }
4261  
4262 0 ▶ unless($input{font}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($input{"font"}) 0 0 0
4263 0 $self->{ERRSTR}="missing required parameter 'font'";
4264 0 return;
4265 }
4266  
4267 0 ▶ unless ($input{font}->draw(image=>$self, %input)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($input{"font"}->draw("image", $self, %input)) 0 0 0
4268 0 return;
4269 }
4270  
4271 0 return $self;
4272 }
4273  
4274 1 ▶sub align_string {
Subroutine align_string: called CC=8 SCAR=37.5
Pod undocumented
4275 1 my $self = shift;
4276  
4277 1 my $img;
4278 1 ▶ if (ref $self) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) { } 1 0 1
4279 1 ▶ $self->_valid_image("align_string")
Branch: 1 branch
BranchTrueFalseTotal
$self->_valid_image("align_string") or return 0 1 1
4280 or return;
4281  
4282 0 $img = $self;
4283 }
4284 else {
4285 0 $img = undef;
4286 }
4287  
4288 0 my %input=('x'=>0, 'y'=>0, @_);
4289 defined $input{string}
4290 0 ▶ or $input{string} = $input{text};
Branch: 1 branch
BranchTrueFalseTotal
defined $input{"string"} or $input{"string"} = $input{"text"} 0 0 0
4291  
4292 0 ▶ unless(exists $input{string}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $input{"string"}) 0 0 0
4293 0 $self->_set_error("missing required parameter 'string'");
4294 0 return;
4295 }
4296  
4297 0 ▶ unless($input{font}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($input{"font"}) 0 0 0
4298 0 $self->_set_error("missing required parameter 'font'");
4299 0 return;
4300 }
4301  
4302 0 my @result;
4303 0 ▶ unless (@result = $input{font}->align(image=>$img, %input)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@result = $input{"font"}->align("image", $img, %input)) 0 0 0
4304 0 return;
4305 }
4306  
4307 0 ▶ return wantarray ? @result : $result[0];
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 0 0 0
4308 }
4309  
4310 79 my @file_limit_names = qw/width height bytes/;
4311  
4312 41 ▶sub set_file_limits {
Subroutine set_file_limits: called CC=4 SCAR=13.9
Pod undocumented
4313 41 shift;
4314  
4315 41 my %opts = @_;
4316 41 my %values;
4317
4318 41 ▶ if ($opts{reset}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{'reset'}) { } 39 2 41
4319 39 @values{@file_limit_names} = (0) x @file_limit_names;
4320 }
4321 else {
4322 2 @values{@file_limit_names} = i_get_image_file_limits();
4323 }
4324  
4325 41 for my $key (keys %values) {
4326 123 ▶ defined $opts{$key} and $values{$key} = $opts{$key};
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{$key} and $values{$key} = $opts{$key} 34 89 123
4327 }
4328  
4329 41 i_set_image_file_limits($values{width}, $values{height}, $values{bytes});
4330 }
4331  
4332 5 ▶sub get_file_limits {
Subroutine get_file_limits: called CC=1 SCAR=0.0
Pod undocumented
4333 5 i_get_image_file_limits();
4334 }
4335  
4336 79 my @check_args = qw(width height channels sample_size);
4337  
4338 11 ▶sub check_file_limits {
Subroutine check_file_limits: called CC=7 SCAR=19.5
Pod undocumented
4339 11 my $class = shift;
4340  
4341 11 my %opts =
4342 (
4343 channels => 3,
4344 sample_size => 1,
4345 @_,
4346 );
4347  
4348 11 ▶ if ($opts{sample_size} && $opts{sample_size} eq 'float') {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"sample_size"} and $opts{"sample_size"} eq "float") 1 10 11
Condition100%3/3
$opts{"sample_size"} and $opts{"sample_size"} eq "float"
!ll&&!rl&&r
191
MC/DC100%2/2
$opts{"sample_size"} and $opts{"sample_size"} eq "float"
$opts{"sample_size"} $opts{"sample_size"} eq "float"
Truth table100%3/3
A and B
A= $opts{"sample_size"}B= $opts{"sample_size"} eq "float"
ABresult
0X0
100
111
4349 1 $opts{sample_size} = length(pack("d", 0));
4350 }
4351  
4352 11 for my $name (@check_args) {
4353 38 ▶ unless (defined $opts{$name}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $opts{$name}) 1 37 38
4354 1 $class->_set_error("check_file_limits: $name must be defined");
4355 1 return;
4356 }
4357 37 ▶ unless ($opts{$name} == int($opts{$name})) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{$name} == int $opts{$name}) 1 36 37
4358 1 $class->_set_error("check_file_limits: $name must be a positive integer");
4359 1 return;
4360 }
4361 }
4362  
4363 9 my $result = i_int_check_image_file_limits(@opts{@check_args});
4364 9 ▶ unless ($result) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result) 6 3 9
4365 6 $class->_set_error($class->_error_as_msg());
4366 }
4367  
4368 9 return $result;
4369 }
4370  
4371 0 ▶sub set_out_of_memory_handler {
Subroutine set_out_of_memory_handler: not called CC=2 SCAR=17.9
Pod documented
4372 0 my $class = shift;
4373  
4374 0 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 0 0 0
4375 0 my $handler = shift;
4376 0 $_out_of_memory = $handler;
4377 0 i_set_out_of_memory(defined $handler);
4378 }
4379 0 $_out_of_memory;
4380 }
4381  
4382 # Shortcuts that can be exported
4383  
4384 283 ▶sub newcolor { Imager::Color->new(@_); }
Subroutine newcolor: called CC=1 SCAR=0.0
Pod undocumented
4385 0 ▶sub newfont { Imager::Font->new(@_); }
Subroutine newfont: not called CC=1 SCAR=6.9
Pod undocumented
4386 33 ▶sub NCF {
Subroutine NCF: called CC=1 SCAR=0.0
Pod undocumented
4387 33 require Imager::Color::Float;
4388 33 return Imager::Color::Float->new(@_);
4389 }
4390  
4391 79 *NC=*newcolour=*newcolor;
4392 79 *NF=*newfont;
4393  
4394 79 *open=\&read;
4395 79 *circle=\&arc;
4396  
4397  
4398 #### Utility routines
4399  
4400 594 ▶sub errstr {
Subroutine errstr: called CC=2 SCAR=6.9
Pod documented
4401 594 ▶ ref $_[0] ? $_[0]->{ERRSTR} : $ERRSTR
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 515 79 594
4402 }
4403  
4404 331 ▶sub _set_error {
Subroutine _set_error: called CC=2 SCAR=6.9
4405 331 my ($self, $msg) = @_;
4406  
4407 331 ▶ if (ref $self) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) { } 287 44 331
4408 287 $self->{ERRSTR} = $msg;
4409 }
4410 else {
4411 44 $ERRSTR = $msg;
4412 }
4413 331 return;
4414 }
4415  
4416 # Default guess for the type of an image from extension
4417  
4418 79 my @simple_types = qw(png tga gif raw ico cur xpm mng jng ilbm pcx psd eps webp xwd xpm dng ras qoi jxl);
4419  
4420 my %ext_types =
4421 (
4422 79 ( map { $_ => $_ } @simple_types ),
4423 tiff => "tiff",
4424 tif => "tiff",
4425 pbm => "pnm",
4426 pgm => "pnm",
4427 ppm => "pnm",
4428 pnm => "pnm", # technically wrong, but historically it works in Imager
4429 jpeg => "jpeg",
4430 jpg => "jpeg",
4431 bmp => "bmp",
4432 dib => "bmp",
4433 rgb => "sgi",
4434 bw => "sgi",
4435 sgi => "sgi",
4436 fit => "fits",
4437 fits => "fits",
4438 rle => "utah",
4439 avifs => "avif", # AVIF image sequence
4440 avif => "avif",
4441 );
4442  
4443 130 ▶sub def_guess_type {
Subroutine def_guess_type: called CC=5 SCAR=16.7
Pod undocumented
4444 130 my $name=lc(shift);
4445  
4446 130 ▶ my ($ext) = $name =~ /\.([^.]+)$/
Branch: 1 branch
BranchTrueFalseTotal
my($ext) = $name =~ /\.([^.]+)$/ or return 130 0 130
4447 or return;
4448  
4449 130 my $type = $ext_types{$ext};
4450 130 ▶ unless ($type) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($type) 2 128 130
4451 2 $type = $ext_types{lc $ext};
4452 }
4453  
4454 130 ▶ if (!defined $type && $ext =~ /\A[a-zA-Z0-9_]{2,}\z/) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $type and $ext =~ /\A[a-zA-Z0-9_]{2,}\z/) 0 130 130
Condition66%2/3
not defined $type and $ext =~ /\A[a-zA-Z0-9_]{2,}\z/
!ll&&!rl&&r
12820
MC/DC0%0/2
not defined $type and $ext =~ /\A[a-zA-Z0-9_]{2,}\z/
not defined $type $ext =~ /\A[a-zA-Z0-9_]{2,}\z/
Truth table66%2/3
not(A) and B
A= not defined $typeB= $ext =~ /\A[a-zA-Z0-9_]{2,}\z/
ABresult
0X0
100
111
4455 # maybe a reasonable assumption
4456 0 $type = lc $ext;
4457 }
4458  
4459 130 return $type;
4460 }
4461  
4462 1 ▶sub add_type_extensions {
Subroutine add_type_extensions: called CC=3 SCAR=11.1
Pod undocumented
4463 1 my ($class, $type, @exts) = @_;
4464  
4465 1 for my $ext (@exts) {
4466 1 ▶ exists $ext_types{lc $ext} or $ext_types{lc $ext} = lc $type;
Branch: 1 branch
BranchTrueFalseTotal
exists $ext_types{lc $ext} or $ext_types{lc $ext} = lc $type 0 1 1
4467 }
4468 1 1;
4469 }
4470  
4471 1 ▶sub combines {
Subroutine combines: called CC=1 SCAR=0.0
Pod undocumented
4472 1 return @combine_types;
4473 }
4474  
4475 # get the minimum of a list
4476  
4477 1470 ▶sub _min {
Subroutine _min: called CC=3 SCAR=11.7
4478 1470 my $mx=shift;
4479 0 ▶ for(@_) { if ($_<$mx) { $mx=$_; }}
Branch: 1 branch
BranchTrueFalseTotal
if ($_ < $mx) 0 1470 1470
4480 1470 return $mx;
4481 }
4482  
4483 # get the maximum of a list
4484  
4485 1203 ▶sub _max {
Subroutine _max: called CC=3 SCAR=11.0
4486 1203 my $mx=shift;
4487 1203 ▶ for(@_) { if ($_>$mx) { $mx=$_; }}
Branch: 1 branch
BranchTrueFalseTotal
if ($_ > $mx) 1184 19 1203
4488 1203 return $mx;
4489 }
4490  
4491 # string stuff for iptc headers
4492  
4493 0 ▶sub _clean {
Subroutine _clean: not called CC=1 SCAR=6.9
4494 0 my($str)=$_[0];
4495 0 $str = substr($str,3);
4496 0 $str =~ s/[\n\r]//g;
4497 0 $str =~ s/\s+/ /g;
4498 0 $str =~ s/^\s//;
4499 0 $str =~ s/\s$//;
4500 0 return $str;
4501 }
4502  
4503 # A little hack to parse iptc headers.
4504  
4505 0 ▶sub parseiptc {
Subroutine parseiptc: not called CC=9 SCAR=45.0
Pod undocumented
4506 0 my $self=shift;
4507 0 my(@sar,$item,@ar);
4508 0 my($caption,$photogr,$headln,$credit);
4509  
4510 0 my $str=$self->{IPTCRAW};
4511  
4512 0 ▶ defined $str
Branch: 1 branch
BranchTrueFalseTotal
defined $str or return 0 0 0
4513 or return;
4514  
4515 0 @ar=split(/8BIM/,$str);
4516  
4517 0 my $i=0;
4518 0 foreach (@ar) {
4519 0 ▶ if (/^\004\004/) {
Branch: 1 branch
BranchTrueFalseTotal
if (/^\004\004/) 0 0 0
4520 0 @sar=split(/\034\002/);
4521 0 foreach $item (@sar) {
4522 0 ▶ if ($item =~ m/^x/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item =~ /^x/) 0 0 0
4523 0 $caption = _clean($item);
4524 0 $i++;
4525 }
4526 0 ▶ if ($item =~ m/^P/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item =~ /^P/) 0 0 0
4527 0 $photogr = _clean($item);
4528 0 $i++;
4529 }
4530 0 ▶ if ($item =~ m/^i/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item =~ /^i/) 0 0 0
4531 0 $headln = _clean($item);
4532 0 $i++;
4533 }
4534 0 ▶ if ($item =~ m/^n/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item =~ /^n/) 0 0 0
4535 0 $credit = _clean($item);
4536 0 $i++;
4537 }
4538 }
4539 }
4540 }
4541 0 return (caption=>$caption,photogr=>$photogr,headln=>$headln,credit=>$credit);
4542 }
4543  
4544 0 ▶sub Inline {
Subroutine Inline: not called CC=3 SCAR=24.8
Pod undocumented
4545 # Inline added a new argument at the beginning
4546 0 my $lang = $_[-1];
4547  
4548 0 ▶ $lang eq 'C' || $lang eq 'CPP'
Branch: 1 branch
BranchTrueFalseTotal
$lang eq "C" or $lang eq "CPP" or die "Only C or C++ (CPP) language supported" 0 0 0
Condition0%0/3
$lang eq "C" or $lang eq "CPP"
l!l&&r!l&&!r
000
MC/DC0%0/2
$lang eq "C" or $lang eq "CPP"
$lang eq "C" $lang eq "CPP"
Truth table0%0/3
A or B
A= $lang eq "C"B= $lang eq "CPP"
ABresult
1X1
011
000
4549 or die "Only C or C++ (CPP) language supported";
4550  
4551 0 require Imager::ExtUtils;
4552 0 return Imager::ExtUtils->inline_config;
4553 }
4554  
4555 # threads shouldn't try to close raw Imager objects
4556 0 ▶sub Imager::ImgRaw::CLONE_SKIP { 1 }
Subroutine CLONE_SKIP: not called CC=1 SCAR=6.9
4557  
4558 1 ▶sub preload {
Subroutine preload: called CC=2 SCAR=6.9
Pod undocumented
4559 # this serves two purposes:
4560 # - a class method to load the file support modules included with Imager
4561 # (or were included, once the library dependent modules are split out)
4562 # - something for Module::ScanDeps to analyze
4563 # https://rt.cpan.org/Ticket/Display.html?id=6566
4564 1 local $@;
4565 1 local @INC = @INC;
4566 1 ▶ pop @INC if $INC[-1] eq '.';
Branch: 1 branch
BranchTrueFalseTotal
if $INC[-1] eq "." 1 0 1
4567 1 eval { require Imager::File::GIF };
4568 1 eval { require Imager::File::JPEG };
4569 1 eval { require Imager::File::PNG };
4570 1 eval { require Imager::File::SGI };
4571 1 eval { require Imager::File::TIFF };
4572 1 eval { require Imager::File::ICO };
4573 1 eval { require Imager::Font::W32 };
4574 1 eval { require Imager::Font::FT2 };
4575 1 eval { require Imager::Font::T1 };
4576 1 eval { require Imager::Color::Table };
4577  
4578 1 1;
4579 }
4580  
4581 package Imager::IO;
4582 79 ▶use IO::Seekable;
Subroutine BEGIN: called CC=1 SCAR=0.0
4583  
4584 19 ▶sub new_fh {
Subroutine new_fh: called CC=2 SCAR=7.1
4585 19 my ($class, $fh) = @_;
4586  
4587 19 ▶ if (tied(*$fh)) {
Branch: 1 branch
BranchTrueFalseTotal
if (tied *$fh) { } 1 18 19
4588 return $class->new_cb
4589 (
4590 2 ▶ sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
4591 2 local $\;
4592  
4593 2 return print $fh $_[0];
4594 },
4595 2 ▶ sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
4596 2 my $tmp;
4597 2 my $count = CORE::read $fh, $tmp, $_[1];
4598 2 ▶ defined $count
Branch: 1 branch
BranchTrueFalseTotal
defined $count or return undef 2 0 2
4599 or return undef;
4600 2 ▶ $count
Branch: 1 branch
BranchTrueFalseTotal
$count or return "" 1 1 2
4601 or return "";
4602 1 return $tmp;
4603 },
4604 2 ▶ sub {
Subroutine __ANON__: called CC=4 SCAR=17.1
4605 2 ▶ if ($_[1] != SEEK_CUR || $_[0] != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($_[1] != 1 or $_[0] != 0) 2 0 2
Condition33%1/3
$_[1] != 1 or $_[0] != 0
l!l&&r!l&&!r
200
MC/DC0%0/2
$_[1] != 1 or $_[0] != 0
$_[1] != 1 $_[0] != 0
Truth table33%1/3
A or B
A= $_[1] != 1B= $_[0] != 0
ABresult
1X1
011
000
4606 2 ▶ unless (CORE::seek $fh, $_[0], $_[1]) {
Branch: 1 branch
BranchTrueFalseTotal
unless (CORE::seek $fh, $_[0], $_[1]) 0 2 2
4607 0 return -1;
4608 }
4609 }
4610  
4611 2 return tell $fh;
4612 },
4613 undef,
4614 1 );
4615 }
4616 else {
4617 18 return $class->_new_perlio($fh);
4618 }
4619 }
4620  
4621 # backward compatibility for %formats
4622 package Imager::FORMATS;
4623 79 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4624 79 ▶use constant IX_FORMATS => 0;
Subroutine BEGIN: called CC=1 SCAR=0.0
4625 79 ▶use constant IX_LIST => 1;
Subroutine BEGIN: called CC=1 SCAR=0.0
4626 79 ▶use constant IX_INDEX => 2;
Subroutine BEGIN: called CC=1 SCAR=0.0
4627 79 ▶use constant IX_CLASSES => 3;
Subroutine BEGIN: called CC=1 SCAR=0.0
4628  
4629 79 ▶sub TIEHASH {
Subroutine TIEHASH: called CC=1 SCAR=0.0
4630 79 my ($class, $formats, $classes) = @_;
4631  
4632 79 return bless [ $formats, [ ], 0, $classes ], $class;
4633 }
4634  
4635 50 ▶sub _check {
Subroutine _check: called CC=3 SCAR=11.2
4636 50 my ($self, $key) = @_;
4637  
4638 50 (my $file = $self->[IX_CLASSES]{$key} . ".pm") =~ s(::)(/)g;
4639 50 my $value;
4640 my $error;
4641 50 my $loaded = Imager::_load_file($file, \$error);
4642 50 ▶ if ($loaded) {
Branch: 1 branch
BranchTrueFalseTotal
if ($loaded) { } 0 50 50
4643 0 $value = 1;
4644 }
4645 else {
4646 50 ▶ if ($error =~ /^Can't locate /) {
Branch: 1 branch
BranchTrueFalseTotal
if ($error =~ /^Can't locate /) 50 0 50
4647 50 $error = "Can't locate $file";
4648 }
4649 50 $reader_load_errors{$key} = $writer_load_errors{$key} = $error;
4650 50 $value = undef;
4651 }
4652 50 $self->[IX_FORMATS]{$key} = $value;
4653  
4654 50 return $value;
4655 }
4656  
4657 11 ▶sub FETCH {
Subroutine FETCH: called CC=3 SCAR=11.0
4658 11 my ($self, $key) = @_;
4659  
4660 11 ▶ exists $self->[IX_FORMATS]{$key} and return $self->[IX_FORMATS]{$key};
Branch: 1 branch
BranchTrueFalseTotal
exists $self->[0]{$key} and return $self->[0]{$key} 6 5 11
4661  
4662 5 ▶ $self->[IX_CLASSES]{$key} or return undef;
Branch: 1 branch
BranchTrueFalseTotal
$self->[3]{$key} or return undef 1 4 5
4663  
4664 1 return $self->_check($key);
4665 }
4666  
4667 0 ▶sub STORE {
Subroutine STORE: not called CC=1 SCAR=6.9
4668 0 die "%Imager::formats is not user monifiable";
4669 }
4670  
4671 0 ▶sub DELETE {
Subroutine DELETE: not called CC=1 SCAR=6.9
4672 0 die "%Imager::formats is not user monifiable";
4673 }
4674  
4675 0 ▶sub CLEAR {
Subroutine CLEAR: not called CC=1 SCAR=6.9
4676 0 die "%Imager::formats is not user monifiable";
4677 }
4678  
4679 0 ▶sub EXISTS {
Subroutine EXISTS: not called CC=4 SCAR=30.0
4680 0 my ($self, $key) = @_;
4681  
4682 0 ▶ if (exists $self->[IX_FORMATS]{$key}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $self->[0]{$key}) 0 0 0
4683 0 ▶ my $value = $self->[IX_FORMATS]{$key}
Branch: 1 branch
BranchTrueFalseTotal
my $value = $self->[0]{$key} or return 0 0 0
4684 or return;
4685 0 return 1;
4686 }
4687  
4688 0 ▶ $self->_check($key) or return 1==0;
Branch: 1 branch
BranchTrueFalseTotal
$self->_check($key) or 0 0 0
4689  
4690 0 return 1==1;
4691 }
4692  
4693 17 ▶sub FIRSTKEY {
Subroutine FIRSTKEY: called CC=6 SCAR=18.2
4694 17 my ($self) = @_;
4695  
4696 17 ▶ unless (@{$self->[IX_LIST]}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@{$self->[1];}) 7 10 17
4697 # full populate it
4698 7 @{$self->[IX_LIST]} = grep $self->[IX_FORMATS]{$_},
4699 7 keys %{$self->[IX_FORMATS]};
4700  
4701 7 for my $key (keys %{$self->[IX_CLASSES]}) {
4702 49 ▶ $self->[IX_FORMATS]{$key} and next;
Branch: 1 branch
BranchTrueFalseTotal
$self->[0]{$key} and next 0 49 49
4703 $self->_check($key)
4704 0 ▶ and push @{$self->[IX_LIST]}, $key;
Branch: 1 branch
BranchTrueFalseTotal
$self->_check($key) and push @{$$self[1];}, $key 0 49 49
4705 }
4706 }
4707  
4708 17 ▶ @{$self->[IX_LIST]} or return;
Branch: 1 branch
BranchTrueFalseTotal
@{$self->[1];} or return 17 0 17
4709 17 $self->[IX_INDEX] = 1;
4710 17 return $self->[IX_LIST][0];
4711 }
4712  
4713 85 ▶sub NEXTKEY {
Subroutine NEXTKEY: called CC=2 SCAR=6.9
4714 85 my ($self) = @_;
4715  
4716 85 ▶ $self->[IX_INDEX] < @{$self->[IX_LIST]}
Branch: 1 branch
BranchTrueFalseTotal
$self->[2] < @{$self->[1];} or return 68 17 85
4717 or return;
4718  
4719 68 return $self->[IX_LIST][$self->[IX_INDEX]++];
4720 }
4721  
4722 0 ▶sub SCALAR {
Subroutine SCALAR: not called CC=1 SCAR=6.9
4723 0 my ($self) = @_;
4724  
4725 0 return scalar @{$self->[IX_LIST]};
4726 }
4727  
4728 79 1;
4729 __END__
« blib/lib/Imager/Color.pm ↑ Summary blib/lib/Imager/Test.pm »