Detailed Description
supports GIF, TIFF, JPEG, BMP, EXR, HDR, PNM (PBM, PGM, PPM), PNG, SunRaster, KHOROS-VIFF formats
◆ importImage()
Read an image from a file.
If the first parameter is vigra::ImageImportInfo, this function assumes that the destination image has already the appropriate shape. If the first parameter is a string, the destination must be a vigra::MultiArray reference, which will be reshaped automatically.
If the input image has only a single band, but the destination has multiple bands (e.g. is an RGB image), all bands will receive the same data. When a multi-band file is read into a single-band destination array, only the first band is read. Any other mismatch between the number of bands in input and output is an error and will throw a precondition exception.
Declarations
pass 2D array views:
template <class T, class S>
void
template <class T, class A>
void
template <class T, class A>
void
}
Argument object for the function importImage().
Definition: imageinfo.hxx:391
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:705
Main MultiArray class containing the memory management.
Definition: multi_array.hxx:2477
void importImage(...)
Read an image from a file.
show deprecated declarations
pass
Image Iterators and
Data Accessors :
template <class ImageIterator, class Accessor>
void
}
Standard 2D random access iterator for images that store the data in a linear array.
Definition: imageiterator.hxx:851
Use argument objects in conjunction with
Argument Object Factories :
template <class ImageIterator, class Accessor>
void
const pair<ImageIterator, Accessor>& image)
}
Usage:
#include <vigra/impex.hxx>
Namespace: vigra
if (info.isGrayscale())
{
...
}
else
{
MultiArray<2, RGBValue<unsigned char> > image(info.width(), info.height());
...
}
When the type of input image is already known, this can be shortened:
show deprecated examples
if (info.isGrayscale())
{
BImage image(info.width(), info.height());
...
}
else
{
BRGBImage image(info.width(), info.height());
...
}
Fundamental class template for images.
Definition: basicimage.hxx:476
BasicImage< RGBValue< UInt8 > > BRGBImage
Definition: stdimage.hxx:164
Preconditions
- The image file must be readable.
- The required support library must be installed (if the table doesn't specify an external library, VIGRA supports the format natively).
- The file type must be one of the following:
Type | Extension | Name | Support Library |
BMP | bmp | Microsoft Windows bitmap image file | |
EXR | exr | OpenEXR high dynamic range image format | libopenexr |
GIF | gif | CompuServe graphics interchange format, 8-bit color | |
HDR | hdr | Radiance RGBE high dynamic range image format | |
JPEG | jpg, jpeg | Joint Photographic Experts Group JFIF format, 24-bit color | libjpeg |
PBM | pbm | Portable bitmap format (black and white) | |
PGM | pgm | Portable graymap format (gray scale) | |
PNG | png | Portable Network Graphic | libpng |
PNM | pnm | Portable anymap | |
PPM | ppm | Portable pixmap format (color) | |
SUN | ras | SUN Rasterfile | |
TIFF | tif, tiff | Tagged Image File Format | libtiff |
VIFF | xv | Khoros Visualization image file | |
◆ exportImage()
Write an image to a file.
The file can be specified either by a file name or by a vigra::ImageExportInfo object. In the latter case, you have much more control about how the file is written. By default, the file format to be created is guessed from the filename extension. This can be overridden by an explicit file type in the ImageExportInfo object. If the file format supports compression (e.g. JPEG and TIFF), default compression parameters are used which can be overridden by the ImageExportInfo object.
If the file format to be created supports the pixel type of the source image, this pixel type will be kept in the file (e.g. float
can be stored by TIFF without conversion) unless the ImageExportInfo object explicitly requests a different storage type. If the array's pixel type is not supported by the file format, the pixel values are transformed to the range 0..255 and converted to unsigned char
, unless another mapping is explicitly requested by the ImageExportInfo object.
Currently, the following file formats are supported. The pixel types given in brackets are those that are written without conversion:
- BMP: Microsoft Windows bitmap image file (pixel types: UINT8 as gray and RGB);
- GIF: CompuServe graphics interchange format, 8-bit color (pixel types: UINT8 as gray and RGB);
- JPEG: Joint Photographic Experts Group JFIF format, compressed 24-bit color (pixel types: UINT8 as gray and RGB), only available if libjpeg is installed;
- PNG: Portable Network Graphic (pixel types: UINT8 and UINT16 with up to 4 channels), only available if libpng is installed;
- PBM: Portable bitmap format (black and white);
- PGM: Portable graymap format (pixel types: UINT8, INT16, INT32 as gray scale);
- PNM: Portable anymap (pixel types: UINT8, INT16, INT32 as gray and RGB);
- PPM: Portable pixmap format (pixel types: UINT8, INT16, INT32 as RGB);
- SUN: SUN Rasterfile (pixel types: UINT8 as gray and RGB);
- TIFF: Tagged Image File Format (pixel types: UINT8, INT16, INT32, FLOAT, DOUBLE with up to 4 channels), only available if libtiff is installed;
- VIFF: Khoros Visualization image file (pixel types: UINT8, INT16, INT32, FLOAT, DOUBLE with arbitrary many channels);
Declarations
pass 2D array views:
template <class T, class S>
void
template <class T, class S>
void
char const * filename);
template <class T, class S>
void
std::string const & filename);
}
Argument object for the function exportImage().
Definition: imageinfo.hxx:134
void exportImage(...)
Write an image to a file.
show deprecated declarations
Usage:
#include <vigra/impex.hxx>
Namespace: vigra
show deprecated examples
...
exportImage(srcImageRange(image),
Preconditions
- The image file must be writable and
- the file type must be one of the supported file types.
◆ importImageAlpha()
void importImageAlpha |
( |
|
... | ) |
|
Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.
See importImage() for more information.
Declarations
pass 2D array views:
template <class T1, class S1,
class T2, class S2>
void
}
void importImageAlpha(...)
Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.
show deprecated declarations
pass
Image Iterators and
Data Accessors :
class AlphaIterator, class AlphaAccessor>
void
AlphaIterator alphaIterator, AlphaAccessor alphaAccessor)
}
Use argument objects in conjunction with
Argument Object Factories :
class AlphaIterator, class AlphaAccessor>
void
const pair<ImageIterator, ImageAccessor>& image,
const pair<AlphaIterator, AlphaAccessor>& alpha)
}
Usage:
#include <vigra/impexalpha.hxx>
Namespace: vigra
if (info.isGrayscale())
{
...
}
else
{
MultiArray<2, value_t> alpha(info.shape());
MultiArray<2, RGBValue<value_t> > image(info.shape());
...
}
detail::SelectIntegerType< 8, detail::UnsignedIntTypes >::type UInt8
8-bit unsigned int
Definition: sized_int.hxx:179
show deprecated examples
if (info.isGrayscale())
{
image.upperLeft(), image.accessor(),
alpha.upperLeft(), alpha.accessor());
...
}
else
{
BasicImage<value_t> alpha(info.size());
BasicImage<vigra::RGBValue<value_t> > image(info.size());
image.upperLeft(), image.accessor(),
alpha.upperLeft(), alpha.accessor());
...
}
Preconditions
- The same preconditions hold as for importImage(), however the only image formats that support alpha channels are
- TIFF and
- PNG. In particular, JPEG does not support alpha channels.
- The alpha channel always is scalar-valued, i.e. comprises a single band.
◆ exportImageAlpha()
void exportImageAlpha |
( |
|
... | ) |
|
Write the image and its alpha channel to a file.
See exportImage() for more information.
Declarations
pass 2D array views:
template <class T1, class S1,
class T2, class S2>
void
template <class T1, class S1,
class T2, class S2>
void
char const * filename)
template <class T1, class S1,
class T2, class S2>
void
std::string const & filename)
}
void exportImageAlpha(...)
Write the image and its alpha channel to a file.
show deprecated declarations
pass
Image Iterators and
Data Accessors :
class AlphaIterator, class AlphaAccessor>
void
AlphaIterator alphaUpperLeft, AlphaAccessor alphaAccessor,
}
Use argument objects in conjunction with
Argument Object Factories :
class AlphaIterator, class AlphaAccessor>
void
exportImageAlpha(
const triple<ImageIterator, ImageIterator, ImageAccessor>& image,
const pair<AlphaIterator, AlphaAccessor>& alpha,
}
Usage:
#include <vigra/impexalpha.hxx>
Namespace: vigra
show deprecated examples
if (info.isGrayscale())
{
...
info);
}
else
{
BasicImage<value_t> alpha;
BasicImage<vigra::RGBValue<value_t> > image;
...
alpha.upperLeft(), alpha.accessor(),
info);
}
Accessor accessor()
Definition: basicimage.hxx:1066
traverser lowerRight()
Definition: basicimage.hxx:936
traverser upperLeft()
Definition: basicimage.hxx:925
Preconditions
- The same preconditions hold as for exportImage(), however the only image formats that support alpha channels are
- TIFF and
- PNG. In particular, JPEG does not support alpha channels.
- The alpha channel always is scalar-valued, i.e. comprises a single band.