Community hub
Recent from talks
Contribute something
Nothing was collected or created yet.
Netpbm
View on Wikipedia| Netpbm | |
|---|---|
| Developers | Jef Poskanzer, Bryan Henderson, Akira F Urushibata[1] |
| Initial release | 1988 |
| Stable release | 11.02.16 
/ 30 April 2025 |
| Repository | |
| Written in | C, Perl, Unix Shell |
| Operating system | Cross-platform |
| License | Various, see below |
| Website | netpbm |
Netpbm (formerly Pbmplus) is an open-source package of graphics programs and a programming library. It is used primarily in Unix, where it is found in all major open-source operating system distributions, but also works on Microsoft Windows, macOS, and other operating systems.[2]
File formats
[edit]| Portable pixmap | |
|---|---|
| Filename extension |
.pbm, .pgm, .ppm, .pnm |
| Internet media type | |
| Uniform Type Identifier (UTI) | public.pbm |
| Developed by | Jef Poskanzer |
| Type of format | Image file format |
| Extended to | Portable Arbitrary Map (PAM) |
| Open format? | yes |
Several graphics formats are used and defined by the Netpbm project:
- portable bitmap format (PBM)
- portable graymap format (PGM)
- portable pixmap format (PPM)
PBM, PGM and PPM, sometimes collectively referred to as the portable anymap format (PNM) are image file formats designed to be easily exchanged between platforms.[6][7] The magic number at the beginning of a file determines the type. PNM files use a magic number of an ASCII "P" followed by a number defining the file type.[8]
The PBM format was invented by Jef Poskanzer in the 1980s. The format allowed monochrome bitmaps to be transmitted within an email message as plain ASCII text, so that it would survive any changes in text formatting.[7] The first library to handle the PBM format was released in 1988 under the name Pbmplus, containing tools to convert between PBM and other graphics formats. By the end of 1988, Poskanzer had developed the PGM and PPM formats along with their associated tools and added them to Pbmplus. The final release of Pbmplus was December 10, 1991.
The Netpbm library was released in 1993 to replace the then-unmaintained Pbmplus. It repackaged the original library and incorporated fixes created by other developers.[1]
Description
[edit]Each file starts with a two-byte magic number in ASCII that identifies the file type (PBM, PGM, or PPM) and its encoding (ASCII/"plain" or binary/"raw"). The magic number is a capital P followed by a single-digit number.
| Type | Magic number | Extension | Colors | |
|---|---|---|---|---|
| ASCII (plain) | Binary (raw) | |||
| Portable BitMap | P1
|
P4
|
.pbm |
2, the values 0 and 1 (white & black) |
| Portable GrayMap | P2
|
P5
|
.pgm |
maximum 65536 gray levels, typically in the range 0-255 or 0-65535, black-to-white range |
| Portable PixMap | P3
|
P6
|
.ppm |
maximum 65536 color levels for each RGB channel, typically in the range 0-255 or 0-65535 |
The Netpbm library supports an additional PAM file format with a magic number of P7.[9]
PNM files can be created as both plain text and raw binary. The ASCII ("plain") formats allow for human readability and easy transfer to other platforms, whereas the binary ("raw") formats are easier to parse by programs and more efficient in file size. In the binary formats, PBM uses 1 bit per pixel, PGM uses 8 or 16 bits per pixel, and PPM uses 24 or 48 bits per pixel: 8/16 for red, 8/16 for green, 8/16 for blue. Application support for the 16 bit variants is rare. In either form, the header remains in ASCII format and the arguments are separated by a whitespace.
PGM and PPM documentation defines that gray and color values use the BT.709 color space and gamma transfer function. However, depending on the application, the used color space may be sRGB, linear or some other color space. There is no metadata in the file to indicate which color space is being used.
PBM example
[edit]A simple example of the PBM format is as follows:
P1 # This is an example bitmap of the letter "J" 6 10 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
The string P1 identifies the file format. The number sign introduces a comment. The next two numbers give the width and the height. The following matrix gives the pixel values. As the PBM format is monochromatic and only supports two shades, namely, black and white, the image is described in only ones and zeros. This is known as a bitmap.
The matrix cells do not need to be aligned; the format ignores whitespace and line feeds in the data section. The following displays the same image:
P1 # This is an example bitmap of the letter "J" 6 10 000010000010000010000010000010000010100010011100000000000000
A value of 0 signifies a white pixel, and a 1 signifies a black pixel. This differs from the other formats, where higher values signify brighter pixels.
The P4 binary format of the same image represents each pixel with a single bit. The width of the row in pixels is given in the header, packed to the length of 8 pixels or a byte. The first pixel in a row is the most significant bit. The extra bits used to make the length equal to a byte are ignored. The following formula can be used to calculate the number of required bytes ⌈width / 8⌉ * height. Using the example above a ⌈6 / 8⌉ * 10 grid would take 10 bytes.
P4 # This is an example binary format of the letter "J" with each byte in decimal notation 6 10 8 8 8 8 8 8 136 112 0 0
PGM example
[edit]The PGM and PPM formats have an additional parameter for the maximum value (numbers of grey between black and white) after the X and Y dimensions and before the actual pixel data. Black is 0 and max value is white.
P2 # Shows the word "FEEP" 24 7 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 3 3 3 0 0 7 7 7 7 0 0 11 11 11 11 0 0 15 15 15 15 0 0 3 0 0 0 0 0 7 0 0 0 0 0 11 0 0 0 0 0 15 0 0 15 0 0 3 3 3 0 0 0 7 7 7 0 0 0 11 11 11 0 0 0 15 15 15 15 0 0 3 0 0 0 0 0 7 0 0 0 0 0 11 0 0 0 0 0 15 0 0 0 0 0 3 0 0 0 0 0 7 7 7 7 0 0 11 11 11 11 0 0 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
PPM example
[edit]This is an example of a color RGB image stored in PPM format. (Not shown are the newline character(s) at the end of each line.)
P3 # "P3" means this is a RGB color image in ASCII # "3 2" is the width and height of the image in pixels # "255" is the maximum value for each color # This, up through the "255" line below are the header. # Everything after that is the image data: RGB triplets. # In order: red, green, blue, yellow, white, and black. 3 2 255 255 0 0 0 255 0 0 0 255 255 255 0 255 255 255 0 0 0
The P6 binary format of the same image represents each color component of each pixel with one byte (thus three bytes per pixel) in the order red, green, then blue. The file is smaller, but the color information is more difficult to read by humans. The binary image information comes after the header (which ends with a whitespace).
In the binary format, last headerline must be like "255\n", with data immediately following it; any comment added after 255 will be taken as the start of image data, and the image will be skewed to the right (at least when opened by the image-manipulation program GIMP (December 2022)).
The PPM format is not compressed, and thus requires more space and bandwidth than a compressed format would. For example, the above 192×128 PNG (Portable Network Graphics) image has a file size of 166 bytes. When converted to a 192×128 PPM image, the file size is 73,848 bytes. Filesize reduction factor 100 or so when converting to png is typical if the image is a line drawing; if the image is a photo, it is best converted to jpeg, which yields a greater filesize reduction.
PPM is generally used as an intermediate format for image work before converting to a more efficient format like PNG without any loss of information in the intermediate step.
The image shown above using only 0 or the maximal value for the red, green and blue channels can be encoded as follows:
P3 # The same image with width 3 and height 2, # using 0 or 1 per color (red, green, blue) 3 2 1 1 0 0 0 1 0 0 0 1 1 1 0 1 1 1 0 0 0
White space (including line ends) and comment lines are syntactically equivalent to a single space within the PNM headers. For the plain formats (P1, P2 and P3) this is also true of the pixmap lines:
P3 3 2 1 1 0 0 0 1 0 0 0 1 1 1 0 1 1 1 0 0 0
Extensions
[edit]16-bit
[edit]The original definition of the PGM and the PPM binary formats (the P5 and P6 formats) did not allow bit depths greater than 8 bits. While the ASCII format can accommodate greater bit depths, it increases file sizes and slows read and write operations. Many programmers have extended the format to allow higher bit depths. When using higher bit depths, the endianness of the file matters. Various implementations have not agreed on which byte order to use, and some connected the 16-bit endianness to the pixel packing order.[10] The PGM and PPM documentation says the most significant byte is first and the Netpbm implementation uses big-endian byte order.[11]
32-bit
[edit]The PFM (Portable Floatmap) is the unofficial four byte IEEE 754 single precision floating point extension.[12][13][14]
- The first line is either the ASCII text "PF", for a color file, or "Pf", for a grey-scale file.
- The next ASCII text line contains the width and height, separated by the space character hex 20 or sometimes with hex 0A (resulting in four lines). After each line a white space character hex 0A is written and not the Windows/DOS CR/LF combination.
- The third ASCII text line holds a nonzero decimal number that indicates little-endian floats for the pixel data when negative and big-endian floats when positive. The absolute value of the number indicates the range. So the third line containing -1.0 indicates little-endian format in range zero to one. (No comments may follow.)
After the header the file, each pixel is specified with a floating point number from left-to-right, bottom-to-top. Some programs suggest PF4 as an additional extension for the RGBA format.[15]
PFM is supported by the programs Photoshop,[16] GIMP, and ImageMagick. It is also supported by the de facto reference implementation netpbm.[12]
Programs
[edit]The Netpbm package contains over 350 programs,[17] most of which have "pbm", "pgm", "ppm", "pam", or "pnm" in their names. For example, one might use pamscale to shrink an image by 10%, pamcomp to overlay one image on top of another, pbmtext to create an image of text, or reduce the number of colors in an image with pnmquant.
The programs are designed to be minimal building blocks that can be used in various combinations to do other things. The Netpbm package can, for example, use two successive conversion programs to turn a color picture in the GIF format into a .bmp file:
giftopnm somepic.gif > somepic.ppm ppmtobmp somepic.ppm > somepic.bmp
This kind of operation is commonly done as a pipeline to save execution time and to avoid creating a temporary file:
giftopnm somepic.gif | ppmtobmp > somepic.bmp
The Netpbm programs are frequently used as intermediates to convert between obscure formats. For instance, there may be no tool to convert an X11 window dump (XWD format) directly to a Macintosh PICT file, but one can do this by running xwdtopnm, then ppmtopict. (Tools which say that they output PNM output either PBM, PGM, or PPM. Tools importing PNM will read any of the three formats.) As a more complex example, Netpbm tools can convert 48×48 XBM to Ikon and eventually X-Face.[18]
History
[edit]The PBM (black and white) format was invented by Jef Poskanzer in the mid-1980s. At the time, there was no standard, reliable way to send binary files in email, and attempting to send anything other than 7-bit ASCII in email often resulted in data corruption. PBM was designed to allow images to be sent via email without being corrupted. Poskanzer released the forerunner of Netpbm, called Pbmplus in 1988. By the end of 1988, Poskanzer had developed the PGM (greyscale) and PPM (color) formats and released them with Pbmplus.
The last release of Pbmplus was on December 10, 1991. Poskanzer never released any further updates, and in 1993, Netpbm was developed to replace it. At first, it was nothing more than a renamed release of Pbmplus, but updates continued to occur until 1995 when the package again became abandoned. In 1999, the Netpbm package was picked up by its present maintainer, Bryan Henderson.
In 2000, PAM was added to the file formats of the Netpbm library allowing an alpha channel.[19]
The name Netpbm came from the program developers collaborating over the Internet, which was notable at the time; the NetBSD operating system and NetHack game got their names similarly. (Unlike with the later, more widespread Portable Network Graphics (PNG) format, the "net" in the name is not actually in reference to the image itself being optimized for transfer over a network.)
PAM graphics format
[edit]| Portable Arbitrary Map | |
|---|---|
| Filename extension | .pam |
| Internet media type |
image/x-portable-arbitrarymap[20] |
| Developed by | Bryan Henderson |
| Type of format | Image file format |
| Extended from | Portable aNy Map (PNM) |
| Open format? | yes |
Portable Arbitrary Map (PAM) is an extension of the older binary P4...P6 graphics formats, introduced with netpbm version 9.7 (August 2000). PAM generalises all features of PBM, PGM, and PPM, and provides for extensions. PAM defines two new attributes; depth and tuple type:
- The depth attribute defines the number of channels in the image, such as 1 for greyscale images and 3 for RGB images.
- The tuple type attribute specifies what kind of image the PAM file represents, thus enabling it to stand for the older Netpbm formats, as well as to be extended to new uses, e.g., transparency.
PAM is supported by XnView and FFmpeg.[21][22] As specified the TUPLTYPE is optional; however, FFmpeg requires it.
Differences from the older formats
[edit]The header for the PAM file format begins with P7, and (unlike in the other formats) ends in an explicit close: "ENDHDR" followed by a whitespace. Line ends in a PAM header are significant; for PNM, line ends are whitespace.
There is no plain (human-readable, ASCII-based) version of PAM. PAM files are always binary, and attempts to use the switch -plain with Netpbm programs that produce PAM output results in an error message.
For the black-and-white version of PAM (depth 1, tuple type BLACKANDWHITE), corresponding to PBM, PAM uses one byte per pixel, instead of PBM's use of one bit per pixel (packing eight pixels in one byte). Also, the value 1 in such a PAM image stands for white ("light on"), as opposed to black in PBM ("ink on").
| TUPLTYPE | MAXVAL | DEPTH | comment |
|---|---|---|---|
| BLACKANDWHITE | 1 | 1 | special case of GRAYSCALE |
| GRAYSCALE | 2...65535 | 1 | 2 bytes per pixel for MAXVAL > 255 |
| RGB | 1...65535 | 3 | 6 bytes per pixel for MAXVAL > 255 |
| BLACKANDWHITE_ALPHA | 1 | 2 | 2 bytes per pixel |
| GRAYSCALE_ALPHA | 2...65535 | 2 | 4 bytes per pixel for MAXVAL > 255 |
| RGB_ALPHA | 1...65535 | 4 | 8 bytes per pixel for MAXVAL > 255 |
Transparency
[edit]All of the basic tuple types (BLACKANDWHITE, GRAYSCALE, and RGB) have a variant with an opacity channel. The tuple type is created by appending "_ALPHA" as a suffix to the base tuple type.
For example, an image with a tuple type of GRAYSCALE is equivalent to PGM (portable graymap). GRAYSCALE_ALPHA with transparency is not directly possible in PGM. The specification permits MAXVAL 1 for GRAYSCALE, but it would have the same effect as BLACKANDWHITE.
An example in the BMP article shows an RGBA image with 4×2=8 blue, green, red, and white pixels; half transparent (0x7F) in the first lower row, opaque (0xFF) in the second upper row; hex. FF00007F 00FF007F 0000FF7F FFFFFF7F FF0000FF 00FF00FF 0000FFFF FFFFFFFF in BGRA order. For PAM, this bitmap has to be given in RGBA order, swapping the 1st and 3rd byte in each pixel. BMP rows are typically arranged bottom-up, for PAM and PNM rows are given top-down (i.e. for this example 0000FFFF 00FF00FF FF0000FF FFFFFFFF 0000FF7F 00FF007F FF00007F FFFFFF7F). The PAM header for this example could be:
P7 WIDTH 4 HEIGHT 2 DEPTH 4 MAXVAL 255 TUPLTYPE RGB_ALPHA ENDHDR
Extensions
[edit]PAM's tuple-type mechanism allows for many extensions. In theory, PAM can be extended to represent color models such as CMYK.
The format is not even limited to graphics, its definition allows it to be used for arbitrary three-dimensional matrices of unsigned integers. Some programs of the Netpbm package, for example pamsummcol, function as crude matrix arithmetic processors and use the PAM format this way.
Licensing
[edit]Netpbm consists of hundreds of different tools, each offered with a public copyright license of its own. An analysis by Debian developer Steve McIntyre from 2001 suggests mostly free software licenses, one non-commercial license (non-free) and a dozen without any license offered (thus also non-free). As mentioned in the analysis, it obviously doesn't cover changes since.[23]
See also
[edit]
- GD Graphics Library
- GraphicsMagick
- ImageMagick
- List of Unix commands
- X PixMap (comparison of PBM and XPM)
- X BitMap
References
[edit]- ^ a b "Netpbm history". Retrieved March 17, 2010.
- ^ Henderson, Bryan (2013). "Getting Netpbm". Sourceforge. Retrieved 2 February 2021.
- ^ .pbm MIME type not registered at IANA
- ^ .pgm MIME type not registered at IANA
- ^ .ppm MIME type not registered at IANA
- ^ a b .pnm MIME type not registered at IANA
- ^ a b Murray, James D.; van Ryper, William (April 1996). Encyclopedia of Graphics File Formats, Second Edition. O'Reilly. ISBN 1-56592-161-5. Retrieved 2014-02-27.
- ^ "The PBM Format". User manual for Netpbm.
- ^ "Layout of the PAM file format".
- ^ "Pnmtotiff User Manual". netpbm doc at SourceForge. 27 March 2005.
- ^ "pamendian man page". netpbm doc at SourceForge. 10 October 2012.
- ^ a b "PFM Format Description".
- ^ "PFM (Portable Float Map) - Just Solve the File Format Problem".
- ^ "PFM Format Documentation". Archived from the original on 2019-12-31.
- ^ "Synthetic HDR Fire Sequences".
- ^ "File formats in Adobe Photoshop".
- ^ "Netpbm home page". Retrieved May 3, 2023.
- ^ Dairiki, Jeff. "Online X-Face Converter". Retrieved 2014-03-02.
- ^ "PAM format specification".
- ^ MIME type not registered at IANA: PAM format specification
- ^ Gougelet, Pierre-Emmanuel (2015-02-19). "XnView 2.30". XnView. Retrieved 2015-02-20.
PAM format added
- ^ "Image Formats". FFmpeg General Documentation. 2014. Retrieved 2014-02-23.
- ^ "2001 analysis of Netpbm copyrights done by Steve McIntyre".
External links
[edit]- Official website
- pfm: the PFM graphic image file format as understood by the Netpbm
- Examples of ppm files in various formats
| Raster |
|
|---|---|
| Raw | |
| Vector | |
| Compound | |
| Metadata |
|
Netpbm
View on GrokipediaOverview
Description
Netpbm is an open-source package comprising approximately 300 command-line graphics programs and a programming library dedicated to image manipulation and conversion.[3] It provides fundamental building blocks for processing raster images, enabling operations such as resizing, cropping, and applying filters to support a wide range of graphics workflows.[4] The toolkit is primarily employed in Unix-like systems for batch processing of images, where it handles nearly 100 input and output formats through dedicated converters, facilitating seamless integration into automated scripts and pipelines.[4] This makes it ideal for server-side image handling, scientific visualization, and large-scale data processing tasks that require efficient, non-interactive manipulation.[4] Netpbm features a strictly command-line interface without any graphical user interface, which underscores its emphasis on portability across platforms and ease of integration with scripting languages like Bash or Perl.[4] Originating in the late 1980s as a collection of utilities for basic image operations, it has evolved into a robust ecosystem while maintaining its core focus on simplicity and extensibility.[2] Its native formats, such as PBM, PGM, PPM, and PAM, serve as intermediaries for format conversions.[4] The project remains actively maintained as of 2025, with releases such as version 10.86.48 in September 2025 incorporating enhancements.[5]Components
Netpbm is composed primarily of approximately 300 standalone executable programs designed for various image processing tasks.[3] These programs are grouped functionally into categories such as converters for format translation, editors for image modification, generators for creating new images, analyzers for examining image properties, and miscellaneous utilities.[3] This organization facilitates targeted use in workflows involving image creation, editing, and analysis.[1] In addition to the executables, Netpbm includes the libnetpbm C programming library, which enables developers to integrate image input/output operations and basic manipulation functions directly into custom applications.[4] The library supports reading and writing Netpbm formats along with utilities for tasks like character drawing and color space conversions, and it underpins nearly all of the package's programs.[4] The programs adhere to a consistent naming convention to indicate their scope and purpose: prefixes such as "pnm" denote operations applicable to multiple Netpbm formats (PBM, PGM, PPM), while "pbm" is specific to bitmap (black-and-white) images, "pgm" to grayscale, "ppm" to color, and "pam" to the more general Portable Arbitrary Map format.[4] Supporting these core elements are auxiliary files, including comprehensive documentation in the form of a user manual and individual program descriptions, as well as man pages for command-line reference.[4]Graphics Formats
Core Formats (PBM, PGM, PPM)
The core formats of Netpbm—Portable Bitmap (PBM), Portable Graymap (PGM), and Portable Pixmap (PPM)—form the foundational raster image standards within the toolkit, emphasizing simplicity and portability across systems. These formats are designed as lowest common denominators for monochrome, grayscale, and color images, respectively, facilitating easy programmatic manipulation and conversion without proprietary dependencies. Each format supports both ASCII-based (plain) and binary (raw) variants, allowing trade-offs between human readability and file efficiency. They share a common structure: a magic number identifying the format and variant, followed by whitespace-separated ASCII integers for image dimensions (width and height in pixels), an optional maxval for sample depth where applicable, and then the pixel raster data arranged row-by-row from top to bottom and left to right.[6][7][8] PBM represents monochrome bitmaps with 1 bit per pixel, where 0 denotes black and 1 denotes white. The magic numbers are P1 for the plain (ASCII) variant and P4 for the raw (binary) variant. The header begins with the magic number, followed by the width and height in decimal ASCII, and may include a comment line starting with # after the magic number. In the plain variant, pixel values are ASCII 0s and 1s separated by whitespace; in the raw variant, pixels are packed into binary bytes with the most significant bit first, filling rows left to right. A simple 2x2 plain PBM example encoding a checkerboard pattern is:P1
2 2
0 1
1 0
P1
2 2
0 1
1 0
P2
2 2
1
0 0
1 1
P2
2 2
1
0 0
1 1
P3
2 2
1
0 0 0 1 1 1
1 1 1 0 0 0
P3
2 2
1
0 0 0 1 1 1
1 1 1 0 0 0
PAM Format
The Portable Arbitrary Map (PAM) format serves as Netpbm's extensible, general-purpose image format, designed to accommodate a wide variety of 2D data arrays beyond the limitations of the core formats. It represents images as a rectangular array of tuples, where each tuple consists of one or more samples, enabling support for arbitrary depths such as RGB (3 samples), CMYK (4 samples), or RGBA (4 samples). Unlike the simpler core formats PBM, PGM, and PPM, which are restricted to fixed structures for monochrome, grayscale, and RGB data respectively, PAM provides greater flexibility through its descriptive header and binary-only encoding.[9] PAM files begin with the magic number "P7" followed by a newline, after which the header consists of keyword-value pairs in ASCII format. Required fields include WIDTH (image width in pixels), HEIGHT (image height in pixels), DEPTH (number of samples per tuple, indicating channel count), and MAXVAL (maximum value for each sample, ranging from 1 to 65535). An optional TUPLTYPE field specifies the semantic meaning of the tuples, such as "RGB" for color images or "BLACKANDWHITE" for monochrome, with multiple types possible but typically one primary descriptor. The header concludes with the mandatory "ENDHDR" keyword followed by a newline, marking the transition to the binary raster data section, which contains height × width × depth samples stored in row-major order. Optional header fields may include hints for orientation (e.g., "TOPLEFT") or end-of-line handling, enhancing portability across systems.[9] A key distinction from PBM, PGM, and PPM lies in PAM's richer metadata and support for multiple channels, including alpha for transparency, without an ASCII variant for data encoding. Transparency is implemented by incorporating an alpha sample in the tuple type, such as "RGB_ALPHA", where the alpha value scales from 0 (fully transparent) to MAXVAL (fully opaque), allowing compositing in image processing workflows. This enables PAM to handle layered or semi-transparent images natively, contrasting with the core formats' lack of such capabilities. The binary data follows immediately after the header, with each sample encoded in 1 to 4 bytes depending on MAXVAL (e.g., 1 byte for values up to 255), ensuring efficient storage without the variable-length parsing issues of ASCII formats.[9] For illustration, a minimal PAM header for a 2×2 RGB image might appear as:P7
WIDTH 2
HEIGHT 2
DEPTH 3
MAXVAL 255
TUPLTYPE RGB
ENDHDR
P7
WIDTH 2
HEIGHT 2
DEPTH 3
MAXVAL 255
TUPLTYPE RGB
ENDHDR
Extensions and Supported Formats
Netpbm formats support extensions for higher bit depths to enable greater precision in image representation. In PGM and PPM formats, the maximum value (maxval) can reach 65,535, allowing for 16 bits per sample when maxval is 256 or greater; this extension was introduced in April 2000, expanding from the prior limit of 255 for 8-bit support.[7][8] PAM similarly accommodates a maxval of up to 65,535, providing 16-bit integer samples across its flexible tuple structure.[9] Support for 32-bit depths is not available in the core formats or PAM, which are limited to 16-bit integer samples. Floating-point representations (up to 32-bit IEEE 754 single precision) are available through the separate PFM (Portable Floatmap) format, which Netpbm converters like pamtopfm and pfmtopam facilitate for high dynamic range applications.[10] These capabilities are primarily tool-specific rather than inherent to the format specifications. Netpbm tools support approximately 92 input and output formats through dedicated converters, enabling broad interoperability while prioritizing lossless conversions where possible.[3] Key examples include PNG for lossless compression, JPEG for lossy photographic images, TIFF for multi-page and layered files, GIF for animated and indexed color graphics, BMP for simple bitmapped representations, and XWD for X Window System dumps.[11][12][13] Conversion between these formats often uses PAM as an intermediate representation to preserve data integrity during processing.[9] Built-in decoders handle many formats directly, while others rely on external libraries such as libjpeg for JPEG support or libtiff for TIFF. Core Netpbm formats themselves lack native lossy compression mechanisms, directing such operations to external format converters.[6]Tools and Programs
Manipulation Utilities
Netpbm provides a suite of command-line utilities for manipulating images, enabling tasks such as resizing, rotating, flipping, and applying effects like noise or arithmetic operations directly on Netpbm formats including PBM, PGM, PPM, and PAM.[3] These tools, prefixed with pbm-, pgm-, ppm-, or pam- to indicate their primary format support, allow precise control over image transformations without requiring graphical interfaces, making them ideal for automated processing.[4] The "Editors" category includes 67 core manipulation functions as part of the broader Netpbm package of more than 350 programs.[3] Key utilities include pamscale for resizing and scaling images with high precision. It supports scaling by a uniform factor, independent horizontal and vertical dimensions, or fitting within specified bounds while preserving aspect ratios, using methods like Lanczos filtering for quality enlargement or reduction. For example, to halve the size of an input image:pamscale 0.5 input.ppm > output.ppm
pamscale 0.5 input.ppm > output.ppm
pamflip -rotate90 input.pgm > output.pgm
pamflip -rotate90 input.pgm > output.pgm
pamflip -leftright input.ppm > output.ppm
pamflip -leftright input.ppm > output.ppm
pamaddnoise -type gaussian -sigma1 4.0 -sigma2 20.0 input.ppm > output.ppm
pamaddnoise -type gaussian -sigma1 4.0 -sigma2 20.0 input.ppm > output.ppm
pamfunc -multiplier=2 input.pam > output.pam
pamfunc -multiplier=2 input.pam > output.pam
pbmmask input.pbm > mask.pbm
pnmpaste -and background.pbm mask.pbm 0 0 | pnmpaste -or foreground.pbm 0 0 > composited.pbm
pbmmask input.pbm > mask.pbm
pnmpaste -and background.pbm mask.pbm 0 0 | pnmpaste -or foreground.pbm 0 0 > composited.pbm
Conversion Tools
Netpbm provides a suite of command-line utilities dedicated to converting images between its core formats (PBM, PGM, PPM, and PAM) and over 100 other graphics formats, enabling bidirectional translations while prioritizing lossless processes where feasible.[21] These tools facilitate seamless integration in pipelines, often piping output from one converter to another to avoid intermediate file storage and preserve data integrity. For instance, converters likepnmtopng, giftopnm, and pnmtojpeg handle popular formats such as PNG, GIF, and JPEG, respectively, with options to control quality, compression, and metadata.[4]
Key converters include pnmtopng, which transforms PNM input (including PPM) into PNG output, scaling color values to 8 or 16 bits per channel for lossless representation; a basic syntax is pnmtopng input.ppm > output.png, with options like -compression=9 for maximum zlib compression or -transparent=red to specify a transparent color.[11] Similarly, giftopnm converts GIF files to PNM, outputting PBM for monochrome, PGM for grayscale, or PPM for color images, as in giftopnm input.gif > output.ppm; it supports -verbose for diagnostic output and --alphaout=mask.pbm to generate a separate transparency mask.[22] For JPEG output, pnmtojpeg processes PNM input into JFIF files, using syntax like pnmtojpeg -quality=90 input.ppm > output.jpg, where -quality=n (0-100, default 75) adjusts compression trade-offs.[12]
Common workflows leverage PAM as a lossless intermediate format to maintain full fidelity during multi-step conversions, such as pngtopam input.png | pnmtojpeg -quality=95 > output.jpg, which first decodes PNG to PAM (preserving alpha if present) before encoding to JPEG.[4] This approach minimizes data loss across ~100 supported formats, including bidirectional support for most (e.g., jpegtopnm for JPEG to PNM), though tools issue warnings for inherently lossy formats like JPEG, where repeated conversions degrade quality—recommendations include quality settings of 50-95 and avoiding cycles like JPEG to PNM and back.[12][21]
Special cases arise in handling transparency, particularly for formats like GIF and PNG. Conversions to/from GIF use separate PBM masks via --alphaout in giftopnm or equivalent in pamtogif, where black pixels denote transparency; for PNG, pngtopam with -alphapam outputs a single PAM file incorporating an alpha channel (RGB_ALPHA or GRAYSCALE_ALPHA), while pamtopng reverses this by embedding the PAM transparency directly into PNG's tRNS or alpha chunks, ensuring lossless preservation without separate files.[22][23][24]
Programming Library
Features
The Netpbm programming library, libnetpbm, is a C library designed for reading, writing, and manipulating images in the Netpbm formats, providing developers with low-level access to pixel data and image metadata. It supports the core formats—PBM for binary images, PGM for grayscale, and PPM for color—as well as the extensible PAM format, enabling handling of multi-channel and high-depth images. Key reading functions includeppm_readppminit for initializing PPM headers with dimensions, maxval, and format details, and pnm_readpamrow for loading rows of pixel tuples in PAM files; writing counterparts such as ppm_writeppminit and pnm_writepamrow allow output in both ASCII (plain) and binary (raw) variants.[25][26]
Pixel access is facilitated through dedicated data structures: the pixel type for PPM, which stores RGB components accessible via macros like PPM_GETR(p) and PPM_ASSIGN; the gray type for PGM, representing grayscale values up to PGM_OVERALLMAXVAL (65535 for 16-bit support); and the bit type for PBM, handling black-and-white pixels efficiently. For PAM, the struct pam encapsulates image properties like width, height, depth (number of channels), maxval, and tuple type, while tuple arrays manage per-pixel samples, supporting 16-bit precision and arbitrary channel counts for formats beyond the core trio. Raster data is organized as row arrays (e.g., pixel* for PPM rows) or full 2D arrays, with allocation functions like ppm_allocrow ensuring memory management.[25][27][28][26]
The library includes modules for image operations, enabling manual processing such as arithmetic on samples to combine values from multiple images, scaling by resizing based on factors while preserving aspect ratios, and color space conversions by manipulating tuple types (e.g., RGB to grayscale via PAM depth adjustments). These features prioritize efficient in-memory processing, with headers consistently providing essential metadata like image dimensions and maxval for validation and rendering. For higher-level manipulations, developers typically implement logic using the pixel access functions or invoke dedicated Netpbm tools via pm_system.[26]
Error handling relies on pm_error, a function that outputs descriptive messages for issues such as malformed headers, invalid formats, or memory failures, typically terminating the program after logging to standard error. This ensures robust development by catching common pitfalls in file I/O and data integrity.[29]
Integration and Usage
To integrate the Netpbm library into C applications, developers must include relevant headers such as<netpbm/ppm.h>, <netpbm/pgm.h>, or the more versatile <netpbm/pam.h> for Portable Anymap (PAM) support, and link against the library using -lnetpbm during compilation.[30] The library is distributed as development packages on various systems; for instance, on Debian-based Linux distributions, it can be installed via apt install libnetpbm-dev, which provides the necessary headers and static libraries, while on macOS, brew install netpbm from Homebrew supplies the components.[31][32]
A typical usage involves reading a PPM image, performing manipulations like scaling, and writing the output. The following C code snippet demonstrates reading a PPM file using ppm_readppm(), applying a simple nearest-neighbor scaling to double the dimensions by duplicating pixels (a basic library-based approach without external tools), and writing the result as a new PPM file; it initializes the library with pm_init() and handles raster allocation.[25][26]
#include <stdio.h>
#include <netpbm/ppm.h>
#include <netpbm/pm.h>
int main(int argc, char *argv[]) {
FILE *ifp, *ofp;
int rows, cols;
pixval maxval;
pixel **pixels, **newpixels;
int row, col;
pm_init(argv[0], 0);
ifp = pm_openr("-");
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
/* Allocate scaled raster (double size via duplication) */
newpixels = ppm_allocarray(2 * cols, 2 * rows);
for (row = 0; row < rows; ++row) {
for (col = 0; col < cols; ++col) {
newpixels[2 * row][2 * col] = pixels[row][col];
newpixels[2 * row][2 * col + 1] = pixels[row][col]; /* Duplicate horizontally */
newpixels[2 * row + 1][2 * col] = pixels[row][col]; /* Duplicate vertically */
newpixels[2 * row + 1][2 * col + 1] = pixels[row][col];
}
}
ppm_freearray(pixels, rows);
ofp = pm_openw("-");
ppm_writeppm(ofp, newpixels, 2 * cols, 2 * rows, maxval, 0);
pm_close(ofp);
ppm_freearray(newpixels, 2 * rows);
return 0;
}
#include <stdio.h>
#include <netpbm/ppm.h>
#include <netpbm/pm.h>
int main(int argc, char *argv[]) {
FILE *ifp, *ofp;
int rows, cols;
pixval maxval;
pixel **pixels, **newpixels;
int row, col;
pm_init(argv[0], 0);
ifp = pm_openr("-");
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
/* Allocate scaled raster (double size via duplication) */
newpixels = ppm_allocarray(2 * cols, 2 * rows);
for (row = 0; row < rows; ++row) {
for (col = 0; col < cols; ++col) {
newpixels[2 * row][2 * col] = pixels[row][col];
newpixels[2 * row][2 * col + 1] = pixels[row][col]; /* Duplicate horizontally */
newpixels[2 * row + 1][2 * col] = pixels[row][col]; /* Duplicate vertically */
newpixels[2 * row + 1][2 * col + 1] = pixels[row][col];
}
}
ppm_freearray(pixels, rows);
ofp = pm_openw("-");
ppm_writeppm(ofp, newpixels, 2 * cols, 2 * rows, maxval, 0);
pm_close(ofp);
ppm_freearray(newpixels, 2 * rows);
return 0;
}
pamscale utility via the library's pm_system() function after writing the input to a temporary file, though this hybrid approach combines library I/O with external execution.[33][34]
The Netpbm library integrates into larger projects for image processing tasks; for example, it powers GIMP plugins through the Netpbm2Gimp tool, which compiles Netpbm programs directly into GIMP-compatible extensions, and ImageMagick supports Netpbm formats natively for conversions and manipulations as part of its format-handling backend.[35][36] Custom scripts in Python can leverage wrappers like the netpbmfile library, which provides pure-Python reading and writing of Netpbm files without direct C bindings.
Best practices for using the library include always checking return values from functions like ppm_readppm() to detect file errors or invalid formats, manually managing memory for rasters with ppm_allocarray() and ppm_freearray() to prevent leaks, and employing generic row-reading functions such as pnm_readpnmrow() to support multiple formats (PBM, PGM, PPM) seamlessly in a single codebase.[37][25]
The core Netpbm library is implemented in C, limiting direct use to C/C++ environments, though language bindings and wrappers exist for Go via the netpbm package and Haskell through pure parsers in the netpbm Hackage library.[30][38][39]
History and Development
Origins
Netpbm originated in the 1980s with the development of the Portable Bitmap (PBM) format by Jef Poskanzer, who created it as a simple, text-based bitmap format suitable for transmission via email and basic image manipulation on Unix systems.[2] In 1988, Poskanzer released Pbmplus, an initial toolkit that compiled his various utilities for working with PBM files, including converters to other graphics formats commonly used in early computing environments.[2] By the end of 1988, Poskanzer expanded the toolkit to include the Portable Graymap (PGM) and Portable Pixmap (PPM) formats, enabling support for grayscale and color images while maintaining the portable, ASCII-compatible structure of the original PBM.[2] Pbmplus was distributed primarily through Usenet newsgroups such as comp.sources.misc and FTP servers associated with the X Window System, fostering early community engagement among Unix users.[2] The last official release of Pbmplus occurred on December 10, 1991, after which Poskanzer ceased active maintenance despite growing external contributions.[2] In 1993, the project was reorganized and rebranded as Netpbm to serve as a community-maintained successor to Pbmplus, incorporating contributions from developers worldwide and emphasizing collaborative development.[2] The last regular Netpbm release was in March 1994, after which the project was neglected until September 1995, when Anthony Thyssen issued an unofficial update (Netpbm-1mar1994.p1). This transition marked Netpbm's shift toward a more distributed model, building directly on the accumulated tools and formats from Pbmplus. From its inception, Netpbm's tools were designed for Unix-based systems, particularly to support graphics applications within the X Window System, with a strong emphasis on portability across different hardware and operating environments lacking advanced memory management.[2] Early adoption occurred prominently in academic and research settings during the late 1980s and early 1990s, where it became a standard for image processing scripts in computer vision projects, archived in repositories like the Pilot European Image Processing Archive (PEIPA).[40]Key Milestones and Maintenance
In September 1999, Bryan Henderson assumed maintenance of the Netpbm project, addressing bugs such as those in Xbmtopbm and reorganizing the collection of unsupported versions and outdated documentation.[2] In April 2000, the project relocated to SourceForge for improved collaboration and distribution.[2] That same year, Netpbm introduced 16-bit support for PGM and PPM formats, allowing a maximum value (maxval) of 65535 with a defined byte order to ensure portability across systems.[2] In August 2000, the PAM format was added, along with corresponding library routines to handle its multi-plane structure for enhanced flexibility in image representation.[2] Release 10 in June 2002 marked a significant reorganization, consolidating the utilities into a single package with a unified library and comprehensive HTML documentation for easier maintenance and user access.[2] By January 2004, gamma-adjusted sample value support was implemented in version 10.20, including functions like pm_[un]gamma709() to better handle color space conversions.[2] In August 2006, Netpbm adopted Subversion for version control, establishing multiple stable branches—super stable, stable, and advanced—alongside a development branch to balance reliability and innovation; this period also saw further enhancements to PAM capabilities.[2] Akira F. Urushibata began contributing in 2004, starting with fixes to the fax format converter pbmtog3 and later providing major speedups for PBM operations using MMX/SSE instructions, as well as creating test facilities in 2012.[2] Netpbm maintains a regular release cadence of approximately every three months, with the latest stable version, 10.86.48, released on September 27, 2025.[5] The project remains actively developed under Bryan Henderson's primary maintenance, hosted on SourceForge, and comprises over 330 distinct tools for image manipulation and conversion.[4] It is widely integrated into Linux distributions, such as Fedora, where a 2012 study identified 114 Netpbm programs in active use.[1]Licensing and Availability
License Terms
Netpbm is distributed under a collection of permissive open source licenses, with individual tools and components licensed separately to accommodate contributions from multiple authors. The majority of the software falls under public domain dedication or highly permissive terms, allowing free use, modification, and redistribution without royalties, subject to basic requirements such as preserving copyright notices where applicable. This licensing approach reflects the project's evolution from its origins as Pbmplus, where many core utilities were explicitly placed in the public domain by primary developer Jef Poskanzer.[1] Specific licenses vary across the toolkit: numerous programs, including common converters like anytopnm and pamcut, use Poskanzer's custom public domain notice, which disclaims warranty and grants unrestricted rights. Others adopt the BSD license or variants, such as for tools like 411toppm and pstopnm, permitting commercial use with minimal attribution obligations. A smaller subset employs the GNU General Public License version 2 (GPLv2), often for components integrating GPL-licensed dependencies (e.g., fiascotopnm). Components using JPEG libraries follow the Independent JPEG Group's permissive terms (e.g., jpegtopnm). The programming library core aligns with BSD-like conditions, emphasizing no warranty and free redistribution while requiring notice preservation. These details are documented in the source code files and a comprehensive copyright summary maintained within the project.[41][42] The project, currently maintained by Bryan Henderson since 1999, explicitly states no warranties of any kind and permits commercial applications as long as license terms are honored. Redistribution of source code is unrestricted and freely available via SourceForge, while binaries must retain all original copyright, license, and disclaimer notices to comply with the varied terms. Historical Pbmplus elements remain public domain, whereas subsequent additions and ports specify their licenses directly in the respective source files, ensuring transparency for users integrating Netpbm components.[1][41]Distribution and Ports
Netpbm is primarily distributed through the SourceForge project page, where users can download source tarballs for stable releases, such as netpbm-10.86.48.tgz, released on September 27, 2025.[5] These archives contain the complete source code, which can be built and installed using standard tools like GNU Make after extracting the tarball and running./configure && make && make install.[43] The project also provides access to the source code via Subversion for the stable, advanced, and development branches, allowing users to check out and build the latest code.[44]
For easier installation on Unix-like systems, Netpbm is available through various package managers. On Debian and Ubuntu, it can be installed via apt install netpbm, which pulls in the necessary dependencies and places binaries in /usr/bin. On macOS, Homebrew users can run brew install netpbm to obtain a pre-built version compatible with the system. Fedora and related distributions support installation with dnf install netpbm, while FreeBSD users can build and install from the ports collection using cd /usr/ports/graphics/netpbm && make install clean.[45]
Netpbm has native support for Unix and Linux systems, with binaries typically installed to /usr/bin, header files to /usr/include/netpbm, and man pages to /usr/share/man. The package also includes a documentation directory, often at /usr/share/doc/netpbm, containing user manuals and format specifications. On Windows, Netpbm can be ported using Cygwin, where it is available as a package via the Cygwin setup installer, providing a POSIX environment for the tools.[46] Similarly, MSYS2 supports Netpbm through its pacman package manager, enabling native Windows builds with pacman -S mingw-w64-x86_64-netpbm. For embedded systems, the portable C codebase allows cross-compilation using toolchains like those for ARM or MIPS, often requiring configuration adjustments for minimal environments.[47]
Official stable releases are in the 10.xx series, with the 10.86.48 update in September 2025 focusing on bug fixes, improved format support, and enhanced compatibility across platforms. Some Linux distributions use their own versioning schemes, such as 11.xx. Beta branches, accessible via the advanced Subversion trunk, offer experimental features ahead of stabilization.[48] All distributions maintain license compliance, ensuring binaries are freely redistributable under the project's terms.[44]