PDL::IO::Pnm
Pnm(m)         User Contributed Perl Documentation         Pnm(m)



NAME
       PDL::IO::Pnm -- pnm format I/O for PDL

SYNOPSIS
         use PDL::IO::Pnm;
         $im = wpnm $pdl, $file, $format[, $raw];
         rpnm $stack->slice(':,:,:,(0)'),"PDL.ppm";


DESCRIPTION
       pnm I/O for PDL.


FUNCTIONS
       rpnm

       Read a pnm (portable bitmap/pixmap, pbm/ppm) file into a
       piddle.

       Reads a file in pnm format (ascii or raw) into a pdl
       (magic numbers P1-P6).  Based on the input format it
       returns pdls with arrays of size (width,height) if binary
       or grey value data (pbm and pgm) or (3,width,height) if
       rgb data (ppm). This also means for a palette image that
       the distinction between an image and its lookup table is
       lost which can be a problem in cases (but can hardly be
       avoided when using netpbm/pbmplus).  Datatype is dependent
       on the maximum grey/color-component value (for raw and
       binary formats always PDL_B). rpnm tries to read chopped
       files by zero padding the missing data (well it currently
       doesn't, it barfs; I'll probably fix it when it becomes a
       problem for me ;). You can also read directly into an
       existing pdl that has to have the right size(!). This can
       come in handy when you want to read a sequence of images
       into a datacube.

       For details about the formats see appropriate manpages
       that come with the netpbm/pbmplus packages.

           $im = rpnm $file;

         $stack = zeroes(byte,3,500,300,4);
         rpnm $stack->slice(':,:,:,(0)'),"PDL.ppm";

       reads an rgb image (that had better be of size (500,300))
       into the first plane of a 3D RGB datacube (=4D pdl dat-
       acube). You can also do inplace transpose/inversion that
       way.

       wpnm

       Write a pnm (portable bitmap/pixmap, pbm/ppm) file into a
       file.

       Writes data in a pdl into pnm format (ascii or raw) (magic
       numbers P1-P6).  The $format is required (normally pro-
       duced by wpic) and routine just checks if data is compati-
       ble with that format. All conversions should already have
       been done. If possible, usage of wpic is preferred. Cur-
       rently RAW format is chosen if compliant with range of
       input data. Explicit control of ASCII/RAW is possible
       through the optional $raw argument. If RAW is set to zero
       it will enforce ASCII mode. Enforcing RAW is somewhat
       meaningless as the routine will always try to write RAW
       format if the data range allows (but maybe it should
       reduce to a RAW supported type when RAW == 'RAW'?). For
       details about the formats consult appropriate manpages
       that come with the netpbm/pbmplus packages.

           $im = wpnm $pdl, $file, $format[, $raw];


BUGS
       The stderr of the converters is redirected to a file. The
       filename is currently generated in a probably non-portable
       way. A method that avoids a file (and is portable) would
       be prefered.

       "rpnm" currently relies on the fact that the header is
       separated from the image data by a newline. This is not
       required by the p[bgp]m formats (in fact any whitespace is
       allowed) but most of the pnm writers seem to comply with
       that. Truncated files are currently treated ungracefully
       ("rpnm" just barfs).

AUTHOR
       Copyright (C) 1996,1997 Christian Soeller <c.soeller@auck-
       land.ac.nz> All rights reserved. There is no warranty. You
       are allowed to redistribute this software / documentation
       under certain conditions. For details, see the file COPY-
       ING in the PDL distribution. If this file is separated
       from the PDL distribution, the copyright notice should be
       included in the file.

FUNCTIONS
       pnminraw

         Signature: (type(); byte+ [o] im(m,n); int ms => m; int ns => n;
                               int isbin; char* fd)

       Read in a raw pnm file.

       read a raw pnm file. The "type" argument is only there to
       determine the type of the operation when creating "im" or
       trigger the appropriate type conversion (maybe we want a
       byte+ here so that "im" follows strictly the type of
       "type").

       pnminascii

         Signature: (type(); byte+ [o] im(m,n); int ms => m; int ns => n;
                               int format; char* fd)

       Read in an ascii pnm file.

       pnmout

         Signature: (a(a); int israw; int isbin; char *fd)

       Write a line of pnm data.

       This function is implemented this way so that threading
       works naturally.



perl v5.6.1                 2002-04-08                     Pnm(m)