Provided by: netpbm_11.07.00-2_amd64 bug

NAME

       netpbm - netpbm library overview

Overview Of Netpbm

       Netpbm is a package of graphics programs and a programming library.

        There  are  over 330 separate programs in the package, most of which have "pbm", "pgm", "ppm", "pam", or
       "pnm" in their names.  For example, pamscale(1) and giftopnm(1).

       For example, you might use pamscale to shrink an image by 10%.  Or use pamcomp to overlay  one  image  on
       top  of  another.  Or use pbmtext to create an image of text.  Or reduce the number of colors in an image
       with pnmquant.

       Netpbm  is  an  open  source  software  package,  distributed  via  the   Sourceforge    netpbm   project
       ⟨http://sourceforge.net/projects/netpbm⟩ .

Table Of Contents

       •

              Overview Of Netpbm ⟨#overview⟩

       •

              The Netpbm Formats ⟨#formats⟩

       •

              Implied Format Conversion ⟨#impconv⟩

       •

              Netpbm and Transparency ⟨#transparency⟩

       •

              The Netpbm Programs ⟨#programs⟩

       •

              Common Options ⟨#commonoptions⟩

       •

              Directory ⟨#directory⟩

       •

              How To Use The Programs ⟨#prognotes⟩

       •

              The Netpbm Library ⟨#libnetpbm⟩

       •

              netpbm-config ⟨#config⟩

       •

              Memory Usage ⟨#memoryusage⟩

       •

              CPU Usage ⟨#cpuusage⟩

       •

              Netpbm For Gimp ⟨#netpbmforgimp⟩

       •

              Companion Software ⟨#companion⟩

       •

              PHP-NetPBM ⟨#phpnetpbm⟩

       •

              Other Graphics Software ⟨#othersoftware⟩

       •

              Image Viewers ⟨#viewers⟩

       •

              Image Capturers ⟨#capturers⟩

       •

              Visual Graphics Software ⟨#visual⟩

       •

              Programming Tools ⟨#programmingtools⟩

       •

              Tools For Specific Graphics Formats ⟨#toolsforformats⟩

       •

              Document/Graphics Software ⟨#document⟩

       •

              Other ⟨#otherothersoftware⟩

       •

              Other Graphics Formats ⟨#otherfmt⟩

       •

              History ⟨#history⟩

       •

              Author ⟨#author⟩

The Netpbm Programs

       The  Netpbm  programs are generally useful run by a person from a command shell, but are also designed to
       be used by programs.  A common characteristic of Netpbm programs is that  they  are  simple,  fundamental
       building blocks.  They are most powerful when stacked in pipelines.  Netpbm programs do not use graphical
       user interfaces and do not seek input from a user.  The only programs that display graphics  at  all  are
       the very primitive display programs pamx and ppmsvgalib, and they don't do anything but that.

       Each of these programs has its own manual, as linked in the directory below.

       The  Netpbm  programs  can  read  and  write files greater than 2 GiB wherever the underlying system can.
       There may be exceptions where the programs use external libraries (The  JPEG  library,  etc.)  to  access
       files and the external library does not have large file capability.  Before Netpbm 10.15 (April 2003), no
       Netpbm program could read a file that large.

   Common Options
       There are a few options that are present on all programs that are based on the Netpbm library,  including
       virtually all Netpbm programs.  These are not mentioned in the individual manuals for the programs.

       You can use two hyphens instead of one on these options if you like.

       -quiet
               Suppress  all  informational  messages  that would otherwise be issued to Standard Error.  (To be
              precise, this only works to the  extent  that  the  program  in  question  implements  the  Netpbm
              convention  of  issuing  all  informational  messages  via  the pm_message() service of the Netpbm
              library).

       -version
              Instead of doing anything else, report the version  of  the  libnetpbm  library  linked  with  the
              program  (it may have been linked statically into the program, or dynamically linked at run time).
              Normally, the Netpbm programs and the library are installed at the same time, so  this  tells  you
              the version of the program and all the other Netpbm files it uses as well.

       -plain If  the program generates an image in PNM format, generate it in the "plain" (aka "ascii") version
              of the format, as opposed to the "raw" (aka "binary") version.

              Note that the other Netpbm format, PAM, does not have plain and raw versions, so this  option  has
              no effect on a program that generates PAM output.

              This  option  was  introduced  in  Netpbm 10.10 (October 2002).  From Netpbm 10.32 (February 2006)
              through Netpbm 10.62 (March 2013), the option is invalid with a program that generates PAM  output
              (instead of ignoring the option, the program fails).

   Directory
       Here is a complete list of all the Netpbm programs (with links to their manuals):

       Netpbm program directory(1)

   How To Use The Programs
       As  a collection of primitive tools, the power of Netpbm is multiplied by the power of all the other unix
       tools you can use with them.  These notes remind you of some of the more useful ways to do this.   Often,
       when people want to add high level functions to the Netpbm tools, they have overlooked some existing tool
       that, in combination with Netpbm, already does it.

       Often, you need to apply some conversion or edit to a whole bunch of files.

       As a rule, Netpbm programs take one input file and produce one output file, usually on  Standard  Output.
       This is for flexibility, since you so often have to pipeline many tools together.

       Here  is an example of a shell command to convert all your of PNG files (named *.png) to JPEG files named
       *.jpg:
       for i in *.png; do pngtopam $i | ppmtojpeg >`basename $i .png`.jpg; done

       Or you might just generate a stream of individual shell commands, one per file, with awk or perl.  Here's
       how to brighten 30 YUV images that make up one second of a movie, keeping the images in the same files:

       ls *.yuv
          | perl -ne 'chomp;
          print yuvtoppm $_ | pambrighten -value +100 | ppmtoyuv >tmp$$.yuv;
          mv tmp$$.yuv $_
          '
          | sh

       The  tools  find  (with  the -exec option) and xargs are also useful for simple manipulation of groups of
       files.

       Some shells' "process substitution" facility can help where a non-Netpbm program expects you to  identify
       a  disk  file for input and you want it to use the result of a Netpbm manipulation.  Say the hypothetical
       program printcmyk takes the filename of a Tiff CMYK file as input  and  what  you  have  is  a  PNG  file
       abc.png.

       Try:
       printcmyk <({ pngtopam abc.png | pnmtotiffcmyk ; })

       It  works  in  the other direction too, if you have a program that makes you name its output file and you
       want the output to go through a Netpbm tool.

The Netpbm Formats

       All of the programs work with a set of graphics formats called the "netpbm" formats.  Specifically, these
       formats are pbm(1), pgm(1), ppm(1), and pam(1).

       The first three of these are sometimes known generically as "pnm".

       Many of the Netpbm programs convert from a Netpbm format to another format or vice versa.  This is so you
       can use the Netpbm programs to work on graphics of any format.  It is also common to use a combination of
       Netpbm  programs  to  convert  from  one  non-Netpbm  format  to  another  non-Netpbm format.  Netpbm has
       converters for about 100 graphics formats, and as a package Netpbm  lets  you  do  more  graphics  format
       conversions than any other computer graphics facility.

       The Netpbm formats are all raster formats, i.e. they describe an image as a matrix of rows and columns of
       pixels.  In the PBM format, the pixels are black and white.  In the PGM  format,  pixels  are  shades  of
       gray.   In  the  PPM  format,  the  pixels  are  in full color.  The PAM format is more sophisticated.  A
       replacement for all three of the other formats, it can represent matrices of general data  including  but
       not limited to black and white, grayscale, and color images.

       Programs designed to work with PBM images have "pbm" in their names.  Programs designed to work with PGM,
       PPM, and PAM images similarly have "pgm", "ppm", and "pam" in their names.

       All Netpbm programs designed to read PGM images see PBM images as if  they  were  PGM  too.   All  Netpbm
       programs designed to read PPM images see PGM and PBM images as if they were PPM.  See
        Implied Format Conversion ⟨#impconv⟩ .

        Programs  that  have  "pnm"  in  their  names  read  PBM,  PGM,  and PPM but unlike "ppm" programs, they
       distinguish between those formats and their function depends on the  format.   For  example,  pnmtopng(1)
       creates  a  black  and white PNG output image if its input is PBM or PGM, but a color PNG output image if
       its input is PPM.  And pnmrotate  produces  an  output  image  of  the  same  format  as  the  input.   A
       hypothetical ppmrotate program would also read all three PNM input formats, but would see them all as PPM
       and would always generate PPM output.

       Programs that have "pam" in their names read all the Netpbm  formats:  PBM,  PGM,  PPM,  and  PAM.   They
       sometimes  treat  them  all as if they are PAM, using an implied conversion, but often they recognize the
       individual formats and behave accordingly, like a "pnm" program  does.   See  Implied  Format  Conversion
       ⟨#impconv⟩ .

       Finally,  there  are  subformats of PAM that are equivalent to PBM, PGM, and PPM respectively, and Netpbm
       programs designed to read PBM, PGM, and/or PPM see those PAM images as if  they  were  the  former.   For
       example, ppmhist can analyze a PAM image of tuple type RGB (i.e. a color image) as if it were PPM.

        If  it  seems  wasteful  to  you to have three separate PNM formats, be aware that there is a historical
       reason for it.  In the beginning, there were only PBMs.  PGMs came later, and then PPMs.  Much later came
       PAM, which realizes the possibility of having just one aggregate format.

       The formats are described in the specifications of pbm(1), pgm(1), ppm(1), and pam(1).

   Implied Format Conversion
       A  program  that  uses the PGM library subroutines to read an image can read a PBM image as well as a PGM
       image.  The program sees the PBM image as if it were the equivalent PGM image,  with  a  maxval  of  255.
       note:  This  sometimes confuses people who are looking at the formats at a lower layer than they ought to
       be because a zero value in a PBM raster means white, while a zero value in a PGM raster means black.

       A program that uses the PPM library subroutines to read an image can read a PGM image as well  as  a  PPM
       image  and  a  PBM image as well as a PGM image.  The program sees the PBM or PGM image as if it were the
       equivalent PPM image, with a maxval of 255 in the PBM case and the same maxval as  the  PGM  in  the  PGM
       case.

       A  program  that  uses  the PAM library subroutines to read an image can read a PBM, PGM, or PPM image as
       well as a PAM image.  The program sees a PBM image as if it were the equivalent PAM image with tuple type
       BLACKANDWHITE.  It sees a PGM image as if it were the equivalent PAM image with tuple type GRAYSCALE.  It
       sees a PPM image as if it were the equivalent PAM image with tuple type RGB.  But  the  program  actually
       can  see  deeper  if  it  wants  to.   It  can  tell  exactly  which format the input was and may respond
       accordingly.  For example, a PAM program typically produces output in the same format as its input.

       A program that uses the PGM library subroutines to read an image can read a  PAM  image  as  well  a  PGM
       image,  if  the PAM is a grayscale or black and white visual image.  That canonically means the PAM has a
       depth of 1 and a tuple type of GRAYSCALE or BLACKANDWHITE, but most Netpbm programs  are  fairly  liberal
       and will take any PAM at all, ignoring all but the first plane.

       There  is a similar implied conversion for PPM library subroutines reading PAM.  There is nothing similar
       for PBM, so if you need for a PBM program to read a PAM image, run it through pamtopnm.

   Netpbm and Transparency
       In many graphics formats, there's a means of indicating that certain parts of the  image  are  wholly  or
       partially transparent, meaning that if it were displayed "over" another image, the other image would show
       through there.  Netpbm formats deliberately omit that capability, since their purpose is to be  extremely
       simple.

       In  Netpbm, you handle transparency via a transparency mask in a separate (slightly redefined) PGM image.
       In this pseudo-PGM, what would normally be a pixel's intensity  is  instead  an  opaqueness  value.   See
       pgm(1).  pamcomp(1) is an example of a program that uses a PGM transparency mask.

       Another  means  of  representing  transparency  information  has  recently developed in Netpbm, using PAM
       images.  In spite of the argument  given  above  that  Netpbm  formats  should  be  too  simple  to  have
       transparency  information  built  in,  it  turns  out  to  be extremely inconvenient to have to carry the
       transparency information around separately.  This is primarily because Unix  shells  don't  provide  easy
       ways  to  have  networks of pipelines.  You get one input and one output from each program in a pipeline.
       So you'd like to have both the color information and the transparency information for  an  image  in  the
       same pipe at the same time.

       For  that  reason,  some  new (and recently renovated) Netpbm programs recognize and generate a PAM image
       with tuple type RGB_ALPHA or GRAYSCALE_ALPHA, which contains a plane for  the  transparency  information.
       See the PAM specification(1).

The Netpbm Library

       The  Netpbm  programming  library,  libnetpbm(1), makes it easy to write programs that manipulate graphic
       images.  Its main function is to read and write files in the  Netpbm  formats,  and  because  the  Netpbm
       package  contains  converters  for all the popular graphics formats, if your program reads and writes the
       Netpbm formats, you can use it with any formats.

       But the library also contain some utility functions, such as character drawing and RGB/YCrCb conversion.

       The library has the conventional C linkage.  Virtually all programs in the Netpbm package  are  based  on
       the Netpbm library.

netpbm-config

       In  a  standard  installation  of  Netpbm,  there is a program named netpbm-config in the regular program
       search path.  We don't consider this a Netpbm program  --  it's  just  an  ancillary  part  of  a  Netpbm
       installation.   This  program  tells you information about the Netpbm installation, and is intended to be
       run by other programs that interface with Netpbm.  In fact, netpbm-config is really a configuration file,
       like those you typically see in the /etc/ directory of a Unix system.

       Example:
           $netpbm-config --datadir
           /usr/local/netpbm/data

       If  you  write a program that needs to access a Netpbm data file, it can use such a shell command to find
       out where the Netpbm data files are.

       netpbm-config is the only file that must be installed in a standard directory (it must be in a  directory
       that  is  in  the default program search path).  You can use netpbm-config as a bootstrap to find all the
       other Netpbm files.

       There is no detailed documentation of netpbm-config.  If you're in a position to use it, you should  have
       no trouble reading the file itself to figure out how to use it.

Memory Usage

       An  important  characteristic  that  varies  among graphics software is how much memory it uses, and how.
       Does it read an entire image into memory, work on it there, then write it out all at once?  Does it  read
       one  and  write  one  pixel at a time?  In Netpbm, it differs from one program to the next, but there are
       some generalizations we can make.

       Most Netpbm programs keep one row of pixels at a time in memory.  Such a program  reads  a  row  from  an
       input  file,  processes  it,  then writes a row to an output file.  Some programs execute algorithms that
       can't work like that, so they keep a small window of rows in memory.  Others must keep the  entire  image
       in memory.  If you think of what job the program does, you can probably guess which one it does.

       When  Netpbm  keeps  a  pixel in memory, it normally uses a lot more space for it than it occupies in the
       Netpbm image file format.

       The older programs (most of Netpbm) use 12 bytes per pixel.  This is true even for a PBM image, for which
       it  only  really  takes  one  bit  to  totally  describe  the  pixel.  Netpbm does this expansion to make
       implementing the programs easier -- it uses the same format regardless of the type of image.

       Newer programs use the  "pam"  family  of  library  functions  internally,  which  use  memory  a  little
       differently.  These functions are designed to handle generic tuples with a variable numbers of planes, so
       no fixed size per-tuple storage is possible.  A program of this type uses 4 bytes per sample (a tuple  is
       composed  of samples), plus a pointer (4-8 bytes) per tuple.  In a graphic image, a tuple is a pixel.  So
       an ordinary color image takes 16-20 bytes per pixel.

       When considering memory usage, it is important to remember that memory and disk storage are equivalent in
       two ways:

       •      Memory is often virtual, backed by swap space on disk storage.  So accessing memory may mean doing
              disk I/O.

       •      Files are usually cached and buffered, so that accessing a  disk  file  may  just  mean  accessing
              memory.

       This means that the consequences of whether a program works from the image file or from a memory copy are
       not straightforward.

       Note that an image takes a lot less space in a Netpbm format file, and therefore in an operating system's
       file  cache,  than  in Netpbm's in-memory format.  In non-Netpbm image formats, the data is even smaller.
       So reading through an input file multiple times instead of keeping a copy in regular memory  can  be  the
       best  use  of memory, and many Netpbm programs do that.  But some files can't be read multiple times.  In
       particular, you can't rewind and re-read a pipe, and a pipe is often the  input  for  a  Netpbm  program.
       Netpbm programs that re-read files detect such input files and read them into a temporary file, then read
       that temporary file multiple times.

       A few Netpbm programs use an in-memory format that is just one bit per pixel.  These  are  programs  that
       convert  between  PBM and a format that has a raster format very much like PBM's.  In this case, it would
       actually make the program more complicated (in addition to much slower) to use Netpbm's generic  12  byte
       or 8 byte pixel representation.

       By the way, the old axiom that memory is way faster than disk is not necessarily true.  On small systems,
       it typically is true, but on a system with a large network of disks,  especially  with  striping,  it  is
       quite easy for the disk storage to be capable of supplying data faster than the CPU can use it.

CPU Usage

       People  sometimes wonder what CPU facilities Netpbm programs and the Netpbm programming library use.  The
       programs never depend on particular features existing (assuming they're compiled properly), but the speed
       and cost of running a program varies depending upon the CPU features.

       Note  that  when  you download a binary that someone else compiled, even though it appears to be compiled
       properly for your machine, it may be compiled improperly for that machine  if  it  is  old,  because  the
       person  who  compiled  it may have chosen to exploit features of newer CPUs in the line.  For example, an
       x86 program may be compiled to use instructions that are present on an 80486, but not on an  80386.   You
       would probably not know this until you run the program and it crashes.

       But  the default build options almost always build binaries that are as backward compatible with old CPUs
       as possible.  An exception is a build for a 64 bit x86 CPU.  While the builder could build a program that
       runs  on a 32 bit x86, it does not do so by default.  A default build builds a program will not run on an
       older 32-bit-only x86 CPU.

       One common build option is to use MMX/SSE operands with x86 CPUs.  Those are not available on  older  x86
       CPUs.  The builder by default does not generate code that uses MMX/SSE when building for 32 bit x86 CPUs,
       but does when building for 64 bit x86.

       One area of particular importance is floating point arithmetic.  The Netpbm image formats  are  based  on
       integers,  and Netpbm arithmetic is done with integers where possible.  But there is one significant area
       that is floating point: programs that must deal with light intensity.  The Netpbm  formats  use  integers
       that  are  proportional  to  brightness, and brightness is exponentially related to light intensity.  The
       programs have to keep the intermediate intensity values in floating point in order not to lose precision.
       And the conversion (gamma function) between the two is heavy-duty floating point arithmetic.

       Programs  that  mix  pixels  together  have  to combine light intensity, so they do heavy floating point.
       Three of the most popular Netpbm programs do  that:  pamscale(1)  (shrink/expand  an  image),  pamcomp(1)
       (overlay an image over another one), and pamditherbw(1) (Make a black and white image that approximates a
       grayscale image).

       The Netpbm image formats use 16 bit integers.  The Netpbm code uses "unsigned int" size integers to  work
       with them.

Netpbm For Gimp

       The  Gimp  is  a visual image editor for Unix and X, so it does the kinds of things that Netpbm does, but
       interactively in a user-friendly way.  The Gimp knows a  variety  of  graphics  file  formats  and  image
       transformations, but you can extend it with plugins.

       A  particularly easy way to write a Gimp plugin is to write a Netpbm program (remember that a fundamental
       mission  of  Netpbm  is  make  writing  image  manipulation  programs  easy)  and  then  use  netpbm2gimp
       http://netpbm2gimp.sourceforge.net/  to compile that same source code into a Gimp plugin.

       You  can  turn  a  program that converts from a certain graphics file format to Netpbm format into a Gimp
       load plugin.  Likewise, you can turn a program that converts to a certain  graphics  format  from  Netpbm
       format into a Gimp store plugin.  Finally, a program that transforms images in Netpbm format can become a
       process plugin.

       And the netpbm2gimp project has already packaged for you a few hundred of the  Netpbm  programs  as  Gimp
       plugins.   With  this  package  you  can,  for  example, edit an image in any of the arcane graphics file
       formats that Netpbm understands but no other image editor in existence does.

Companion Software

   PHP-NetPBM
       If you're using Netpbm to do graphics for a website, you can  invoke  the  Netpbm  programs  from  a  PHP
       script.   To  make this even easier, check out PHP-NetPBM ⟨http://sourceforge.net/projects/phpnetpbm⟩ , a
       PHP class that interacts with Netpbm.  Its main goal is to decrease the pain of using Netpbm when working
       with images in various formats.  It includes macro commands to perform manipulations on many files.

       I  can't  actually recommend PHP-NetPBM.  I spent some time staring at it and was unable to make sense of
       it.  Some documentation is in fractured English and other is in an unusual  character  set.   But  a  PHP
       expert might be able to figure it out and get some use out of it.

Other Graphics Software

       Netpbm contains primitive building blocks.  It certainly is not a complete graphics software library.

   Command Line Programs
       ImageMagick  does  many  of  the same things - mainly the more popular ones - that Netpbm does, including
       conversion between popular formats and basic editing.  convert, mogrify, montage, and animate are popular
       programs  from  the  ImageMagick  package.  ImageMagick runs on Unix, Windows, Windows NT, Macintosh, and
       VMS.

       ImageMagick also contains the program display, which is a viewer ⟨#viewers⟩  and visual editor  ⟨#visual⟩
       .

   Image Viewers
       The  first thing you will want to make use of any of these tools is a viewer.  (On GNU/Linux, you can use
       Netpbm's pamx or ppmsvgalib in a pinch, but it is pretty limiting).  zgv is a good full service viewer to
       use  on  a  GNU/Linux  system  with  the  SVGALIB  graphics  display driver library.  You can find zgv at
       ftp://ftp.ibiblio.org/pub/Linux/apps/graphics/viewers/svga
       ftp://ftp.ibiblio.org/pub/Linux/apps/graphics/viewers/svga .

       zgv  even  has  a  feature  in  it wherein you can visually crop an image and write an output file of the
       cropped image using pamcut(1).

       See the -s option to zgv.

       For the X inclined, there is also xzgv.

       xwud (X Window Undump) is a classic application program in the X Window System that displays an image  in
       an  X  window.   It  takes the special X Window Dump format as input; you can use Netpbm's pnmtoxwd(1) to
       create it.  You're probably better off just using Netpbm's pamx(1).

       xloadimage and its extension xli are also common ways to display a graphic image in X.

       gqview is a more modern X-based image viewer.

       qiv is a small, very fast viewer for X.

       To   play   mpeg   movies,   such   as    produced    by    ppmtompeg,    try    mplayer(1)    or    xine
       http://sourceforge.net/projects/xine .

       See                                               ftp://metalab.unc.edu/pub/Linux/apps/graphics/viewers/X
       ftp://metalab.unc.edu/pub/Linux/apps/graphics/viewers/X .

   Image Capturers
       xwd (X Window Dump), a classic application program in the X Window System, captures the contents of an  X
       window,  in its own special image format, called X Window Dump File.  You can use Netpbm's xwdtopnm(1) to
       turn it into something more useful.

       fbdumphttp://www.rcdrummond.net/fbdump/⟩  Capturers the current contents of  a  video  display  on  the
       local computer and generates a PPM image of it.  It works with Linux framebuffer devices.

   Visual Graphics Software
       Visual  graphics  software is modern point-and-click software that displays an image and lets you work on
       it and see the results as you go.  This is fundamentally different from what Netpbm programs do.

       xv is a very old and very popular simple image editor in the Unix world.  It does not have  much  in  the
       way of current support, or maintenance, though.

       Gimp  is a visual image editor for Unix and the X Window System, in the same category as the more famous,
       less capable, and much more  expensive  Adobe  Photoshop,  etc.  for  Windows.   See  http://www.gimp.org
       http://www.gimp.org  .   And  you  can  add  most  of  Netpbm's  function  to  Gimp  using  Netpbm2gimp
       ⟨http://netpbm2gimp.sourceforge.net/⟩ .

       ImageMagick contains the program display, which is another visual image editor.  It has  fewer  functions
       than   Gimp.   This  program  uses  the  X  Window  System.   The  package  also  contains  command  line
       ⟨#othercmdline⟩  graphics programs.

       Electric Eyes, kuickshow, and gthumb are also visual editors for  the  X/Window  system,  and  KView  and
       gwenview are specifically for KDE.

   Programming Tools
       If    you're   writing   a   program   in   C   to   draw   and   manipulate   images,   check   out   gd
       ⟨https://github.com/libgd/libgd⟩ .  Netpbm contains a C library for drawing  images  (libnetpbm's  "ppmd"
       routines), but it is not as capable or documented as gd.  There are wrapper libraries available for Perl,
       PHP, and other language.

       You can easily run any Netpbm program from a C program  with  the  pm_system  function  from  the  Netpbm
       programming library, but that is less efficient than gd functions that do the same thing.

       Cairo ⟨http://cairographics.org/⟩  is similar.

       Ilib  is  a  C subroutine library with functions for adding text to an image (as you might do at a higher
       level with pbmtext, pamcomp, etc.).   It  works  with  Netpbm  input  and  output.   Find  it  at  k5n.us
       http://www.k5n.us/Ilib.php  .   Netpbm  also  includes  character drawing functions in the libnetpbm(1)
       library, but they do not have as fancy font capabilities (see ppmdraw(1) for an example  of  use  of  the
       Netpbm character drawing functions).

       Pango   ⟨http://www.pango.org/⟩      is   another   text   rendering   library,   with   an  emphasis  on
       internationalization.

       Pango and Cairo complement each other and work well together.

       GD is a library of graphics routines that is part of PHP.  It has a subset of Netpbm's functions and  has
       been found to resize images more slowly and with less quality.

   Tools For Specific Graphics Formats
       mencode,  which  is  part of the mplayer(1) package, creates movie files.  It's like a much more advanced
       version of ppmtompeg(1), without the Netpbm building block simplicity.

       MJPEGToolshttp://mjpeg.sourceforge.net⟩  is software for dealing with the MJPEG movie format.

       To create an animated GIF, or extract a frame from one, use gifsicle.  gifsicle converts between animated
       GIF  and still GIF, and you can use pamtogif and giftopnm to connect up to all the Netpbm utilities.  See
       http://www.lcdf.org/gifsicle http://www.lcdf.org/gifsicle .

       To convert an image of text to text (optical character recognition - OCR), use gocr (think of  it  as  an
       inverse of pbmtext).  See http://jocr.sourceforge.net/ http://jocr.sourceforge.net/ .

         http://schaik.com/pngsuite  http://schaik.com/pngsuite  contains a PNG test suite -- a whole bunch of
       PNG images exploiting the various features of the PNG format.

       Other versions of Netpbm's pnmtopng/pngtopam are at  http://www.schaik.com/png/pnmtopng.html" (1).

       The version in Netpbm was actually based on that package a long time ago, and  you  can  expect  to  find
       better  exploitation  of  the  PNG  format, especially recent enhancements, in that package.  It may be a
       little less consistent with the Netpbm project and less exploitive of recent Netpbm format  enhancements,
       though.

         pngwriter  http://pngwriter.sourceforge.net   is a C++ library for creating PNG images.  With it, you
       plot an image pixel by pixel.  You can also render text with the FreeType2 library.

       jpegtran Does some of the same transformations as Netpbm is famous for, but  does  them  specifically  on
       JPEG  files and does them without loss of information.  By contrast, if you were to use Netpbm, you would
       first decompress the JPEG image to Netpbm format, then transform the image, then compress it back to JPEG
       format.   In that recompression, you lose a little image information because JPEG is a lossy compression.
       Of course, only a few kinds of lossless transformation are possible.  jpegtran comes with the Independent
       JPEG Group's ( http://www.ijg.org) ⟨http://www.ijg.org⟩  JPEG library.

        Some tools to deal with EXIF files (see also Netpbm's jpegtopnm(1) and pnmtojpeg(1)):

       To   dump   (interpret)   an  EXIF  header:  Exifdump  ((  http://www.math.u-psud.fr/~bousch/exifdump.py)
       ⟨http://www.math.u-psud.fr/~bousch/exifdump.py⟩ ) or Jhead ⟨http://www.sentex.net/~mwandel/jhead⟩ .

       A Python EXIF library and dumper: http://pyexif.sourceforge.net.  ⟨http://pyexif.sourceforge.net.⟩

       Here's  some  software  to  work  with   IOCA   (Image   Object   Content   Architecture):   ImageToolbox
       ⟨http://www.forminnovation.com⟩    ($2500,  demo available).  This can convert from TIFF -> IOCA and back
       again.

       Ameri-Imager ⟨https://ameri-imager.software.informer.com/⟩  is an image and video editor.   ($40  Windows
       only).

       pnm2ppa  converts  to  HP's  "Winprinter"  format (for HP 710, 720, 820, 1000, etc).  It is a superset of
       Netpbm's pbmtoppa  and handles, notably, color.  However, it is more of a printer driver than  a  Netpbm-
       style    primitive    graphics    building    block.     See    The    Pnm2ppa    /Sourceforge    Project
       ⟨http://sourceforge.net/projects/pnm2ppaDjVuLibre is a package of software for using the DjVu format.   It  includes  viewers,  browser  plugins,
       decoders,  simple  encoders,  and utilities.  The encoders and decoders can convert between DjVu and PNM.
       See
        the DjVu website.  ⟨http://djvu.sourceforge.net/Document/Graphics Software
       There is a large class of software that does  document  processing,  and  that  is  somewhat  related  to
       graphics  because  documents  contain  graphics  and  a page of a document is for many purposes a graphic
       image.  Because of this slight intersection with graphics, I  cover  document  processing  software  here
       briefly, but it is for the most part beyond the scope of this document.

       First,  we  look  at where Netpbm meets document processing.  pstopnm converts from Postscript and PDF to
       PNM.  It effectively renders the document into images  of  printed  pages.   pstopnm  is  nothing  but  a
       convenient wrapper for Ghostscript ⟨http://www.ghostscript.com/⟩ , and in particular Netpbm-format device
       drivers that are part of it.  pnmtops and pbmtoepsi convert a PNM  image  to  a  Postscript  program  for
       printing the image.  But to really use PDF and Postscript files, you generally need more complex document
       processing software.

       Adobe invented Postscript and PDF and products from  Adobe  are  for  many  purposes  the  quintessential
       Postscript and PDF tools.

       Adobe's  free  Acrobat Reader displays PDF and converts to Postscript.  The Acrobat Reader for unix has a
       program name of "acroread" and the -toPostScript option (also see the -level2 option) is useful.

       Other software from Adobe, available for purchase, interprets  and  creates  Postscript  and  PDF  files.
       "Distill" is a program that converts Postscript to PDF.

       xpdfhttp://www.foolabs.com/xpdf/⟩  also reads PDF files.

       GSview, ghostview, gv, ggv, and kghostview are some other viewers for Postscript and PDF files.

       The program ps2pdf, part of Ghostscript, converts from Postscript to PDF.

       bmpp(1) converts from Netpbm and other formats to PDF.

       Two  packages  that  produce  more  kinds  of Encapsulated Postscript than the Netpbm programs, including
       compressed kinds, are bmpp(1) and imgtops ⟨http://imgtops.sourceforge.net/⟩ .

       dvips converts from DVI format to Postscript.  DVI is the format that Tex produces.  Netpbm  can  convert
       from  Postscript  to  PNM.   Thus,  you  can  use  these  in combination to work with Tex/Latex documents
       graphically.

       wvwarehttp://wvware.sourceforge.net⟩  converts a Microsoft Word document (.doc file) to  various  other
       formats.  While the web page doesn't seem to mention it, it reportedly can extract an embedded image in a
       Word document as a PNG.

       Document Printer ⟨http://www.verypdf.com/artprint⟩  converts various print  document  formats  (Microsoft
       Word, PDF, HTML, etc.)  to various graphic image formats.  ($38, Windows only).

       Latex2html  converts  Latex document source to HTML document source.  Part of that involves graphics, and
       Latex2html uses Netpbm tools for some of that.  But Latex2html through its history has  had  some  rather
       esoteric   codependencies   with   Netpbm.    Older   Latex2html   doesn't   work  with  current  Netpbm.
       Latex2html-99.2beta8 works, though.

   Other
       The file program looks at a file and tells you what kind of file  it  is.   It  recognizes  most  of  the
       graphics  formats with which Netpbm deals, so it is pretty handy for graphics work.  Netpbm's anytopnm(1)
       program depends on file.  See ftp://ftp.astron.com/pub/file ftp://ftp.astron.com/pub/file .

       The Utah Raster Toolkit from the Geometric Design And Computation group in  the  Department  of  Computer
       Science  at  University  of  Utah serves a lot of the same purpose as Netpbm, but without the emphasis on
       format conversions.  This package is based on the RLE format, which you  can  convert  to  and  from  the
       Netpbm formats.

       Ivtools  is  a  suite  of  free  X  Window  System  drawing editors for Postscript, Tex, and web graphics
       production, as well as an embeddable and extendable vector graphic shell.  It uses the Netpbm facilities.
       See http://www.ivtools.org http://www.ivtools.org .

       Chisato  Yamauchi  <cyamauch@ir.isas.jaxa.jp>  has written a free c/Fortran graphic library: EGGX/ProCall
       ⟨http://www.ir.isas.jaxa.jp/~cyamauch/eggx_procall/⟩ .  He says he tried to write the  ultimate  easy-to-
       use  graphic  kit  for  X.   It  is  for drawing upon an X11 window, but for storage, it outputs PPM.  He
       suggests Netpbm to convert to other formats.

       The program morph morphs one image into another.  It uses Targa format images, but you can  use  tgatoppm
       and  ppmtotga  to  deal with that format.  You have to use the graphical (X/Tk) Xmorph to create the mesh
       files   that   you   must   feed   to   morph.    morph   is   part   of   the   Xmorph   package.    See
       http://xmorph.sourceforge.net/ http://xmorph.sourceforge.net/ .

Other Graphics Formats

       People never seem to tire of inventing new graphics formats, often completely redundant with pre-existing
       ones.  Netpbm cannot keep up with them.  Here is a list of a few that we  know  Netpbm  does  not  handle
       (yet).

       Various  commercial  Windows  software handles dozens of formats that Netpbm does not, especially formats
       typically used with Windows programs.  ImageMagick is probably the most used free image format  converter
       and it also handles lots of formats Netpbm does not.

       •      WebP  was announced by Google in October 2010 as a more compressed replacement for JFIF (aka JPEG)
              on the web.

       •      JPEG-LS is similar to JFIF  (aka  JPEG)  except  that  it  is  capable  of  representing  all  the
              information  in  any  raster  image,  so  you  could  convert  from,  say, PNM, without losing any
              information.  CharLS is a programming library for JPEG-LS.

       •      Lossless JPEG is a similarly lossless variation of JPEG.  It predates every  other  lossless  JPEG
              variation, but had only brief interest.  You can find code for encoding and decoding Lossless JPEG
              on GitHub ⟨https://github.com/thorfdbg/libjpeg⟩ .

       •      JPEG XR offers greater dynamic range, a wider range of colors, and more efficient compression than
              JFIF  (aka  JPEG).   Windows and Internet Explorer understand this format, starting with Windows 7
              and Internet Explorer 9, along with many other programs.  This  format  was  previously  known  as
              Windows Media Photo and HD Photo.

       •      Direct  Draw  Surface  (DDS)is the de facto standard wrapper format for S3 texture compression, as
              used in all modern realtime graphics applications.  Besides Windows-based tools, there is  a  Gimp
              plugin for this format.

       •      DjVu  is  a  web-centric  format  and  software  platform  for  distributing documents and images.
              Promoters say it is a good replacement for PDF, PS, TIFF, JFIF(JPEG),  and  GIF  for  distributing
              scanned  documents,  digital  documents, or high-resolution pictures, because it downloads faster,
              displays and renders faster, looks nicer on a screen, and  consumes  less  client  resources  than
              competing formats.

              For more information, see
               the DjVu website.  ⟨http://djvu.sourceforge.net/⟩

       •

              VRML (Virtual Reality Modelling Language) ⟨http://www.web3d.org/x3d/specifications/vrml⟩

       •

              CALS  (originated  by  US  Department Of Defense, favored by architects).  It is described in this
              1997 listing of graphics formats:
               http://www.faqs.org/faqs/graphics/fileformats-faq/part3/http://www.faqs.org/faqs/graphics/fileformats-faq/part3/⟩   .    CALS   has   at  times  been  an
              abbreviation of various things, all of which  appear  to  be  essentially  the  same  format,  but
              possibly slightly different:

       •      Computer Aided Logistics Support

       •      Computer Aided Acquisition and Logistics Support

       •      Continuous Acquisition and Life-cycle Support

       •      Commerce At Light Speed

              The    US    Navy    publishes    specs    ⟨https://www.navsea.navy.mil/Home/Warfare-Centers/NSWC-
              Carderock/Resources/Technical-Information-Systems/IETMs/Specifications-Standards/CALS-Standards/⟩
              for it.

       •

              array formats dx, general, netcdf, CDF, hdf, cm

       •

              CGM+

       •      HDR formats OpenEXR, SGI TIFF LogLuv, floating point TIFF, Radiance RGBE

       •      Windows Meta File (.WMF).  Libwmf converts from WMF to things like Latex, PDF, PNG.  Some of these
              can be input to Netpbm.

       •      Microsoft Word .doc format.  Microsoft keeps a proprietary hold on this format.  Any software  you
              see that can handle it is likely to cost money.

       •      RTF

       •

              DXF (AutoCAD)

       •

              IOCA (Image Object Content Architecture) The specification of this format is documented by IBM:
               Data   Stream   and   Object   Architectures:   Image   Object   Content  Architecture  Reference
              ⟨http://publibz.boulder.ibm.com/epubs/pdf/c3168055.pdf⟩ .  See above for software  that  processes
              this format.

       •      OpenEXR is an HDR format (like PFM(1)).  See
               http://www.openexr.comhttp://www.openexr.com⟩ .

       •      Xv  Visual  Schnauzer thumbnail image.  This is a rather antiquated format used by the Xv program.
              In Netpbm circles, it is best known for the fact that it is very similar  to  Netpbm  formats  and
              uses  the  same  signature  ("P7") as PAM because it was developed as sort of a fork of the Netpbm
              format specifications.

       •      YUV 4:2:0, aka YUV 420, and the similar YUV 4:4:4, YUV 4:2:2,  YUV  4:1:1,  YUV  4:1:1s,  and  YUV
              4:1:0.  Video systems often use this.

       •

              MJPEG ⟨http://en.wikipedia.org/wiki/MJPEG⟩  movie format.

       •      YUV4MPEG2  is  a  movie  format  whose  purpose is similar to that of the Netpbm formats for still
              images.  You use it for manipulating movies, but not for storing or transmitting them.   The  only
              known use of the format is with MJPEGToolshttp://mjpeg.sourceforge.net⟩ .  The programs pnmtoy4m
              and y4mtopnm (and predecessors ppmtoy4m and y4mtoppm) in that package  convert  between  a  Netpbm
              stream  and  a  YUV4MPEG2  stream.   As  you  might  guess  from  the  name,  YUV4MPEG2 uses a YUV
              representation of data, which is more convenient than the Netpbm formats' RGB  representation  for
              working with data that is ultimately MPEG2.

History

       Netpbm  has  a  long  history, starting with Jef Poskanzer's Pbmplus package in 1988.  See the Netpbm web
       site(1) for details.

       The file doc/HISTORY in the Netpbm source code contains a detailed change history release by release.

Author

       Netpbm is based on the Pbmplus package by Jef Poskanzer, first distributed in 1988 and maintained by  him
       until  1991.   But the package contains work by countless other authors, added since Jef's original work.
       In fact, the name is derived from the fact that the work was contributed by people all over the world via
       the Internet, when such collaboration was still novel enough to merit naming the package after it.

       Bryan  Henderson  has been maintaining Netpbm since 1999.  In addition to packaging work by others, Bryan
       has also written a significant amount of new material for the package.

DOCUMENT SOURCE

       This manual page was generated by the Netpbm tool 'makeman' from HTML source.  The  master  documentation
       is at

              http://netpbm.sourceforge.net/doc/index.html