blib/lib/PDL/IO/Pic.pm

filter: Statementstmt 65.1% 183 / 281 Branchbran 41.2% 90 / 218 Conditioncond 38.7% 45 / 116 MC/DCmcdc 14.0% 9 / 64 Subroutinesub 77.7% 28 / 36 Podpod 25.0% 5 / 20 totaltotal 48.9% 360 / 735 CC 152 SCAR 40.1
CC
152
Cov
52%
chkext
148.8
chkform
136.4
wmpeg
110.0
CRAP 54.9
« blib/lib/Test/PDL.pm ↑ Summary blib/lib/PDL/Dbg.pm »
1 =head1 NAME
2  
3 PDL::IO::Pic -- image I/O for PDL
4  
5 =head1 DESCRIPTION
6  
7 This package implements I/O for a number of popular image formats
8 by exploiting the xxxtopnm and pnmtoxxx converters from the netpbm package
9 (which is based on the original pbmplus by Jef Poskanzer).
10  
11 Netpbm is available at
12 ftp://wuarchive.wustl.edu/graphics/graphics/packages/NetPBM/
13 Pbmplus (on which netpbm is based) might work as well, I haven't tried it.
14 If you want to read/write JPEG images you additionally need the two
15 converters cjpeg/djpeg which come with the libjpeg distribution (the
16 "official" archive site for this software is L<ftp://ftp.uu.net/graphics/jpeg>).
17  
18 Image I/O for all formats is established by reading and writing only
19 the PNM format directly while the netpbm standalone apps take care of
20 the necessary conversions. In accordance with netpbm parlance PNM stands
21 here for 'portable any map' meaning any of the PBM/PGM/PPM formats.
22  
23 As it appeared to be a reasonable place this package also contains the
24 routine wmpeg to write mpeg movies from PDLs representing image
25 stacks (the image stack is first written as a sequence of PPM images into some
26 temporary directory). For this to work you need the program ffmpeg also.
27  
28 =cut
29  
30 package PDL::IO::Pic;
31  
32 14 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
33 14 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
34  
35 14 our @EXPORT_OK = ('imageformat', map +("r$_", "w$_"), qw(mpeg im pic piccan));
36 14 our %EXPORT_TAGS = (Func => \@EXPORT_OK);
37 14 our ($Dflags, %converter);
38 14 our @ISA = qw( PDL::Exporter );
39  
40 14 ▶use PDL::Core;
Subroutine BEGIN: called CC=1 SCAR=0.0
41 14 ▶use PDL::Exporter;
Subroutine BEGIN: called CC=1 SCAR=0.0
42 14 ▶use PDL::Types;
Subroutine BEGIN: called CC=1 SCAR=0.0
43 14 ▶use PDL::ImageRGB;
Subroutine BEGIN: called CC=1 SCAR=0.0
44 14 ▶use PDL::IO::Pnm;
Subroutine BEGIN: called CC=1 SCAR=0.0
45 14 ▶use PDL::Options;
Subroutine BEGIN: called CC=1 SCAR=0.0
46 14 ▶use File::Basename;
Subroutine BEGIN: called CC=1 SCAR=0.0
47 14 ▶use File::Spec;
Subroutine BEGIN: called CC=1 SCAR=0.0
48 14 ▶use Text::ParseWords qw(shellwords);
Subroutine BEGIN: called CC=1 SCAR=0.0
49 14 ▶use File::Which ();
Subroutine BEGIN: called CC=1 SCAR=0.0
50  
51 =head2 Configuration
52  
53 The executables from the netpbm package are assumed to be in your path.
54 Problems in finding the executables may show up as PNM format
55 errors when calling wpic/rpic. If you run into this kind of problem run
56 your program with perl C<-w> so that perl prints a message if it can't find
57 the filter when trying to open the pipe. [']
58  
59 =cut
60  
61  
62 # list of converters by type
63 # might get more fields in the future to provide a generic representation
64 # of common flags like COMPRESSION, LUT, etc which would hold the correct
65 # flags for the particular converter or NA if not supported
66 # conventions:
67 # NONE we need no converter (directly supported format)
68 # NA feature not available
69 # 'whatevertopnm' name of the executable
70 # The 'FLAGS' key must be used if the converter needs other flags than
71 # the default flags ($Dflags)
72 #
73 #
74 # The "referral" field, if present, contains a within-perl referral
75 # to other methods for reading/writing the PDL as that type of file. The
76 # methods must have the same syntax as wpic/rpic (e.g. wfits/rfits).
77 #
78  
79 14 ▶$PDL::IO::Pic::debug = $PDL::IO::Pic::debug || 0;
Condition50%1/2
$PDL::IO::Pic::debug || 0
l!l
014
MC/DC0%0/1
$PDL::IO::Pic::debug || 0
$PDL::IO::Pic::debug
Truth table50%1/2
A
A= $PDL::IO::Pic::debug
Aresult
11
00
80 14 init_converter_table();
81  
82 # setup functions
83  
84 14 ▶sub init_converter_table {
Subroutine init_converter_table: called CC=17 SCAR=38.7
Pod undocumented
85 # default flag to be used with any converter unless overridden with FLAGS
86 14 $Dflags = '';
87 14 %converter = ();
88  
89 0 ▶ if (eval {require PDL::IO::GD; PDL::IO::GD->can ('to_rpic') && PDL::IO::GD->can ('write_Jpeg')}) {
Branch: 1 branch
BranchTrueFalseTotal
if (eval { do { require PDL::IO::GD; "PDL::IO::GD"->can("to_rpic") and "PDL::IO::GD"->can("write_Jpeg") } }) 0 14 14
Condition0%0/3
'PDL::IO::GD'->can('to_rpic') && 'PDL::IO::GD'->can('write_Jpeg')
!ll&&!rl&&r
000
MC/DC0%0/2
'PDL::IO::GD'->can('to_rpic') && 'PDL::IO::GD'->can('write_Jpeg')
'PDL::IO::GD'->can('to_rpic') 'PDL::IO::GD'->can('write_Jpeg')
Truth table0%0/3
A && B
A= 'PDL::IO::GD'->can('to_rpic')B= 'PDL::IO::GD'->can('write_Jpeg')
ABresult
0X0
100
111
90 $converter{JPEG} = {referral => {
91 0 ▶ put => sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
92 0 my $pdl = $_[0];
93 0 ▶ $pdl = $pdl->mv(0,-1) if $pdl->ndims > 2 && $pdl->dim(0) == 3;
Branch: 1 branch
BranchTrueFalseTotal
if $pdl->ndims > 2 and $pdl->dim(0) == 3 0 0 0
Condition0%0/3
$pdl->ndims > 2 and $pdl->dim(0) == 3
!ll&&!rl&&r
000
MC/DC0%0/2
$pdl->ndims > 2 and $pdl->dim(0) == 3
$pdl->ndims > 2 $pdl->dim(0) == 3
Truth table0%0/3
A and B
A= $pdl->ndims > 2B= $pdl->dim(0) == 3
ABresult
0X0
100
111
94 0 PDL::IO::GD->new(pdl=>$pdl->slice(',-1:0'))->write_Jpeg($_[1], -1);
95 },
96 0 ▶ get => sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
97 0 my $pdl = PDL::IO::GD->new($_[1])->to_rpic;
98 0 ▶ $pdl->diff2->zcheck ? $pdl->slice('(0)')->sever : $pdl; # greyscale
Branch: 1 branch
BranchTrueFalseTotal
$pdl->diff2->zcheck ? : 0 0 0
99 },
100 0 }};
101 }
102  
103 # Pbmplus systems have cjpeg/djpeg; netpbm systems have pnmtojpeg and
104 # jpegtopnm.
105 $converter{$_} = {put => "pnmto\L$_", get => "\L${_}topnm"}
106 14 ▶ for qw/TIFF SGI RAST PCX/, !$converter{PNG} ? 'PNG' : (),
Branch: 2 branches
BranchTrueFalseTotal
!$PDL::IO::Pic::converter{'PNG'} ? : 14 0 14
!$PDL::IO::Pic::converter{'JPEG'} && File::Which::which('pnmtojpeg') ? : 0 14 14
Condition33%1/3
not $PDL::IO::Pic::converter{"JPEG"} and File::Which::which("pnmtojpeg")
!ll&&!rl&&r
0140
MC/DC0%0/2
not $PDL::IO::Pic::converter{"JPEG"} and File::Which::which("pnmtojpeg")
not $PDL::IO::Pic::converter{"JPEG"} File::Which::which("pnmtojpeg")
Truth table33%1/3
not(A) and B
A= not $PDL::IO::Pic::converter{"JPEG"}B= File::Which::which("pnmtojpeg")
ABresult
0X0
100
111
107 !$converter{JPEG} && File::Which::which('pnmtojpeg') ? "JPEG" : ();
108  
109 14 ▶ $converter{$_->[0]} = {put => $_->[1], get => $_->[2]} for
Branch: 1 branch
BranchTrueFalseTotal
!$PDL::IO::Pic::converter{'JPEG'} && File::Which::which('cjpeg') ? : 0 14 14
Condition33%1/3
not $PDL::IO::Pic::converter{"JPEG"} and File::Which::which("cjpeg")
!ll&&!rl&&r
0140
MC/DC0%0/2
not $PDL::IO::Pic::converter{"JPEG"} and File::Which::which("cjpeg")
not $PDL::IO::Pic::converter{"JPEG"} File::Which::which("cjpeg")
Truth table33%1/3
not(A) and B
A= not $PDL::IO::Pic::converter{"JPEG"}B= File::Which::which("cjpeg")
ABresult
0X0
100
111
110 ['PNM','NONE','NONE'],
111 ['PS','pnmtops -dpi=100',
112 'pstopnm -stdout -xborder=0 -yborder=0 -quiet -dpi=100'],
113 ['GIF','ppmtogif','giftopnm'],
114 ['XBM','pbmtoxbm','xbmtopbm'],
115 ['IFF','ppmtoilbm','ilbmtoppm'],
116 !$converter{JPEG} && File::Which::which('cjpeg') ? ['JPEG', 'cjpeg' ,'djpeg'] : ();
117  
118 14 $converter{FITS}= {referral => {put => \&PDL::wfits, get => \&PDL::rfits}};
119  
120 # these converters do not understand pbmplus flags:
121 14 $converter{JPEG}{FLAGS} = '';
122 14 $converter{GIF}{Prefilt} = 'ppmquant 256 |';
123  
124 14 for my $key (keys %converter) {
125 $converter{$key}{Rok} = File::Which::which($converter{$key}{get})
126 168 ▶ if defined($converter{$key}{get});
Branch: 1 branch
BranchTrueFalseTotal
if defined $PDL::IO::Pic::converter{$key}{"get"} 140 28 168
127 $converter{$key}{Wok} = File::Which::which($converter{$key}{put})
128 168 ▶ if defined($converter{$key}{put});
Branch: 1 branch
BranchTrueFalseTotal
if defined $PDL::IO::Pic::converter{$key}{"put"} 140 28 168
129 168 ▶ if (defined $converter{$key}{Prefilt}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $PDL::IO::Pic::converter{$key}{"Prefilt"}) 14 154 168
130 14 ▶ my $filt = $1 if $converter{$key}{Prefilt} =~ /^\s*(\S+)\s+/;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::converter{$key}{"Prefilt"} =~ /^\s*(\S+)\s+/ 14 0 14
131 14 ▶ $converter{$key}{Wok} = File::Which::which($filt) if $converter{$key}{Wok};
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::converter{$key}{"Wok"} 0 14 14
132 }
133 }
134  
135 14 $converter{$_}{ushortok} = 1 for grep !m/GIF|TIFF/, keys %converter;
136 }
137  
138 =head1 FUNCTIONS
139  
140 =head2 rpiccan, wpiccan
141  
142 =for ref
143  
144 Test which image formats can be read/written
145  
146 =for example
147  
148 $im = PDL->rpic('PDL.jpg') if PDL->rpiccan('JPEG');
149 @wformats = PDL->wpiccan();
150  
151 finds out if PDL::IO::Pic can read/write certain image formats.
152 When called without arguments returns a list of supported
153 formats. When called with an argument returns true if format
154 is supported on your computer (requires appropriate filters in
155 your path), false otherwise.
156  
157 =cut
158  
159 0 ▶sub rpiccan {return PDL->rpiccan(@_)}
Subroutine rpiccan: not called CC=1 SCAR=6.9
Pod documented
160 0 ▶sub wpiccan {return PDL->wpiccan(@_)}
Subroutine wpiccan: not called CC=1 SCAR=6.9
Pod documented
161 6 ▶sub PDL::rpiccan {splice @_,1,0,'R';
Subroutine rpiccan: called CC=1 SCAR=0.0
Pod undocumented
162 6 return PDL::IO::Pic::piccan(@_)}
163 3 ▶sub PDL::wpiccan {splice @_,1,0,'W';
Subroutine wpiccan: called CC=1 SCAR=0.0
Pod undocumented
164 3 return PDL::IO::Pic::piccan(@_)}
165  
166  
167 =head2 rpic
168  
169 =for ref
170  
171 Read images in many formats with automatic format detection.
172  
173 =for example
174  
175 $im = rpic $file;
176 $im = PDL->rpic 'PDL.jpg' if PDL->rpiccan('JPEG');
177  
178 I<Options>
179  
180 =for opt
181  
182 FORMAT => 'JPEG' # explicitly read this format
183 XTRAFLAGS => '-nolut' # additional flags for converter
184  
185 Reads image files in most of the formats supported by netpbm. You can
186 explicitly specify a supported format by additionally passing a hash
187 containing the FORMAT key as in
188  
189 $im = rpic ($file, {FORMAT => 'GIF'});
190  
191 This is especially useful if the particular format isn't identified by
192 a magic number and doesn't have the 'typical' extension or you want to
193 avoid the check of the magic number if your data comes in from a pipe.
194 The function returns a pdl of the appropriate type upon completion.
195 Option parsing uses the L<PDL::Options> module and
196 therefore supports minimal options matching.
197  
198 You can also read directly into an existing pdl that has to have the
199 right size(!). This can come in handy when you want to read a sequence
200 of images into a datacube, e.g.
201  
202 $stack = zeroes(byte,3,500,300,4);
203 rpic $stack->slice(':,:,:,(0)'),"PDL.jpg";
204  
205 reads an rgb image (that had better be of size (500,300)) into the
206 first plane of a 3D RGB datacube (=4D pdl datacube). You can also do
207 transpose/inversion upon read that way.
208  
209 =cut
210  
211 14 my $rpicopts = {
212 FORMAT => undef,
213 XTRAFLAGS => undef,
214 };
215  
216 8 ▶sub rpic {PDL->rpic(@_)}
Subroutine rpic: called CC=1 SCAR=0.0
Pod documented
217  
218 16 ▶sub PDL::rpic {
Subroutine rpic: called CC=21 SCAR=44.1
Pod undocumented
219 16 ▶ barf 'Usage: $im = rpic($file[,hints]) or $im = PDL->rpic($file[,hints])'
Branch: 1 branch
BranchTrueFalseTotal
unless @_ 0 16 16
220 if !@_;
221 16 my ($class,$file,$hints,$maybe) = @_;
222 16 my ($type, $pdl);
223  
224 16 ▶ if (ref($file)) { # $file is really a pdl in this case
Branch: 1 branch
BranchTrueFalseTotal
if (ref $file) { } 0 16 16
225 0 $pdl = $file;
226 0 $file = $hints;
227 0 $hints = $maybe;
228 } else {
229 16 $pdl = $class->initialize;
230 }
231  
232 16 ▶ $hints = { iparse $rpicopts, $hints } if ref $hints;
Branch: 1 branch
BranchTrueFalseTotal
if ref $hints 9 7 16
233 16 ▶ if (defined($$hints{FORMAT})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $hints->{'FORMAT'}) { } 9 7 16
234 9 $type = $$hints{FORMAT};
235 barf "unsupported (input) image format"
236 unless exists($converter{$type}) && (
237 ($converter{$type}{referral} && $converter{$type}{referral}{get}) ||
238 9 ▶ $converter{$type}{get} !~ /NA/);
Branch: 1 branch
BranchTrueFalseTotal
unless exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"get"} || !($PDL::IO::Pic::converter{$type}{"get"} =~ /NA/) 0 9 9
Condition33%3/9
exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"get"} || !($PDL::IO::Pic::converter{$type}{"get"} =~ /NA/)
!ll&&!rl&&r
009
$PDL::IO::Pic::converter{$type}{"referral"} and $PDL::IO::Pic::converter{$type}{"referral"}{"get"} or not $PDL::IO::Pic::converter{$type}{"get"} =~ /NA/
l!l&&r!l&&!r
090
$PDL::IO::Pic::converter{$type}{"referral"} and $PDL::IO::Pic::converter{$type}{"referral"}{"get"}
!ll&&!rl&&r
900
MC/DC0%0/4
exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"get"} || !($PDL::IO::Pic::converter{$type}{"get"} =~ /NA/)
exists $PDL::IO::Pic::converter{$type} $PDL::IO::Pic::converter{$type}{"referral"} $PDL::IO::Pic::converter{$type}{"referral"}{"get"} not $PDL::IO::Pic::converter{$type}{"get"} =~ /NA/
Truth table16%1/6
A and B and C or not(D)
A= exists $PDL::IO::Pic::converter{$type}B= $PDL::IO::Pic::converter{$type}{"referral"}C= $PDL::IO::Pic::converter{$type}{"referral"}{"get"}D= not $PDL::IO::Pic::converter{$type}{"get"} =~ /NA/
ABCDresult
0XXX0
10X00
11000
111X1
10X11
11011
239 } else {
240 7 $type = chkform($file);
241 7 ▶ barf "can't figure out file type, specify explicitly"
Branch: 1 branch
BranchTrueFalseTotal
if $type =~ /UNKNOWN/ 0 7 7
242 if $type =~ /UNKNOWN/;
243 }
244  
245 16 my($converter) = $PDL::IO::Pic::converter;
246 16 ▶ if (defined($converter{$type}{referral})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $PDL::IO::Pic::converter{$type}{"referral"}) 0 16 16
247 0 ▶ if(ref ($converter{$type}{referral}{get}) eq 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $PDL::IO::Pic::converter{$type}{'referral'}{'get'} eq 'CODE') { } 0 0 0
248 0 return &{$converter{$type}{referral}{get}}(@_);
249 } else {
250 0 barf "rpic: internal error with referral (format is $type)\n";
251 }
252 }
253  
254 16 my $fh;
255 16 ▶ if ($converter{$type}->{'get'} and $converter{$type}->{'get'} =~ /^NONE/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($PDL::IO::Pic::converter{$type}{'get'} and $PDL::IO::Pic::converter{$type}{'get'} =~ /^NONE/) { } 16 0 16
Condition33%1/3
$PDL::IO::Pic::converter{$type}{"get"} and $PDL::IO::Pic::converter{$type}{"get"} =~ /^NONE/
!ll&&!rl&&r
0016
MC/DC0%0/2
$PDL::IO::Pic::converter{$type}{"get"} and $PDL::IO::Pic::converter{$type}{"get"} =~ /^NONE/
$PDL::IO::Pic::converter{$type}{"get"} $PDL::IO::Pic::converter{$type}{"get"} =~ /^NONE/
Truth table33%1/3
A and B
A= $PDL::IO::Pic::converter{$type}{"get"}B= $PDL::IO::Pic::converter{$type}{"get"} =~ /^NONE/
ABresult
0X0
100
111
256 16 open $fh, $file;
257 } else {
258 0 ▶ my @cmd = $converter{$type}{get} // barf "No converter for '$type'";
Condition0%0/3
$PDL::IO::Pic::converter{$type}{"get"} // barf("No converter for '${type}'")
l!l&&r!l&&!r
000
MC/DC0%0/2
$PDL::IO::Pic::converter{$type}{"get"} // barf("No converter for '${type}'")
$PDL::IO::Pic::converter{$type}{"get"} barf("No converter for '${type}'")
Truth table0%0/3
A // B
A= $PDL::IO::Pic::converter{$type}{"get"}B= barf("No converter for '${type}'")
ABresult
1X1
011
000
259 0 ▶ push @cmd, shellwords $converter{$type}{FLAGS} // $Dflags;
Condition0%0/3
$PDL::IO::Pic::converter{$type}{"FLAGS"} // $PDL::IO::Pic::Dflags
l!l&&r!l&&!r
000
MC/DC0%0/2
$PDL::IO::Pic::converter{$type}{"FLAGS"} // $PDL::IO::Pic::Dflags
$PDL::IO::Pic::converter{$type}{"FLAGS"} $PDL::IO::Pic::Dflags
Truth table0%0/3
A // B
A= $PDL::IO::Pic::converter{$type}{"FLAGS"}B= $PDL::IO::Pic::Dflags
ABresult
1X1
011
000
260 0 ▶ push @cmd, shellwords $$hints{XTRAFLAGS} if defined($$hints{XTRAFLAGS});
Branch: 1 branch
BranchTrueFalseTotal
if defined $hints->{"XTRAFLAGS"} 0 0 0
261 0 ▶ open $fh, '-|', @cmd, $file
Branch: 1 branch
BranchTrueFalseTotal
open $fh, "-|", @cmd, $file or barf("spawning '@{cmd}' failed: $? ($!)") 0 0 0
262 or barf "spawning '@cmd' failed: $? ($!)";
263 0 ▶ print "conversion by '@cmd'\n" if $PDL::IO::Pic::debug > 10;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug > 10 0 0 0
264 }
265 16 binmode $fh;
266 16 my @frames;
267 16 ▶ while (!eof $fh) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eof $fh) 16 16 32
268 16 push @frames, rpnm $fh;
269 }
270 16 ▶ @frames == 1 ? $frames[0] : cat(@frames);
Branch: 1 branch
BranchTrueFalseTotal
@frames == 1 ? : 16 0 16
271 }
272  
273 =head2 wpic
274  
275 =for ref
276  
277 Write images in many formats with automatic format selection.
278  
279 =for usage
280  
281 Usage: wpic($pdl,$filename[,{ options... }])
282  
283 =for example
284  
285 wpic $pdl, $file;
286 $im->wpic('web.gif',{LUT => $lut});
287 for (@images) {
288 $_->wpic($name[0],{CONVERTER => 'ppmtogif'})
289 }
290  
291  
292 Write out an image file. Function will try to guess correct image
293 format from the filename extension, e.g.
294  
295 $pdl->wpic("image.gif")
296  
297 will write a gif file. The data written out will be scaled to byte if
298 input is of type float/double. Input data that is of a signed integer
299 type and contains negative numbers will be rejected (assuming the user
300 should have the desired conversion to an unsigned type already). A number
301 of options can be specified (as a hash reference) to get more direct control of
302 the image format that is being written. Valid options are (key
303 => example_value):
304  
305 =for options
306  
307 CONVERTER => 'ppmtogif', # explicitly specify pbm converter
308 FLAGS => '-interlaced -transparent 0', # flags for converter
309 IFORM => 'PGM', # explicitly specify intermediate format
310 XTRAFLAGS => '-imagename iris', # additional flags to defaultflags
311 FORMAT => 'PCX', # explicitly specify output image format
312 COLOR => 'bw', # specify color conversion
313 LUT => $lut, # use color table information
314  
315 Option parsing uses the L<PDL::Options> module and
316 therefore supports minimal options matching. A detailed explanation of
317 supported options follows.
318  
319 =over 7
320  
321 =item CONVERTER
322  
323 directly specify the converter,
324 you had better know what you are doing, e.g.
325  
326 CONVERTER => 'ppmtogif',
327  
328 =item FLAGS
329  
330 flags to use with the converter;
331 ignored if !defined($$hints{CONVERTER}), e.g. with the gif format
332  
333 FLAGS => '-interlaced -transparent 0',
334  
335 =item IFORM
336  
337 intermediate PNM/PPM/PGM/PBM format to use;
338 you can append the strings 'RAW' or 'ASCII'
339 to enforce those modes, eg IFORMAT=>'PGMRAW' or
340  
341 IFORM => 'PGM',
342  
343 =item XTRAFLAGS
344  
345 additional flags to use with an automatically chosen
346 converter, this example works when you write SGI
347 files (but will give an error otherwise)
348  
349 XTRAFLAGS => '-imagename iris',
350  
351 =item FORMAT
352  
353 explicitly select the format you want to use. Required if wpic cannot
354 figure out the desired format from the file name extension. Supported
355 types are currently TIFF,GIF,SGI,PNM,JPEG,PS,RAST(Sun Raster),IFF,PCX,
356 e.g.
357  
358 FORMAT => 'PCX',
359  
360 =item COLOR
361  
362 you want black and white (value B<bw>), other possible value is
363 B<bwdither> which will write a dithered black&white
364 image from the input data, data conversion will be done appropriately,
365 e.g.
366  
367 COLOR => 'bw',
368  
369 =item LUT
370  
371 This is a palette image and the value of this key should be a
372 pdl containing an RGB lookup table (3,x), e.g.
373  
374 LUT => $lut,
375  
376 =back
377  
378 Using the CONVERTER hint you can also build a pipe and perform
379 several netpbm operations to get the special result you like. Using it
380 this way the first converter/filecommand in the pipe should be
381 specified with the CONVERTER hint and subsequent converters + flags in
382 the FLAGS hint. This is because wpic tries to figure out the required
383 format to be written by wpnm based on the first converter. Be careful when
384 using the PBMBIN var as it will only be prepended to the converter. If more
385 converters are in the FLAGS part specify the full path unless they are in
386 your PATH anyway.
387  
388 Example:
389  
390 $im->wpic('test.ps',{CONVERTER => 'pgmtopbm',
391 FLAGS => "-dither8 | pnmtops" })
392  
393 Some of the options may appear silly at the moment and probably
394 are. The situation will hopefully improve as people use the code and
395 the need for different/modified options becomes clear. The general
396 idea is to make the function perl compliant: easy things should be
397 easy, complicated tasks possible.
398  
399 =cut
400  
401 14 my %wpicopts = map {($_ => undef)}
402 qw/IFORM CONVERTER FLAGS FORMAT
403 XTRAFLAGS COLOR LUT/;
404 14 my $wpicopts = \%wpicopts;
405  
406 14 *wpic = \&PDL::wpic;
407  
408 10 ▶sub PDL::wpic {
Subroutine wpic: called CC=18 SCAR=31.6
Pod undocumented
409 10 ▶ barf 'Usage: wpic($pdl,$filename[,$hints]) ' .
Branch: 1 branch
BranchTrueFalseTotal
if @_ < 2 0 10 10
410 'or $pdl->wpic($filename,[,$hints])' if @_ < 2;
411  
412 10 my ($pdl,$file,$hints) = @_;
413 10 my ($type, $cmd, $form,$iform,$iraw);
414  
415 10 ▶ $hints = {iparse($wpicopts, $hints)} if ref $hints;
Branch: 1 branch
BranchTrueFalseTotal
if ref $hints 8 2 10
416 # figure out the right converter
417 10 my ($conv, $flags, $format, $referral) = getconv($pdl,$file,$hints);
418  
419 10 ▶ if(defined($referral)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $referral) 0 10 10
420 0 ▶ if(ref ($referral->{'put'}) eq 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $referral->{'put'} eq 'CODE') { } 0 0 0
421 0 return &{$referral->{'put'}}(@_);
422 } else {
423 0 barf "wpic: internal error with referral (format is $format)\n";
424 }
425 }
426  
427 10 ▶ print "Using the command $conv with the flags $flags\n"
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug > 10 2 8 10
428 if $PDL::IO::Pic::debug>10;
429  
430 10 ▶ if (defined($$hints{IFORM})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $hints->{'IFORM'}) { } 5 5 10
431 5 $iform = $$hints{IFORM}; }
432 else { # check if converter requires a particular intermediate format
433 5 ▶ $iform = 'PPM' if $conv =~ /^\s*(ppm)|(cjpeg)/;
Branch: 1 branch
BranchTrueFalseTotal
if $conv =~ /^\s*(ppm)|(cjpeg)/ 0 5 5
434 5 ▶ $iform = 'PGM' if $conv =~ /^\s*pgm/;
Branch: 1 branch
BranchTrueFalseTotal
if $conv =~ /^\s*pgm/ 0 5 5
435 5 ▶ $iform = 'PBM' if $conv =~ /^\s*pbm/;
Branch: 1 branch
BranchTrueFalseTotal
if $conv =~ /^\s*pbm/ 0 5 5
436 5 ▶ $iform = 'PNM' if $conv =~ /^\s*(pnm)|(NONE)/; }
Branch: 1 branch
BranchTrueFalseTotal
if $conv =~ /^\s*(pnm)|(NONE)/ 5 0 5
437 # get final values for $iform and $pdl (check conversions, consistency,etc)
438 10 ($pdl,$iform) = chkpdl($pdl,$iform,$hints,$format);
439 10 ▶ print "using intermediate format $iform\n" if $PDL::IO::Pic::debug>10;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug > 10 2 8 10
440  
441 10 $cmd = "|" . qq{$conv $flags >"$file"};
442 10 ▶ $cmd = ">" . $file if $conv =~ /^NONE/;
Branch: 1 branch
BranchTrueFalseTotal
if $conv =~ /^NONE/ 10 0 10
443 10 ▶ print "built the command $cmd to write image\n" if $PDL::IO::Pic::debug>10;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug > 10 2 8 10
444  
445 10 ▶ $iraw = 1 if (defined($$hints{IFORM}) && $$hints{IFORM} =~ /RAW/);
Branch: 1 branch
BranchTrueFalseTotal
if defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /RAW/ 5 5 10
Condition66%2/3
defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /RAW/
!ll&&!rl&&r
505
MC/DC50%1/2
defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /RAW/
defined $hints->{"IFORM"} $hints->{"IFORM"} =~ /RAW/
Truth table66%2/3
A and B
A= defined $hints->{"IFORM"}B= $hints->{"IFORM"} =~ /RAW/
ABresult
0X0
100
111
446 10 ▶ $iraw = 0 if (defined($$hints{IFORM}) && $$hints{IFORM} =~ /ASCII/);
Branch: 1 branch
BranchTrueFalseTotal
if defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /ASCII/ 0 10 10
Condition66%2/3
defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /ASCII/
!ll&&!rl&&r
550
MC/DC0%0/2
defined $hints->{"IFORM"} and $hints->{"IFORM"} =~ /ASCII/
defined $hints->{"IFORM"} $hints->{"IFORM"} =~ /ASCII/
Truth table66%2/3
A and B
A= defined $hints->{"IFORM"}B= $hints->{"IFORM"} =~ /ASCII/
ABresult
0X0
100
111
447  
448 10 ▶ local $SIG{PIPE}= sub {}; # Prevent crashing if converter dies
Subroutine __ANON__: not called CC=1 SCAR=0.0
449  
450 10 wpnm($pdl, $cmd, $iform , $iraw);
451 }
452  
453 =head2 rim
454  
455 =for usage
456  
457 Usage: $x = rim($file);
458 or rim($x,$file);
459  
460 =for ref
461  
462 Read images in most formats, with improved RGB handling.
463  
464 You specify a filename and get back a PDL with the image data in it.
465 Any PNM handled format or FITS will work. In the second form, $x is an
466 existing PDL that gets loaded with the image data.
467  
468 If the image is in one of the standard RGB formats, then you get back
469 data in (<X>,<Y>,<RGB-index>) format -- that is to say, the third dim
470 contains the color information. That allows you to do simple indexing
471 into the image without knowing whether it is color or not -- if present,
472 the RGB information is silently broadcasted over. (Contrast L</rpic>, which
473 munges the information by putting the RGB index in the 0th dim, screwing
474 up subsequent broadcasting operations).
475  
476 If the image is in FITS format, then you get the data back in exactly
477 the same order as in the file itself.
478  
479 Images with a ".Z" or ".gz" extension are assumed to be compressed with
480 UNIX L<"compress"|compress> or L<"gzip"|gzip>, respectively, and are
481 automatically uncompressed before reading.
482  
483 OPTIONS
484  
485 The same as L</rpic>, which is used as an engine:
486  
487 =over 3
488  
489 =item FORMAT
490  
491 If you don't specify this then formats are autodetected. If you do specify
492 it then only the specified interpreter is tried. For example,
493  
494 $x = rim("foo.gif",{FORMAT=>"JPEG"})
495  
496 forces JPEG interpretation.
497  
498 =item XTRAFLAGS
499  
500 Contains extra command line flags for the pnm interpreter. For example,
501  
502 $x = rim("foo.jpg",{XTRAFLAGS=>"-nolut"})
503  
504 prevents use of a lookup table in JPEG images.
505  
506 =back
507  
508 =cut
509  
510 6 ▶sub rim {
Subroutine rim: called CC=8 SCAR=21.5
Pod documented
511 ## Handle dest-PDL-first case
512 6 ▶ my $dest = @_ >= 2 && UNIVERSAL::isa($_[0],'PDL') ? shift : undef;
Branch: 1 branch
BranchTrueFalseTotal
@_ >= 2 && UNIVERSAL::isa($_[0], 'PDL') ? : 3 3 6
Condition66%2/3
@_ >= 2 and UNIVERSAL::isa($_[0], "PDL")
!ll&&!rl&&r
033
MC/DC50%1/2
@_ >= 2 and UNIVERSAL::isa($_[0], "PDL")
@_ >= 2 UNIVERSAL::isa($_[0], "PDL")
Truth table66%2/3
A and B
A= @_ >= 2B= UNIVERSAL::isa($_[0], "PDL")
ABresult
0X0
100
111
513 6 my $out = rpic(@_);
514 6 ▶ my $isrgb = $out->ndims == 3 && $out->dim(0) == 3;
Condition66%2/3
$out->ndims == 3 && $out->dim(0) == 3
!ll&&!rl&&r
204
MC/DC50%1/2
$out->ndims == 3 && $out->dim(0) == 3
$out->ndims == 3 $out->dim(0) == 3
Truth table66%2/3
A && B
A= $out->ndims == 3B= $out->dim(0) == 3
ABresult
0X0
100
111
515 $out = $out->reorder(1,2,0) if $isrgb &&
516 6 ▶ !(defined($out->gethdr) && $out->gethdr->{SIMPLE});
Branch: 1 branch
BranchTrueFalseTotal
if $isrgb and not defined $out->gethdr && $out->gethdr->{"SIMPLE"} 4 2 6
Condition50%3/6
$isrgb and not defined $out->gethdr && $out->gethdr->{"SIMPLE"}
!ll&&!rl&&r
204
defined $out->gethdr && $out->gethdr->{'SIMPLE'}
!ll&&!rl&&r
400
MC/DC33%1/3
$isrgb and not defined $out->gethdr && $out->gethdr->{"SIMPLE"}
$isrgb defined $out->gethdr $out->gethdr->{'SIMPLE'}
Truth table50%2/4
A and not(B && C)
A= $isrgbB= defined $out->gethdrC= $out->gethdr->{'SIMPLE'}
ABCresult
0XX0
1110
10X1
1101
517 6 ▶ $dest .= $out if defined $dest;
Branch: 1 branch
BranchTrueFalseTotal
if defined $dest 3 3 6
518 6 $out;
519 }
520  
521 =head2 wim
522  
523 =for ref
524  
525 Write a pdl to an image file with selected type (or using filename extensions)
526  
527 =for usage
528  
529 wim $pdl,$file;
530 $pdl->wim("foo.gif",{LUT=>$lut});
531  
532 Write out an image file. You can specify the format explicitly as an
533 option, or the function will try to guess the correct image
534 format from the filename extension, e.g.
535  
536 $pdl->wim("image.gif");
537 $pdl->wim("image.fits");
538  
539 will write a gif and a FITS file. The data written out will be scaled
540 to byte if the input if of type float/double. Input data that is of a
541 signed integer type and contains negative numbers will be rejected.
542  
543 If you append C<.gz> or C<.Z> to the end of the file name, the final
544 file will be automatically compressed with L<"gzip"|gzip> |
545 L<"compress"|compress>, respectively.
546  
547 OPTIONS
548  
549 You can pass in a hash ref whose keys are options. The code uses the
550 PDL::Options module so unique abbreviations are accepted. Accepted
551 keys are the same as for L</wpic>, which is used as an engine:
552  
553 =over 3
554  
555 =item CONVERTER
556  
557 Names the converter program to be used by pbmplus (e.g. "ppmtogif" to
558 output a gif file)
559  
560 =item FLAGS
561  
562 Flags that should be passed to the converter (replacing any default flag list)
563 e.g. "-interlaced" to make an interlaced GIF
564  
565 =item IFORM
566  
567 Explicitly specifies the intermediate format (e.g. PGM, PPM, or PNM).
568  
569 =item XTRAFLAGS
570  
571 Flags that should be passed to the converter (in addition to any default
572 flag list).
573  
574 =item FORMAT
575  
576 Explicitly specifies the output image format (allowing pbmplus to pick an
577 output converter)
578  
579 =item COLOR
580  
581 Specifies color conversion (e.g. 'bw' converts to black-and-white; see
582 pbmplus for details).
583  
584 =item LUT
585  
586 Use color-table information
587  
588 =back
589  
590 =cut
591  
592 14 *wim = \&PDL::wim;
593  
594 0 ▶sub PDL::wim {
Subroutine wim: not called CC=6 SCAR=37.4
Pod undocumented
595 0 my(@args) = @_;
596 0 my($im) = $args[0];
597 0 ▶ my $isrgb = $im->ndims == 3 && $im->dim(2) == 3;
Condition0%0/3
$im->ndims == 3 && $im->dim(2) == 3
!ll&&!rl&&r
000
MC/DC0%0/2
$im->ndims == 3 && $im->dim(2) == 3
$im->ndims == 3 $im->dim(2) == 3
Truth table0%0/3
A && B
A= $im->ndims == 3B= $im->dim(2) == 3
ABresult
0X0
100
111
598 $args[0] = $im->reorder(2,0,1)
599 if $isrgb and !(
600 ( $args[1] =~ m/\.fits$/i )
601 or
602 0 ▶ ( ref $args[2] eq 'HASH' and $args[2]->{FORMAT} =~ m/fits/i )
Branch: 1 branch
BranchTrueFalseTotal
if $isrgb and not $args[1] =~ /\.fits$/i || ref $args[2] eq "HASH" && $args[2]{"FORMAT"} =~ /fits/i 0 0 0
Condition0%0/9
$isrgb and not $args[1] =~ /\.fits$/i || ref $args[2] eq "HASH" && $args[2]{"FORMAT"} =~ /fits/i
!ll&&!rl&&r
000
$args[1] =~ /\.fits$/i || ref $args[2] eq 'HASH' && $args[2]{'FORMAT'} =~ /fits/i
l!l&&r!l&&!r
000
ref $args[2] eq "HASH" and $args[2]{"FORMAT"} =~ /fits/i
!ll&&!rl&&r
000
MC/DC0%0/4
$isrgb and not $args[1] =~ /\.fits$/i || ref $args[2] eq "HASH" && $args[2]{"FORMAT"} =~ /fits/i
$isrgb $args[1] =~ /\.fits$/i ref $args[2] eq "HASH" $args[2]{"FORMAT"} =~ /fits/i
Truth table0%0/5
A and not(B || C and D)
A= $isrgbB= $args[1] =~ /\.fits$/iC= ref $args[2] eq "HASH"D= $args[2]{"FORMAT"} =~ /fits/i
ABCDresult
0XXX0
11XX0
10110
100X1
10101
603 );
604 0 wpic(@args);
605 }
606  
607 =head2 rmpeg
608  
609 =for ref
610  
611 Read an image sequence (a (3,x,y,n) byte pdl) from an animation.
612  
613 =for usage
614  
615 $ndarray = rmpeg('movie.mpg'); # $ndarray is (3,x,y,nframes) byte
616  
617 Reads a stack of RGB images from a movie. While the
618 format generated is nominally MPEG, the file extension
619 is used to determine the video encoder type.
620 It uses the program C<ffmpeg>, and throws an exception if not found.
621  
622 =cut
623  
624 14 *rmpeg = \&PDL::rmpeg;
625 0 ▶sub PDL::rmpeg {
Subroutine rmpeg: not called CC=5 SCAR=34.0
Pod undocumented
626 0 ▶ barf 'Usage: rmpeg($filename)' if @_ != 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ != 1 0 0 0
627 0 my ($file) = @_;
628 0 ▶ die "rmpeg: ffmpeg not found in PATH" if !File::Which::which('ffmpeg');
Branch: 1 branch
BranchTrueFalseTotal
unless File::Which::which("ffmpeg") 0 0 0
629 0 ▶ open my $fh, '-|', qw(ffmpeg -loglevel quiet -i), $file, qw(-f image2pipe -codec:v ppm -)
Branch: 1 branch
BranchTrueFalseTotal
open my $fh, "-|", ("ffmpeg", "-loglevel", "quiet", "-i"), $file, ("-f", "image2pipe", "-codec:v", "ppm", "-") or barf("spawning ffmpeg failed: $?") 0 0 0
630 or barf "spawning ffmpeg failed: $?";
631 0 binmode $fh;
632 0 my @frames;
633 0 ▶ while (!eof $fh) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eof $fh) 0 0 0
634 0 push @frames, rpnm $fh;
635 }
636 0 cat(@frames);
637 }
638  
639 =head2 wmpeg
640  
641 =for ref
642  
643 Write an image sequence (a (3,x,y,n) byte pdl) as an animation.
644  
645 =for usage
646  
647 $ndarray->wmpeg('movie.mpg'); # $ndarray is (3,x,y,nframes) byte
648  
649 Writes a stack of RGB images as a movie. While the
650 format generated is nominally MPEG, the file extension
651 is used to determine the video encoder type.
652 E.g. F<.mpg> for MPEG-1 encoding, F<.mp4> for MPEG-4 encoding, F<.gif>
653 for GIF animation
654  
655 C<wmpeg> requires a 4-D pdl of type B<byte> as
656 input. The first dim B<has> to be of size 3 since
657 it will be interpreted as RGB pixel data.
658 C<wmpeg> returns 1 on success and undef on failure.
659  
660 =for example
661  
662 use strict; use warnings;
663 use PDL;
664 use PDL::IO::Pic;
665 my ($width, $height, $framecount, $xvel, $maxheight, $ballsize) = (320, 80, 100, 15, 60, 8);
666 my $frames = zeros byte, $width, $height, $framecount;
667 my $coords = yvals(3, $framecount); # coords for drawing ball, all val=frameno
668 my ($xcoords, $ycoords) = map $coords->slice($_), 0, 1;
669 $xcoords *= $xvel; # moves $xvel pixels/frame
670 $xcoords .= $width - abs(($xcoords % (2*$width)) - $width); # back and forth
671 my $sqrtmaxht = sqrt $maxheight;
672 $ycoords .= indx($maxheight - ((($ycoords % (2*$sqrtmaxht)) - $sqrtmaxht)**2));
673 my $val = pdl(byte,250); # start with white
674 $frames->range($coords, [$ballsize,$ballsize,1], 't') .= $val;
675 $frames = $frames->dummy(0, 3)->copy; # now make the movie
676 $frames->wmpeg('bounce.gif'); # or bounce.mp4, ffmpeg deals OK
677  
678 # iterate running this with:
679 rm bounce.gif; perl scriptname.pl && animate bounce.gif
680  
681 Some of the input data restrictions will have to
682 be relaxed in the future but routine serves as
683 a proof of principle at the moment. It uses the
684 program ffmpeg to encode the frames into video.
685 Currently, wmpeg
686 doesn't allow modification of the parameters
687 written through its calling interface. This will
688 change in the future as needed.
689  
690 In the future it might be much nicer to implement
691 a movie perl object that supplies methods for
692 manipulating the image stack (insert, cut, append
693 commands) and a final movie->make() call would
694 invoke ffmpeg on the picture stack (which will
695 only be held on disk). This should get around the
696 problem of having to hold a huge amount of data
697 in memory to be passed into wmpeg (when you are,
698 e.g. writing a large animation from PDL3D rendered
699 fly-throughs).
700  
701 =cut
702  
703 14 *wmpeg = \&PDL::wmpeg;
704 0 ▶sub PDL::wmpeg {
Subroutine wmpeg: not called CC=10 SCAR=47.0
Pod undocumented
705 0 ▶ barf 'Usage: wmpeg($pdl,$filename) or $pdl->wmpeg($filename)' if @_ != 2;
Branch: 1 branch
BranchTrueFalseTotal
if @_ != 2 0 0 0
706 0 my ($pdl,$file) = @_;
707 # return undef if no ffmpeg in path
708 0 ▶ if (! File::Which::which('ffmpeg')) {
Branch: 1 branch
BranchTrueFalseTotal
unless (File::Which::which("ffmpeg")) 0 0 0
709 0 warn("wmpeg: ffmpeg not found in PATH");
710 0 return;
711 }
712 0 my @Dims = $pdl->dims;
713 # too strict in general but alright for the moment
714 # especially restriction to byte will have to be relaxed
715 0 ▶ barf "input must be byte (3,x,y,z)" if (@Dims != 4) || ($Dims[0] != 3)
Branch: 1 branch
BranchTrueFalseTotal
if @Dims != 4 or $Dims[0] != 3 or $pdl->get_datatype != $PDL::IO::Pic::PDL_B 0 0 0
Condition0%0/6
@Dims != 4 or $Dims[0] != 3 or $pdl->get_datatype != $PDL::IO::Pic::PDL_B
l!l&&r!l&&!r
000
@Dims != 4 or $Dims[0] != 3
l!l&&r!l&&!r
000
MC/DC0%0/3
@Dims != 4 or $Dims[0] != 3 or $pdl->get_datatype != $PDL::IO::Pic::PDL_B
@Dims != 4 $Dims[0] != 3 $pdl->get_datatype != $PDL::IO::Pic::PDL_B
Truth table0%0/4
A or B or C
A= @Dims != 4B= $Dims[0] != 3C= $pdl->get_datatype != $PDL::IO::Pic::PDL_B
ABCresult
1XX1
01X1
0011
0000
716 || ($pdl->get_datatype != $PDL_B);
717 0 my $nims = $Dims[3];
718 # $frame is 16N x 16N frame (per mpeg standard), insert each image in as $inset
719 0 my (@MDims) = (3,map(16*int(($_+15)/16),@Dims[1..2]));
720 0 my $frame = zeroes(byte,@MDims);
721 0 my $inset = $frame->slice(join ',',
722 map int(($MDims[$_]-$Dims[$_])/2).':'.
723 int(($MDims[$_]+$Dims[$_])/2-1),0..2);
724 0 local $SIG{PIPE} = 'IGNORE';
725 0 my $loglevel = 'quiet';
726 0 ▶ $loglevel = 'verbose' if $PDL::verbose;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::verbose 0 0 0
727 0 ▶ $loglevel = 'debug' if $PDL::debug;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::debug 0 0 0
728 0 ▶ open my $fh, '|-', qw(ffmpeg -y -loglevel), $loglevel, qw(-f image2pipe -codec:v ppm -i -), $file
Branch: 1 branch
BranchTrueFalseTotal
open my $fh, "|-", ("ffmpeg", "-y", "-loglevel"), $loglevel, ("-f", "image2pipe", "-codec:v", "ppm", "-i", "-"), $file or barf("spawning ffmpeg failed: $?") 0 0 0
729 or barf "spawning ffmpeg failed: $?";
730 0 binmode $fh;
731 0 for ($pdl->dog) {
732 0 $inset .= $_;
733 0 wpnm($frame, $fh, 'PPM', 1);
734 }
735 0 return 1;
736 }
737  
738 =head2 imageformat
739  
740 =for ref
741  
742 Figure out the format of an image file from its magic numbers, or else, from its extension.
743  
744 Currently recognized image formats are: PNM, GIF, TIFF, JPEG, SGI,
745 RAST, IFF, PCX, PS, FITS, PNG, XBM. If the format can not be determined,
746 the string 'UNKNOWN' is returned.
747  
748 =for example
749  
750 $format=imageformat($path); # find out image format of certain file
751 print "Unknown image format" if $format eq 'UNKNOWN';
752 $canread=rpiccan($format); # check if this format is readable in this system
753 if($canread){
754 $pdl=rpic($path) ; # attempt to read image ONLY if we can
755 } else {
756 print "Image can't be read\n"; # skip unreadable file
757 }
758  
759 =cut
760  
761 2 ▶sub imageformat {PDL->imageformat(@_)}
Subroutine imageformat: called CC=1 SCAR=0.0
Pod documented
762  
763 2 ▶sub PDL::imageformat {
Subroutine imageformat: called CC=1 SCAR=0.0
Pod undocumented
764 2 my($class, $file)=@_;
765 2 return chkform($file);
766 }
767  
768 9 ▶sub _piccan {
Subroutine _piccan: called CC=5 SCAR=16.7
769 9 my ($format, $rw, $refer_rw) = @_;
770 9 my $cnv = $converter{$format};
771 ($cnv->{$refer_rw} && $cnv->{$refer_rw} eq 'NONE') || # directly supported
772 9 ▶ $cnv->{$rw} || ($cnv->{referral} && $cnv->{referral}{$refer_rw});
Branch: 1 branch
BranchTrueFalseTotal
$cnv->{$refer_rw} and $cnv->{$refer_rw} eq "NONE" or $cnv->{$rw} or $cnv->{"referral"} and $cnv->{"referral"}{$refer_rw} 3 6 9
Condition66%8/12
$cnv->{$refer_rw} && $cnv->{$refer_rw} eq 'NONE' || $cnv->{$rw} || $cnv->{'referral'} && $cnv->{'referral'}{$refer_rw}
l!l&&r!l&&!r
306
$cnv->{$refer_rw} and $cnv->{$refer_rw} eq "NONE" or $cnv->{$rw}
l!l&&r!l&&!r
306
$cnv->{$refer_rw} and $cnv->{$refer_rw} eq "NONE"
!ll&&!rl&&r
153
$cnv->{"referral"} and $cnv->{"referral"}{$refer_rw}
!ll&&!rl&&r
600
MC/DC40%2/5
$cnv->{$refer_rw} && $cnv->{$refer_rw} eq 'NONE' || $cnv->{$rw} || $cnv->{'referral'} && $cnv->{'referral'}{$refer_rw}
$cnv->{$refer_rw} $cnv->{$refer_rw} eq "NONE" $cnv->{$rw} $cnv->{"referral"} $cnv->{"referral"}{$refer_rw}
Truth table33%3/9
A and B or C || D and E
A= $cnv->{$refer_rw}B= $cnv->{$refer_rw} eq "NONE"C= $cnv->{$rw}D= $cnv->{"referral"}E= $cnv->{"referral"}{$refer_rw}
ABCDEresult
11XXX1
0X1XX1
101XX1
0X0111
100111
0X00X0
0X0100
1000X0
100100
773 }
774 9 ▶sub piccan {
Subroutine piccan: called CC=5 SCAR=16.2
Pod undocumented
775 9 my $class = shift;
776 9 ▶ my $rw = (shift =~ /r/i) ? 'Rok' : 'Wok';
Branch: 1 branch
BranchTrueFalseTotal
(shift()) =~ /r/i ? : 6 3 9
777 9 ▶ my $refer_rw = $rw eq 'Rok' ? 'get' : 'put';
Branch: 1 branch
BranchTrueFalseTotal
$rw eq 'Rok' ? : 6 3 9
778 9 ▶ return sort grep _piccan($_, $rw, $refer_rw), keys %converter if !@_;
Branch: 1 branch
BranchTrueFalseTotal
unless @_ 0 9 9
779 9 my $format = shift;
780 9 ▶ barf 'unknown format' unless defined($converter{$format});
Branch: 1 branch
BranchTrueFalseTotal
unless defined $PDL::IO::Pic::converter{$format} 0 9 9
781 9 _piccan($format, $rw, $refer_rw);
782 }
783  
784 7 ▶sub getext {
Subroutine getext: called CC=2 SCAR=7.0
Pod undocumented
785 # changed to a more os independent way
786 7 my $file = shift;
787 7 my ($base,$dir,$ext) = fileparse($file,'\.[^.]*');
788 7 ▶ $ext = $1 if $ext =~ /^.([^;]*)/; # chop off VMS version numbers
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^.([^;]*)/ 7 0 7
789 7 return $ext;
790 }
791  
792 # try to figure out the format of a supposed image file from the extension
793 # a couple of extensions are only checked when the optional parameter
794 # $wmode is set (because those should have been identified by magic numbers
795 # when reading)
796 # todo: check completeness
797 7 ▶sub chkext {
Subroutine chkext: called CC=15 SCAR=50.0
Pod undocumented
798 7 my ($ext,$wmode) = @_;
799 7 ▶ $wmode = 0 unless defined $wmode;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $wmode 0 7 7
800  
801 # there are not yet file formats which wouldn't have been identified
802 # by magic no's if in reading mode
803  
804 7 ▶ if ($wmode) {
Branch: 1 branch
BranchTrueFalseTotal
if ($wmode) 7 0 7
805 7 ▶ return 'PNM' if $ext =~ /^(pbm)|(pgm)|(ppm)|(pnm)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^(pbm)|(pgm)|(ppm)|(pnm)$/ 7 0 7
806 0 ▶ return 'JPEG' if $ext =~ /^(jpg)|(jpeg)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^(jpg)|(jpeg)$/ 0 0 0
807 0 ▶ return 'TIFF' if $ext =~ /^(tiff)|(tif)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^(tiff)|(tif)$/ 0 0 0
808 0 ▶ return 'PCX' if $ext =~ /^pcx$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^pcx$/ 0 0 0
809 0 ▶ return 'SGI' if $ext =~ /^rgb$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^rgb$/ 0 0 0
810 0 ▶ return 'GIF' if $ext =~ /^gif$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^gif$/ 0 0 0
811 0 ▶ return 'RAST' if $ext =~ /^(r)|(rast)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^(r)|(rast)$/ 0 0 0
812 0 ▶ return 'IFF' if $ext =~ /^(iff)|(ilbm)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^(iff)|(ilbm)$/ 0 0 0
813 0 ▶ return 'PS' if $ext =~ /^ps/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^ps/ 0 0 0
814 0 ▶ return 'FITS' if $ext =~ /^f(i?ts|it)$/;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^f(i?ts|it)$/ 0 0 0
815 0 ▶ return 'PNG' if $ext =~ /^png$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^png$/i 0 0 0
816 0 ▶ return 'XBM' if $ext =~ /^xbm$/i;
Branch: 1 branch
BranchTrueFalseTotal
if $ext =~ /^xbm$/i 0 0 0
817 }
818  
819  
820 0 return 'UNKNOWN';
821 }
822  
823  
824  
825 # try to figure out the format of a supposed image file
826 # from the magic numbers (numbers taken from magic in netpbm and
827 # the file format routines in xv)
828 # if no magics match try extension for non-magic file types
829 # todo: make more complete
830  
831 9 ▶sub chkform {
Subroutine chkform: called CC=16 SCAR=49.2
Pod undocumented
832 9 my $file = shift;
833 9 my ($format, $magic, $len, $ext) = ("","",0,"");
834 9 ▶ open my $fh, $file or barf "Can't open image file";
Branch: 1 branch
BranchTrueFalseTotal
open my $fh, $file or barf("Can't open image file") 9 0 9
835 9 binmode $fh;
836 # should first check if file is long enough
837 9 $len = read($fh, $magic,12);
838 9 ▶ if (!defined($len) ||$len != 12) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $len or $len != 12) 0 9 9
Condition33%1/3
not defined $len or $len != 12
l!l&&r!l&&!r
009
MC/DC0%0/2
not defined $len or $len != 12
not defined $len $len != 12
Truth table33%1/3
not(A) or B
A= not defined $lenB= $len != 12
ABresult
1X1
011
000
839 0 barf "end of file when checking magic number";
840 0 close $fh;
841 0 return 'UNKNOWN';
842 }
843 9 close $fh;
844 9 ▶ return 'PNM' if $magic =~ /^P[1-6]/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^P[1-6]/ 9 0 9
845 0 ▶ return 'GIF' if $magic =~ /(^GIF87a)|(^GIF89a)/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /(^GIF87a)|(^GIF89a)/ 0 0 0
846 0 ▶ return 'TIFF' if $magic =~ /(^MM)|(^II)/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /(^MM)|(^II)/ 0 0 0
847 0 ▶ return 'JPEG' if $magic =~ /^(\377\330\377)/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^(\377\330\377)/ 0 0 0
848 0 ▶ return 'SGI' if $magic =~ /^(\001\332)|(\332\001)/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^(\001\332)|(\332\001)/ 0 0 0
849 0 ▶ return 'RAST' if $magic =~ /^\131\246\152\225/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^\131\246\152\225/ 0 0 0
850 0 ▶ return 'IFF' if $magic =~ /ILBM$/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /ILBM$/ 0 0 0
851 0 ▶ return 'PCX' if $magic =~ /^\012[\000-\005]/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^\012[\000-\005]/ 0 0 0
852 0 ▶ return 'PS' if $magic =~ /%!\s*PS/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /%!\s*PS/ 0 0 0
853 0 ▶ return 'FITS' if $magic =~ /^SIMPLE \=/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^SIMPLE \=/ 0 0 0
854 0 ▶ return 'PNG' if $magic =~ /^.PNG\r/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^.PNG\r/ 0 0 0
855 0 ▶ return 'XBM' if $magic =~ /^#define\s+/;
Branch: 1 branch
BranchTrueFalseTotal
if $magic =~ /^#define\s+/ 0 0 0
856 0 return chkext(getext($file)); # then try extensions
857 }
858  
859 # helper proc for wpic
860 # process hints for direct converter control and try to guess from extension
861 # otherwise
862 10 ▶sub getconv {
Subroutine getconv: called CC=13 SCAR=30.9
Pod undocumented
863 10 my ($pdl,$file,$hints) = @_;
864  
865 return ($$hints{CONVERTER},$$hints{FLAGS})
866 10 ▶ if defined($$hints{CONVERTER}); # somebody knows what they're doing
Branch: 1 branch
BranchTrueFalseTotal
if defined $hints->{"CONVERTER"} 0 10 10
867  
868 10 my $type = "";
869 10 ▶ if (defined($$hints{'FORMAT'})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $hints->{'FORMAT'}) { } 3 7 10
870 3 $type = $$hints{'FORMAT'};
871 barf "unsupported (output) image format"
872 unless exists($converter{$type}) && (
873 ($converter{$type}{referral} && $converter{$type}{referral}{put}) ||
874 3 ▶ $converter{$type}{put} !~ /NA/);
Branch: 1 branch
BranchTrueFalseTotal
unless exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"put"} || !($PDL::IO::Pic::converter{$type}{"put"} =~ /NA/) 0 3 3
Condition33%3/9
exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"put"} || !($PDL::IO::Pic::converter{$type}{"put"} =~ /NA/)
!ll&&!rl&&r
003
$PDL::IO::Pic::converter{$type}{"referral"} and $PDL::IO::Pic::converter{$type}{"referral"}{"put"} or not $PDL::IO::Pic::converter{$type}{"put"} =~ /NA/
l!l&&r!l&&!r
030
$PDL::IO::Pic::converter{$type}{"referral"} and $PDL::IO::Pic::converter{$type}{"referral"}{"put"}
!ll&&!rl&&r
300
MC/DC0%0/4
exists $PDL::IO::Pic::converter{$type} and $PDL::IO::Pic::converter{$type}{"referral"} && $PDL::IO::Pic::converter{$type}{"referral"}{"put"} || !($PDL::IO::Pic::converter{$type}{"put"} =~ /NA/)
exists $PDL::IO::Pic::converter{$type} $PDL::IO::Pic::converter{$type}{"referral"} $PDL::IO::Pic::converter{$type}{"referral"}{"put"} not $PDL::IO::Pic::converter{$type}{"put"} =~ /NA/
Truth table16%1/6
A and B and C or not(D)
A= exists $PDL::IO::Pic::converter{$type}B= $PDL::IO::Pic::converter{$type}{"referral"}C= $PDL::IO::Pic::converter{$type}{"referral"}{"put"}D= not $PDL::IO::Pic::converter{$type}{"put"} =~ /NA/
ABCDresult
0XXX0
10X00
11000
111X1
10X11
11011
875 } else {
876 7 $type = chkext(getext($file),1);
877 7 ▶ if ($type =~ /UNKNOWN/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type =~ /UNKNOWN/) 0 7 7
878 0 barf "can't figure out desired file type, using PNM" ;
879 0 $type = 'PNM';
880 }
881 }
882  
883 10 my $conv = $converter{$type}->{'put'};
884  
885 # the datatype check is only a dirty fix for the ppmquant problem with
886 # types > byte
887 # a ppmquant is anyway only warranted when $isrgb!!!
888 $conv = $converter{$type}->{Prefilt}.$conv
889 10 ▶ if defined($converter{$type}->{Prefilt});
Branch: 1 branch
BranchTrueFalseTotal
if defined $PDL::IO::Pic::converter{$type}{"Prefilt"} 0 10 10
890  
891 10 my $flags = $converter{$type}->{FLAGS};
892 10 ▶ $flags = "$Dflags" unless defined($flags);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $flags 10 0 10
893 10 ▶ $flags .= " $$hints{XTRAFLAGS}" if defined($$hints{XTRAFLAGS});
Branch: 1 branch
BranchTrueFalseTotal
if defined $hints->{"XTRAFLAGS"} 0 10 10
894 10 ▶ if (defined($$hints{'COLOR'}) && $$hints{'COLOR'} =~ /bwdither/) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $hints->{"COLOR"} and $hints->{"COLOR"} =~ /bwdither/) 0 10 10
Condition66%2/3
defined $hints->{"COLOR"} and $hints->{"COLOR"} =~ /bwdither/
!ll&&!rl&&r
910
MC/DC0%0/2
defined $hints->{"COLOR"} and $hints->{"COLOR"} =~ /bwdither/
defined $hints->{"COLOR"} $hints->{"COLOR"} =~ /bwdither/
Truth table66%2/3
A and B
A= defined $hints->{"COLOR"}B= $hints->{"COLOR"} =~ /bwdither/
ABresult
0X0
100
111
895 0 $flags = " | $conv $flags";
896 0 $conv = "pgmtopbm -floyd"; }
897  
898 10 my($referral) = $converter{$type}->{referral};
899  
900 10 return ($conv, $flags, $type, $referral);
901 }
902  
903 # helper proc for wpic
904 # if a certain type of pnm is required check data and make compliant if possible
905 # else if intermediate format is pnm or ppm figure out the appropriate format
906 # from the pdl
907 10 ▶sub chkpdl {
Subroutine chkpdl: called CC=21 SCAR=37.5
Pod undocumented
908 10 my ($pdl, $iform, $hints, $format) = @_;
909  
910 10 ▶ if ($pdl->get_datatype >= $PDL_L ||
Branch: 1 branch
BranchTrueFalseTotal
if ($pdl->get_datatype >= $PDL::IO::Pic::PDL_L or $pdl->get_datatype == $PDL::IO::Pic::PDL_S or not $PDL::IO::Pic::converter{$format}{"ushortok"} and $pdl->get_datatype == $PDL::IO::Pic::PDL_US) 1 9 10
Condition55%5/9
$pdl->get_datatype >= $PDL::IO::Pic::PDL_L or $pdl->get_datatype == $PDL::IO::Pic::PDL_S or not $PDL::IO::Pic::converter{$format}{"ushortok"} and $pdl->get_datatype == $PDL::IO::Pic::PDL_US
l!l&&r!l&&!r
109
$pdl->get_datatype >= $PDL::IO::Pic::PDL_L or $pdl->get_datatype == $PDL::IO::Pic::PDL_S
l!l&&r!l&&!r
109
not $PDL::IO::Pic::converter{$format}{"ushortok"} and $pdl->get_datatype == $PDL::IO::Pic::PDL_US
!ll&&!rl&&r
900
MC/DC25%1/4
$pdl->get_datatype >= $PDL::IO::Pic::PDL_L or $pdl->get_datatype == $PDL::IO::Pic::PDL_S or not $PDL::IO::Pic::converter{$format}{"ushortok"} and $pdl->get_datatype == $PDL::IO::Pic::PDL_US
$pdl->get_datatype >= $PDL::IO::Pic::PDL_L $pdl->get_datatype == $PDL::IO::Pic::PDL_S not $PDL::IO::Pic::converter{$format}{"ushortok"} $pdl->get_datatype == $PDL::IO::Pic::PDL_US
Truth table40%2/5
A or B or not(C) and D
A= $pdl->get_datatype >= $PDL::IO::Pic::PDL_LB= $pdl->get_datatype == $PDL::IO::Pic::PDL_SC= not $PDL::IO::Pic::converter{$format}{"ushortok"}D= $pdl->get_datatype == $PDL::IO::Pic::PDL_US
ABCDresult
1XXX1
01XX1
00111
000X0
00100
911 $pdl->get_datatype == $PDL_S ||
912 (!$converter{$format}->{ushortok} && $pdl->get_datatype == $PDL_US)) {
913 1 ▶ print "scaling data to type byte...\n" if $PDL::IO::Pic::debug;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug 1 0 1
914 1 $pdl = bytescl($pdl,-255);
915 }
916  
917 10 my @Dims = $pdl->dims;
918 10 ▶ my $isrgb = @Dims >= 3 && $Dims[0] == 3;
Condition66%2/3
@Dims >= 3 && $Dims[0] == 3
!ll&&!rl&&r
604
MC/DC50%1/2
@Dims >= 3 && $Dims[0] == 3
@Dims >= 3 $Dims[0] == 3
Truth table66%2/3
A && B
A= @Dims >= 3B= $Dims[0] == 3
ABresult
0X0
100
111
919 10 ▶ barf "expecting 2D or 3D-RGB-interlaced data as input"
Branch: 1 branch
BranchTrueFalseTotal
unless $isrgb or @Dims == 2 0 10 10
Condition66%2/3
$isrgb or @Dims == 2
l!l&&r!l&&!r
460
MC/DC0%0/2
$isrgb or @Dims == 2
$isrgb @Dims == 2
Truth table66%2/3
A or B
A= $isrgbB= @Dims == 2
ABresult
1X1
011
000
920 unless $isrgb || @Dims == 2;
921  
922 10 ▶ $$hints{'COLOR'} = "" unless defined($$hints{'COLOR'});
Branch: 1 branch
BranchTrueFalseTotal
unless defined $hints->{"COLOR"} 9 1 10
923 10 my $form = "";
924 10 ▶ if ($iform =~ /P[NP]M/) { # figure out the format from the data
Branch: 1 branch
BranchTrueFalseTotal
if ($iform =~ /P[NP]M/) 10 0 10
925 10 ▶ $form = 'PPM' if $isrgb;
Branch: 1 branch
BranchTrueFalseTotal
if $isrgb 4 6 10
926 10 ▶ $form = 'PGM' if (@Dims == 2) || ($$hints{'COLOR'} =~ /bwdither/i);
Branch: 1 branch
BranchTrueFalseTotal
if @Dims == 2 or $hints->{"COLOR"} =~ /bwdither/i 6 4 10
Condition66%2/3
@Dims == 2 or $hints->{"COLOR"} =~ /bwdither/i
l!l&&r!l&&!r
604
MC/DC50%1/2
@Dims == 2 or $hints->{"COLOR"} =~ /bwdither/i
@Dims == 2 $hints->{"COLOR"} =~ /bwdither/i
Truth table66%2/3
A or B
A= @Dims == 2B= $hints->{"COLOR"} =~ /bwdither/i
ABresult
1X1
011
000
927 10 ▶ $form = 'PBM' if ($$hints{'COLOR'} =~ /bw/i);
Branch: 1 branch
BranchTrueFalseTotal
if $hints->{"COLOR"} =~ /bw/i 1 9 10
928 10 $iform = $form; }
929 # this is the place for data conversions
930 10 ▶ if ($isrgb && ($iform =~ 'P[B,G]M')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($isrgb and $iform =~ /P[B,G]M/) 0 10 10
Condition66%2/3
$isrgb and $iform =~ /P[B,G]M/
!ll&&!rl&&r
640
MC/DC0%0/2
$isrgb and $iform =~ /P[B,G]M/
$isrgb $iform =~ /P[B,G]M/
Truth table66%2/3
A and B
A= $isrgbB= $iform =~ /P[B,G]M/
ABresult
0X0
100
111
931 0 print "wpic: converting to grayscale...\n";
932 0 $pdl = rgbtogr($pdl); # colour to grayscale
933 }
934 10 ▶ if (defined $$hints{LUT}) { # make LUT images into RGB
Branch: 1 branch
BranchTrueFalseTotal
if (defined $hints->{"LUT"}) 0 10 10
935 0 ▶ barf "luts only with non RGB data" if $isrgb;
Branch: 1 branch
BranchTrueFalseTotal
if $isrgb 0 0 0
936 0 ▶ print "starting palette->RGB conversion...\n" if $PDL::IO::Pic::debug;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug 0 0 0
937 0 $pdl = interlrgb($pdl,$$hints{LUT});
938 0 $iform = 'PPM'; # and tell everyone we are now RGB
939 0 ▶ print "finished conversion\n" if $PDL::IO::Pic::debug;
Branch: 1 branch
BranchTrueFalseTotal
if $PDL::IO::Pic::debug 0 0 0
940 }
941 10 return ($pdl, $iform);
942 }
943  
944 =head1 BUGS
945  
946 Currently only a random selection of converters/formats provided by
947 pbmplus/netpbm is supported. It is hoped that the more important formats
948 are covered. Other formats can be added as needed. Please send patches to
949 the author.
950  
951 =head1 AUTHOR
952  
953 Copyright (C) 1996,1997 Christian Soeller <c.soeller@auckland.ac.nz>
954 All rights reserved. There is no warranty. You are allowed
955 to redistribute this software / documentation under certain
956 conditions. For details, see the file COPYING in the PDL
957 distribution. If this file is separated from the PDL distribution,
958 the copyright notice should be included in the file.
959  
960 =cut
961  
962 14 1; # Return OK status
« blib/lib/Test/PDL.pm ↑ Summary blib/lib/PDL/Dbg.pm »