[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
vigra/imageinfo.hxx | ![]() |
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2001 by Ullrich Koethe */ 00004 /* Copyright 2001-2002 by Gunnar Kedenburg */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* The VIGRA Website is */ 00008 /* http://hci.iwr.uni-heidelberg.de/vigra/ */ 00009 /* Please direct questions, bug reports, and contributions to */ 00010 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00011 /* vigra@informatik.uni-hamburg.de */ 00012 /* */ 00013 /* Permission is hereby granted, free of charge, to any person */ 00014 /* obtaining a copy of this software and associated documentation */ 00015 /* files (the "Software"), to deal in the Software without */ 00016 /* restriction, including without limitation the rights to use, */ 00017 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00018 /* sell copies of the Software, and to permit persons to whom the */ 00019 /* Software is furnished to do so, subject to the following */ 00020 /* conditions: */ 00021 /* */ 00022 /* The above copyright notice and this permission notice shall be */ 00023 /* included in all copies or substantial portions of the */ 00024 /* Software. */ 00025 /* */ 00026 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00027 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00028 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00029 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00030 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00031 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00032 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00033 /* OTHER DEALINGS IN THE SOFTWARE. */ 00034 /* */ 00035 /************************************************************************/ 00036 00037 /* Modifications by Pablo d'Angelo 00038 * updated to vigra 1.4 by Douglas Wilkins 00039 * as of 18 February 2006: 00040 * - Added UINT16 and UINT32 pixel types. 00041 * - Added support for obtaining extra bands beyond RGB. 00042 * - Added support for a position field that indicates the start of this 00043 * image relative to some global origin. 00044 * - Added support for x and y resolution fields. 00045 * - Added support for ICC profiles 00046 */ 00047 00048 #ifndef VIGRA_IMAGEINFO_HXX 00049 #define VIGRA_IMAGEINFO_HXX 00050 00051 #include <memory> 00052 #include <string> 00053 #include "config.hxx" 00054 #include "error.hxx" 00055 #include "diff2d.hxx" 00056 #include "codec.hxx" 00057 #include "array_vector.hxx" 00058 #include "multi_iterator.hxx" 00059 00060 namespace vigra 00061 { 00062 /** \addtogroup VigraImpex Image Import/Export Facilities 00063 00064 supports GIF, TIFF, JPEG, BMP, EXR, HDR, PNM (PBM, PGM, PPM), PNG, SunRaster, KHOROS-VIFF formats 00065 **/ 00066 //@{ 00067 00068 /** \brief List the image formats VIGRA can read and write. 00069 00070 This is useful for creating error messages if VIGRA encounters an 00071 image format it doesn't recognize. 00072 00073 <b> Usage:</b> 00074 00075 <b>\#include</b> <vigra/imageinfo.hxx><br> 00076 Namespace: vigra 00077 00078 \code 00079 std::cout << "supported formats: " << vigra::impexListFormats() << std::endl; 00080 \endcode 00081 00082 **/ 00083 VIGRA_EXPORT std::string impexListFormats(); 00084 00085 /** \brief List the file extension VIGRA understands. 00086 00087 This is useful for creating file dialogs that only list image files 00088 VIGRA can actually import. 00089 00090 <b> Usage:</b> 00091 00092 <b>\#include</b> <vigra/imageinfo.hxx><br> 00093 Namespace: vigra 00094 00095 \code 00096 std::cout << "supported extensions: " << vigra::impexListExtensions() << std::endl; 00097 \endcode 00098 00099 **/ 00100 VIGRA_EXPORT std::string impexListExtensions(); 00101 00102 /** \brief Test whether a file is an image format known to VIGRA. 00103 00104 This checks the first few bytes of the file and compares them with the 00105 "magic strings" of each recognized image format. 00106 00107 <b> Usage:</b> 00108 00109 <b>\#include</b> <vigra/imageinfo.hxx><br> 00110 Namespace: vigra 00111 00112 \code 00113 std::cout << "is image: " << vigra::isImage("foo.bmp") << std::endl; 00114 \endcode 00115 00116 **/ 00117 VIGRA_EXPORT bool isImage(char const * filename); 00118 00119 /********************************************************/ 00120 /* */ 00121 /* ImageExportInfo */ 00122 /* */ 00123 /********************************************************/ 00124 00125 /** \brief Argument object for the function exportImage(). 00126 00127 See \ref exportImage() for usage example. This object must be used 00128 to define the properties of an image to be written to disk. 00129 00130 <b>\#include</b> <vigra/imageinfo.hxx><br> 00131 Namespace: vigra 00132 **/ 00133 class ImageExportInfo 00134 { 00135 public: 00136 /** Construct ImageExportInfo object. 00137 00138 The image will be stored under the given filename. 00139 The file type will be guessed from the extension unless overridden 00140 by \ref setFileType(). Recognized extensions: '.bmp', '.exr', '.gif', 00141 '.jpeg', '.jpg', '.p7', '.png', '.pbm', '.pgm', '.pnm', '.ppm', '.ras', 00142 '.tif', '.tiff', '.xv', '.hdr'. 00143 EXR support requires libopenexr, JPEG support requires libjpeg, 00144 PNG support requires libpng and TIFF support requires libtiff. 00145 **/ 00146 VIGRA_EXPORT ImageExportInfo( const char *, const char * = "w" ); 00147 VIGRA_EXPORT ~ImageExportInfo(); 00148 00149 /** Set image file name. 00150 00151 The file type will be guessed from the extension unless overridden 00152 by \ref setFileType(). Recognized extensions: '.bmp', '.exr', '.gif', 00153 '.jpeg', '.jpg', '.p7', '.png', '.pbm', '.pgm', '.pnm', '.ppm', '.ras', 00154 '.tif', '.tiff', '.xv', '.hdr'. 00155 EXR support requires libopenexr, JPEG support requires libjpeg, 00156 PNG support requires libpng and TIFF support requires libtiff. 00157 **/ 00158 VIGRA_EXPORT ImageExportInfo & setFileName(const char * filename); 00159 VIGRA_EXPORT const char * getFileName() const; 00160 00161 /** Return the image file opening mode. 00162 **/ 00163 VIGRA_EXPORT const char * getMode() const; 00164 00165 /** Store image as given file type. 00166 00167 This will override any type guessed 00168 from the file name's extension. Recognized file types: 00169 00170 <DL> 00171 <DT>"BMP"<DD> Microsoft Windows bitmap image file. 00172 <DT>"EXR"<DD> OpenEXR high dynamic range image format. 00173 (only available if libopenexr is installed) 00174 <DT>"GIF"<DD> CompuServe graphics interchange format; 8-bit color. 00175 <DT>"HDR"<DD> Radiance RGBE high dynamic range image format. 00176 <DT>"JPEG"<DD> Joint Photographic Experts Group JFIF format; 00177 compressed 24-bit color (only available if libjpeg is installed). 00178 <DT>"PNG"<DD> Portable Network Graphic 00179 (only available if libpng is installed). 00180 <DT>"PBM"<DD> Portable bitmap format (black and white). 00181 <DT>"PGM"<DD> Portable graymap format (gray scale). 00182 <DT>"PNM"<DD> Portable anymap. 00183 <DT>"PPM"<DD> Portable pixmap format (color). 00184 <DT>"SUN"<DD> SUN Rasterfile. 00185 <DT>"TIFF"<DD> Tagged Image File Format. 00186 (only available if libtiff is installed.) 00187 <DT>"VIFF"<DD> Khoros Visualization image file. 00188 </DL> 00189 00190 With the exception of TIFF, VIFF, PNG, and PNM all file types store 00191 1 byte (gray scale and mapped RGB) or 3 bytes (RGB) per 00192 pixel. 00193 00194 PNG can store UInt8 and UInt16 values, and supports 1 and 3 channel 00195 images. One additional alpha channel is also supported. 00196 00197 PNM can store 1 and 3 channel images with UInt8, UInt16 and UInt32 00198 values in each channel. 00199 00200 TIFF and VIFF are additionally able to store short and long 00201 integers (2 or 4 bytes) and real values (32 bit float and 00202 64 bit double) without conversion. So you will need to use 00203 TIFF or VIFF if you need to store images with high 00204 accuracy (the appropriate type to write is automatically 00205 derived from the image type to be exported). However, many 00206 other programs using TIFF (e.g. ImageMagick) have not 00207 implemented support for those pixel types. So don't be 00208 surprised if the generated TIFF is not readable in some 00209 cases. If this happens, export the image as 'unsigned 00210 char' or 'RGBValue<unsigned char>' by calling 00211 \ref ImageExportInfo::setPixelType(). 00212 00213 Support to reading and writing ICC color profiles is 00214 provided for TIFF, JPEG, and PNG images. 00215 **/ 00216 VIGRA_EXPORT ImageExportInfo & setFileType( const char * ); 00217 VIGRA_EXPORT const char * getFileType() const; 00218 00219 /** Set compression type and quality. 00220 00221 This option is ignored when the target file format doesn't recognize 00222 the compression type. Valid arguments: 00223 00224 <DL> 00225 <DT>"NONE"<DD> (recognized by EXR and TIFF): do not compress (many other formats don't 00226 compress either, but it is not an option for them). 00227 <DT>"JPEG"<DD> (recognized by JPEG and TIFF): use JPEG compression. 00228 You can also specify a compression quality parameter by 00229 passing "JPEG QUALITY=N", where "N" must be an integer between 1 and 100 00230 (e.g. "JPEG QUALITY=70"). 00231 <DT>"JPEG-ARITH"<DD> (recognized by new versions of JPEG): use arithmetic coding as a back-end 00232 after JPEG compression (by default, the back-end is Huffman coding). 00233 You can also specify a compression quality parameter by 00234 passing "JPEG-ARITH QUALITY=N", where "N" must be an integer between 1 and 100 00235 (e.g. "JPEG-ARITH QUALITY=70"). 00236 <DT>"RLE", "RunLength"<DD> (recognized by EXR and TIFF): use run-length encoding. (BMP also 00237 uses run-length encoding, but there it is not an option). 00238 <DT>"PACKBITS"<DD> (recognized by TIFF): use packbits encoding (a variant of RLE). 00239 <DT>"DEFLATE"<DD> (recognized by TIFF): use deflate encoding, as defined in zlib (PNG also 00240 uses deflate, but there it is not an option). 00241 <DT>"LZW"<DD> (recognized by TIFF): use Lempel-Ziv-Welch encoding. 00242 <DT>"ZIP"<DD> (recognized by EXR): use zip-style encoding. 00243 <DT>"PIZ"<DD> (recognized by EXR): use wavelet encoding. 00244 <DT>"PXR24"<DD> (recognized by EXR): reduce to 24-bit, then use zip-style encoding. 00245 <DT>"B44", "B44A"<DD> (recognized by EXR): see OpenEXR documentation. 00246 <DT>"ASCII"<DD> (recognized by PNM): store pixels as ASCII (human readable numbers). 00247 <DT>"RAW"<DD> (recognized by PNM): store pixels as uncompressed binary data. 00248 <DT>"BILEVEL"<DD> (recognized by PNM): store as one bit per pixel. 00249 <DT>"1" ... "100"<DD> deprecated (equivalent to <tt>setCompression("JPEG QUALITY=number")</tt> 00250 where the number denotes the desired quality). 00251 </DL> 00252 00253 Some of these options (e.g. "JPEG-ARITH", "LZW", "B44", "B44A") may only be available when 00254 they have been enabled in the corresponding third-party library. 00255 **/ 00256 VIGRA_EXPORT ImageExportInfo & setCompression( const char * type); 00257 00258 VIGRA_EXPORT const char * getCompression() const; 00259 00260 /** Set the pixel type of the image file. Possible values are: 00261 <DL> 00262 <DT>"UINT8"<DD> 8-bit unsigned integer (unsigned char) 00263 <DT>"INT16"<DD> 16-bit signed integer (short) 00264 <DT>"UINT16"<DD> 16-bit unsigned integer (unsigned short) 00265 <DT>"INT32"<DD> 32-bit signed integer (long) 00266 <DT>"UINT32"<DD> 32-bit unsigned integer (unsigned long) 00267 <DT>"FLOAT"<DD> 32-bit floating point (float) 00268 <DT>"DOUBLE"<DD> 64-bit floating point (double) 00269 </DL> 00270 00271 <b>Usage:</b> 00272 00273 \code 00274 FImage img(w,h); 00275 00276 // by default, float images are exported with pixeltype float 00277 // when the target format support this type, i.e. is TIFF or VIFF. 00278 exportImage(srcImageRange(img), ImageExportInfo("asFloat.tif")); 00279 00280 // if this is not desired, force a different pixeltype 00281 exportImage(srcImageRange(img), ImageExportInfo("asByte.tif").setPixelType("UINT8")); 00282 \endcode 00283 **/ 00284 VIGRA_EXPORT ImageExportInfo & setPixelType( const char * ); 00285 00286 /** Get the pixel type of the image. Possible values are: 00287 <DL> 00288 <DT>"UINT8"<DD> 8-bit unsigned integer (unsigned char) 00289 <DT>"INT16"<DD> 16-bit signed integer (short) 00290 <DT>"INT32"<DD> 32-bit signed integer (long) 00291 <DT>"FLOAT"<DD> 32-bit floating point (float) 00292 <DT>"DOUBLE"<DD> 64-bit floating point (double) 00293 </DL> 00294 **/ 00295 VIGRA_EXPORT const char * getPixelType() const; 00296 00297 VIGRA_EXPORT ImageExportInfo & setForcedRangeMapping(double fromMin, double fromMax, 00298 double toMin, double toMax); 00299 VIGRA_EXPORT bool hasForcedRangeMapping() const; 00300 VIGRA_EXPORT double getFromMin() const; 00301 VIGRA_EXPORT double getFromMax() const; 00302 VIGRA_EXPORT double getToMin() const; 00303 VIGRA_EXPORT double getToMax() const; 00304 00305 /** Set the image resolution in horizontal direction 00306 **/ 00307 VIGRA_EXPORT ImageExportInfo & setXResolution( float ); 00308 VIGRA_EXPORT float getXResolution() const; 00309 00310 /** Set the image resolution in vertical direction 00311 **/ 00312 VIGRA_EXPORT ImageExportInfo & setYResolution( float ); 00313 VIGRA_EXPORT float getYResolution() const; 00314 00315 /** Set the position of the upper Left corner on a global 00316 canvas. 00317 00318 Currently only supported by TIFF, PNG and OpenEXR files. 00319 00320 The offset is encoded in the XPosition and YPosition TIFF tags. 00321 00322 @param pos position of the upper left corner in pixels 00323 (must be >= 0) 00324 **/ 00325 VIGRA_EXPORT ImageExportInfo & setPosition(const Diff2D & pos); 00326 00327 /** Get the position of the upper left corner on 00328 a global canvas. 00329 **/ 00330 VIGRA_EXPORT Diff2D getPosition() const; 00331 00332 /** Get the size of the canvas, on which the image is positioned at 00333 getPosition() 00334 **/ 00335 VIGRA_EXPORT Size2D getCanvasSize() const; 00336 00337 /** Get the size of the canvas, on which the image is positioned at 00338 getPosition() 00339 **/ 00340 VIGRA_EXPORT ImageExportInfo & setCanvasSize(const Size2D & size); 00341 00342 /** 00343 ICC profiles (handled as raw data so far). 00344 see getICCProfile()/setICCProfile() 00345 **/ 00346 typedef ArrayVector<unsigned char> ICCProfile; 00347 00348 /** Returns a reference to the ICC profile. 00349 */ 00350 VIGRA_EXPORT const ICCProfile & getICCProfile() const; 00351 00352 /** Sets the ICC profile. 00353 ICC profiles are currently supported by TIFF, PNG and JPEG images. 00354 (Otherwise, the profile data is silently ignored.) 00355 **/ 00356 VIGRA_EXPORT ImageExportInfo & setICCProfile(const ICCProfile & profile); 00357 00358 private: 00359 std::string m_filename, m_filetype, m_pixeltype, m_comp, m_mode; 00360 float m_x_res, m_y_res; 00361 Diff2D m_pos; 00362 ICCProfile m_icc_profile; 00363 Size2D m_canvas_size; 00364 double fromMin_, fromMax_, toMin_, toMax_; 00365 }; 00366 00367 // return an encoder for a given ImageExportInfo object 00368 VIGRA_EXPORT std::auto_ptr<Encoder> encoder( const ImageExportInfo & info ); 00369 00370 /********************************************************/ 00371 /* */ 00372 /* ImageImportInfo */ 00373 /* */ 00374 /********************************************************/ 00375 00376 /** \brief Argument object for the function importImage(). 00377 00378 See \ref importImage() for a usage example. This object must be 00379 used to read an image from disk and enquire about its properties. 00380 00381 <b>\#include</b> <vigra/imageinfo.hxx><br> 00382 Namespace: vigra 00383 **/ 00384 class ImageImportInfo 00385 { 00386 public: 00387 enum PixelType { UINT8, INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE }; 00388 00389 /** Construct ImageImportInfo object. 00390 00391 The image with the given filename is read into memory. 00392 The file type will be determined by the first few bytes of the 00393 file (magic number). Recognized file types: 00394 00395 <DL> 00396 <DT>"BMP"<DD> Microsoft Windows bitmap image file. 00397 <DT>"EXR"<DD> OpenEXR high dynamic range image format. 00398 (only available if libopenexr is installed) 00399 <DT>"GIF"<DD> CompuServe graphics interchange format; 8-bit color. 00400 <DT>"HDR"<DD> Radiance RGBE high dynamic range image format. 00401 <DT>"JPEG"<DD> Joint Photographic Experts Group JFIF format; 00402 compressed 24-bit color (only available if libjpeg is installed). 00403 <DT>"PNG"<DD> Portable Network Graphic 00404 (only available if libpng is installed). 00405 <DT>"PBM"<DD> Portable bitmap format (black and white). 00406 <DT>"PGM"<DD> Portable graymap format (gray scale). 00407 <DT>"PNM"<DD> Portable anymap. 00408 <DT>"PPM"<DD> Portable pixmap format (color). 00409 <DT>"SUN"<DD> SUN Rasterfile. 00410 <DT>"TIFF"<DD> Tagged Image File Format. 00411 (only available if libtiff is installed.) 00412 <DT>"VIFF"<DD> Khoros Visualization image file. 00413 </DL> 00414 **/ 00415 VIGRA_EXPORT ImageImportInfo( const char *, unsigned int = 0 ); 00416 VIGRA_EXPORT ~ImageImportInfo(); 00417 00418 VIGRA_EXPORT const char * getFileName() const; 00419 00420 /** Get the file type of the image associated with this 00421 info object. 00422 00423 See ImageImportInfo::ImageImportInfo for a list of the 00424 available file types. 00425 **/ 00426 VIGRA_EXPORT const char * getFileType() const; 00427 00428 /** Get width of the image. 00429 **/ 00430 VIGRA_EXPORT int width() const; 00431 00432 /** Get height of the image. 00433 **/ 00434 VIGRA_EXPORT int height() const; 00435 00436 /** Get the total number of bands in the image. 00437 **/ 00438 VIGRA_EXPORT int numBands() const; 00439 00440 /** Get the number of extra (non color) bands in the image. 00441 ** Usually these are the alpha channels. 00442 **/ 00443 VIGRA_EXPORT int numExtraBands() const; 00444 00445 /** Get the number of images contained in the image file. 00446 **/ 00447 VIGRA_EXPORT int numImages() const; 00448 00449 /** Sets the index of the image to import from the image file. 00450 **/ 00451 VIGRA_EXPORT void setImageIndex(const int); 00452 00453 /** Gets the index of the image to import from the image file. 00454 **/ 00455 VIGRA_EXPORT int getImageIndex() const; 00456 00457 /** Get size of the image. 00458 **/ 00459 VIGRA_EXPORT Size2D size() const; 00460 00461 /** Get size of the image in a form compatible to MultiArray. 00462 **/ 00463 VIGRA_EXPORT MultiArrayShape<2>::type shape() const; 00464 00465 /** Returns true if the image is gray scale. 00466 **/ 00467 VIGRA_EXPORT bool isGrayscale() const; 00468 00469 /** Returns true if the image is colored (RGB). 00470 **/ 00471 VIGRA_EXPORT bool isColor() const; 00472 00473 /** Query the pixel type of the image. 00474 00475 Possible values are: 00476 <DL> 00477 <DT>"UINT8"<DD> 8-bit unsigned integer (unsigned char) 00478 <DT>"INT16"<DD> 16-bit signed integer (short) 00479 <DT>"UINT16"<DD> 16-bit unsigned integer (unsigned short) 00480 <DT>"INT32"<DD> 32-bit signed integer (long) 00481 <DT>"UINT32"<DD> 32-bit unsigned integer (unsigned long) 00482 <DT>"FLOAT"<DD> 32-bit floating point (float) 00483 <DT>"DOUBLE"<DD> 64-bit floating point (double) 00484 </DL> 00485 **/ 00486 VIGRA_EXPORT const char * getPixelType() const; 00487 00488 /** Query the pixel type of the image. 00489 00490 Same as getPixelType(), but the result is returned as a 00491 ImageImportInfo::PixelType enum. This is useful to implement 00492 a switch() on the pixel type. 00493 00494 Possible values are: 00495 <DL> 00496 <DT>UINT8<DD> 8-bit unsigned integer (unsigned char) 00497 <DT>INT16<DD> 16-bit signed integer (short) 00498 <DT>UINT16<DD> 16-bit unsigned integer (unsigned short) 00499 <DT>INT32<DD> 32-bit signed integer (long) 00500 <DT>UINT32<DD> 32-bit unsigned integer (unsigned long) 00501 <DT>FLOAT<DD> 32-bit floating point (float) 00502 <DT>DOUBLE<DD> 64-bit floating point (double) 00503 </DL> 00504 **/ 00505 VIGRA_EXPORT PixelType pixelType() const; 00506 00507 /** Returns true if the image has 1 byte per pixel (gray) or 00508 3 bytes per pixel (RGB). 00509 **/ 00510 VIGRA_EXPORT bool isByte() const; 00511 00512 /** Returns the layer offset of the current image, if there is one 00513 **/ 00514 VIGRA_EXPORT Diff2D getPosition() const; 00515 00516 /** Get the size of the canvas, on which the image is positioned at 00517 getPosition() 00518 **/ 00519 VIGRA_EXPORT Size2D getCanvasSize() const; 00520 00521 /** Returns the image resolution in horizontal direction 00522 **/ 00523 VIGRA_EXPORT float getXResolution() const; 00524 00525 /** Returns the image resolution in vertical direction 00526 **/ 00527 VIGRA_EXPORT float getYResolution() const; 00528 00529 /** 00530 ICC profiles (handled as raw data so far). 00531 see getICCProfile()/setICCProfile() 00532 **/ 00533 typedef ArrayVector<unsigned char> ICCProfile; 00534 00535 /** Returns a reference to the ICC profile. 00536 00537 Note: The reference will become invalid when the 00538 ImageImportInfo object has been destroyed. 00539 **/ 00540 VIGRA_EXPORT const ICCProfile & getICCProfile() const; 00541 00542 private: 00543 std::string m_filename, m_filetype, m_pixeltype; 00544 int m_width, m_height, m_num_bands, m_num_extra_bands, m_num_images, m_image_index; 00545 float m_x_res, m_y_res; 00546 Diff2D m_pos; 00547 Size2D m_canvas_size; 00548 ICCProfile m_icc_profile; 00549 00550 void readHeader_(); 00551 }; 00552 00553 // return a decoder for a given ImageImportInfo object 00554 VIGRA_EXPORT std::auto_ptr<Decoder> decoder( const ImageImportInfo & info ); 00555 00556 //@} 00557 00558 } // namespace vigra 00559 00560 #endif // VIGRA_IMAGEINFO_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|