[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

details Image Import/Export Facilities VIGRA

Classes

class  ImageExportInfo
 Argument object for the function exportImage(). More...
class  ImageImportInfo
 Argument object for the function importImage(). More...

Functions

template<... >
void exportImage (...)
 Write an image given a vigra::ImageExportInfo object.
template<... >
void exportImageAlpha (...)
 Write the image specified by the given vigra::ImageExportInfo object including an alpha channel.
std::string impexListExtensions ()
 List the file extension VIGRA understands.
std::string impexListFormats ()
 List the image formats VIGRA can read and write.
template<... >
void importImage (...)
 Read the image specified by the given vigra::ImageImportInfo object.
template<... >
void importImageAlpha (...)
 Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.
bool isImage (char const *filename)
 Test whether a file is an image format known to VIGRA.


Detailed Description

supports GIF, TIFF, JPEG, BMP, EXR, HDR, PNM (PBM, PGM, PPM), PNG, SunRaster, KHOROS-VIFF formats


Function Documentation

std::string vigra::impexListFormats ( )

List the image formats VIGRA can read and write.

This is useful for creating error messages if VIGRA encounters an image format it doesn't recognize.

Usage:

#include <vigra/imageinfo.hxx>
Namespace: vigra

        std::cout << "supported formats: " << vigra::impexListFormats() << std::endl;
Examples:
boundarytensor.cxx, convert.cxx, edge.cxx, invert.cxx, invert_explicitly.cxx, profile.cxx, pyramid.cxx, resize.cxx, smooth.cxx, subimage.cxx, total_variation.cxx, and watershed.cxx.
std::string vigra::impexListExtensions ( )

List the file extension VIGRA understands.

This is useful for creating file dialogs that only list image files VIGRA can actually import.

Usage:

#include <vigra/imageinfo.hxx>
Namespace: vigra

        std::cout << "supported extensions: " << vigra::impexListExtensions() << std::endl;
bool vigra::isImage ( char const *  filename)

Test whether a file is an image format known to VIGRA.

This checks the first few bytes of the file and compares them with the "magic strings" of each recognized image format.

Usage:

#include <vigra/imageinfo.hxx>
Namespace: vigra

    std::cout << "is image: " << vigra::isImage("foo.bmp") << std::endl;
void vigra::importImage (   ...)

Read the image specified by the given vigra::ImageImportInfo object.

Declarations

Pass arguments explicitly:

 namespace vigra {
     template <class ImageIterator, class Accessor>
     void
     importImage(const ImageImportInfo& importInfo,
                 ImageIterator imageIterator, Accessor imageAccessor)
 }

Use argument objects in conjunction with Argument Object Factories :

 namespace vigra {
     template <class ImageIterator, class Accessor>
     inline void
     importImage(const ImageImportInfo& importInfo,
                 const pair<ImageIterator, Accessor>& image)
 }

Usage

#include <vigra/impex.hxx>

Namespace: vigra

     ImageImportInfo info("myimage.gif");

     if (info.isGrayscale())
     {
         // create byte image of appropriate size
         BImage image(info.width(), info.height());

         importImage(info, destImage(image));
         ...
     }
     else
     {
         // create byte RGB image of appropriate size
         BRGBImage image(info.width(), info.height());

         importImage(info, destImage(image));
         ...
     }

Preconditions

  • The image file must be readable and
  • 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 | libexr? | | 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 | |

Examples:
boundarytensor.cxx, convert.cxx, edge.cxx, invert.cxx, invert_explicitly.cxx, profile.cxx, pyramid.cxx, resize.cxx, smooth.cxx, subimage.cxx, total_variation.cxx, and watershed.cxx.
void vigra::exportImage (   ...)

Write an image given a vigra::ImageExportInfo object.

If the file format to be exported to supports the pixel type of the source image, the pixel type will be kept (e.g. float can be stored as TIFF without conversion, in contrast to most other image export toolkits). Otherwise, the pixel values are transformed to the range 0..255 and converted to unsigned char. 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 arguments explicitly:

 namespace vigra {
     template <class ImageIterator, class ImageAccessor>
     void
     exportImage(ImageIterator imageUpperLeft, ImageIterator imageLowerRight, ImageAccessor imageAccessor,
                 const ImageExportInfo& exportInfo)
 }

Use argument objects in conjunction with Argument Object Factories :

     namespace vigra {
         template <class ImageIterator, class ImageAccessor>
         void exportImage(ImageIterator imageUpperLeft, ImageIterator imageLowerRight, ImageAccessor imageAccessor,
                          const ImageExportInfo& exportInfo)
     }

Usage

#include <vigra/impex.hxx>

Namespace: vigra

     BRGBImage image(width, height);
     ...

     // write as JPEG image, using compression quality 80
     exportImage(srcImageRange(image),
                 ImageExportInfo("my-image.jpg").setCompression("80"));

     // Force it to a particular pixel type.  The pixel type must be supported by the
     // desired image file format, otherwise an \ref vigra::PreconditionViolation
     // exception will be thrown.
     exportImage(srcImageRange(image),
                 ImageExportInfo("my-INT16-image.tif").setPixelType("INT16"));

Preconditions

  • The image file must be writable and
  • the file type must be one of the supported file types.
Examples:
boundarytensor.cxx, convert.cxx, edge.cxx, invert.cxx, invert_explicitly.cxx, palette.cxx, profile.cxx, pyramid.cxx, resize.cxx, smooth.cxx, subimage.cxx, total_variation.cxx, voronoi.cxx, and watershed.cxx.
void vigra::importImageAlpha (   ...)

Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.

Declarations

Pass arguments explicitly:

     namespace vigra {
         template <class ImageIterator, class ImageAccessor,
                   class AlphaIterator, class AlphaAccessor>
         void
         importImageAlpha(const ImageImportInfo& importInfo,
                          ImageIterator imageIterator, ImageAccessor imageAccessor,
                          AlphaIterator alphaIterator, AlphaAccessor alphaAccessor)
     }

Use argument objects in conjunction with Argument Object Factories :

     namespace vigra {
         template <class ImageIterator, class ImageAccessor,
                   class AlphaIterator, class AlphaAccessor>
         void
         importImageAlpha(const ImageImportInfo& importInfo,
                          const pair<ImageIterator, ImageAccessor>& image,
                          const pair<AlphaIterator, AlphaAccessor>& alpha)
     }

Usage

#include <vigra/impexalpha.hxx>

Namespace: vigra

     typedef UInt8 value_t;
     ImageImportInfo info("zorro.tif");

     if (info.isGrayscale())
     {
         BasicImage<value_t> alpha(info.size());
         BasicImage<value_t> image(info.size());

         importImageAlpha(info,
                          image.upperLeft(), image.accessor(),
                          alpha.upperLeft(), alpha.accessor());
         ...
     }
     else
     {
         BasicImage<value_t> alpha(info.size());
         BasicImage<vigra::RGBValue<value_t> > image(info.size());

         importImageAlpha(info,
                          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.
void vigra::exportImageAlpha (   ...)

Write the image specified by the given vigra::ImageExportInfo object including an alpha channel.

Declarations

Pass arguments explicitly:

     namespace vigra {
         template <class ImageIterator, class ImageAccessor,
                   class AlphaIterator, class AlphaAccessor>
         void
         exportImageAlpha(ImageIterator imageUpperLeft, ImageIterator imageLowerRight, ImageAccessor imageAccessor,
                          AlphaIterator alphaUpperLeft, AlphaAccessor alphaAccessor,
                          const ImageExportInfo& exportInfo)
     }

Use argument objects in conjunction with Argument Object Factories :

     namespace vigra {
     template <class ImageIterator, class ImageAccessor,
               class AlphaIterator, class AlphaAccessor>
     void
     exportImageAlpha(const triple<ImageIterator, ImageIterator, ImageAccessor>& image,
                      const pair<AlphaIterator, AlphaAccessor>& alpha,
                      const ImageExportInfo& exportInfo)
     }

Usage

#include <vigra/impexalpha.hxx>

Namespace: vigra

     typedef UInt8 value_t;
     ImageExportInfo info("zorro.tif");

     if (info.isGrayscale())
     {
         BasicImage<value_t> alpha;
         BasicImage<value_t> image;

         ...

         exportImageAlpha(image.upperLeft(), image.lowerRight(), image.accessor(),
                          alpha.upperLeft(), alpha.accessor(),
                          info);
     }
     else
     {
         BasicImage<value_t> alpha;
         BasicImage<vigra::RGBValue<value_t> > image;

         ...

         exportImageAlpha(image.upperLeft(), image.lowerRight(), image.accessor(),
                          alpha.upperLeft(), alpha.accessor(),
                          info);
     }

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.

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.9.0 (Tue Nov 6 2012)