18#ifndef MVE_NO_PNG_SUPPORT
22#ifndef MVE_NO_JPEG_SUPPORT
30#ifndef MVE_NO_TIFF_SUPPORT
42#define PPM_MAX_PIXEL_AMOUNT (16384 * 16384)
45#define MVEI_FILE_SIGNATURE "\211MVE_IMAGE\n"
46#define MVEI_FILE_SIGNATURE_LEN 11
47#define MVEI_MAX_PIXEL_AMOUNT (16384 * 16384)
61#ifndef MVE_NO_PNG_SUPPORT
68#ifndef MVE_NO_JPEG_SUPPORT
75#ifndef MVE_NO_TIFF_SUPPORT
93 return std::dynamic_pointer_cast<ByteImage>(image);
111#ifndef MVE_NO_PNG_SUPPORT
118#ifndef MVE_NO_JPEG_SUPPORT
125#ifndef MVE_NO_TIFF_SUPPORT
149 std::string fext4 = lowercase(right(filename, 4));
150 std::string fext5 = lowercase(right(filename, 5));
152#ifndef MVE_NO_JPEG_SUPPORT
153 if (fext4 ==
".jpg" || fext5 ==
".jpeg")
160#ifndef MVE_NO_PNG_SUPPORT
168#ifndef MVE_NO_TIFF_SUPPORT
169 if (fext4 ==
".tif" || fext5 ==
".tiff")
196 std::string fext4 = lowercase(right(filename, 4));
199 save_pfm_file(image, filename);
207save_file (FloatImage::Ptr image, std::string
const& filename)
209 save_file(FloatImage::ConstPtr(image), filename);
214#ifndef MVE_NO_PNG_SUPPORT
219 load_png_headers_intern (FILE* fp, ImageHeaders* headers,
220 png_structp* png, png_infop* png_info)
223 png_byte signature[8];
224 if (std::fread(signature, 1, 8, fp) != 8)
229 if (png_sig_cmp(signature, 0, 8) != 0)
236 *png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
237 nullptr,
nullptr,
nullptr);
244 *png_info = png_create_info_struct(*png);
247 png_destroy_read_struct(png,
nullptr,
nullptr);
253 png_init_io(*png, fp);
254 png_set_sig_bytes(*png, 8);
257 png_read_info(*png, *png_info);
259 headers->width = png_get_image_width(*png, *png_info);
260 headers->height = png_get_image_height(*png, *png_info);
261 headers->channels = png_get_channels(*png, *png_info);
263 int const bit_depth = png_get_bit_depth(*png, *png_info);
266 else if (bit_depth == 16)
270 png_destroy_read_struct(png, png_info,
nullptr);
281 FILE* fp = std::fopen(filename.c_str(),
"rb");
287 png_structp png =
nullptr;
288 png_infop png_info =
nullptr;
289 load_png_headers_intern(fp, &headers, &png, &png_info);
292 int const bit_depth = png_get_bit_depth(png, png_info);
295 png_destroy_read_struct(&png, &png_info,
nullptr);
301 int const color_type = png_get_color_type(png, png_info);
302 if (color_type == PNG_COLOR_TYPE_PALETTE)
303 png_set_palette_to_rgb(png);
304 if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
305 png_set_expand_gray_1_2_4_to_8(png);
306 if (png_get_valid(png, png_info, PNG_INFO_tRNS))
307 png_set_tRNS_to_alpha(png);
310 png_read_update_info(png, png_info);
318 std::vector<png_bytep> row_pointers;
319 row_pointers.resize(headers.
height);
320 for (
int i = 0; i < headers.
height; ++i)
321 row_pointers[i] = &data[i * headers.
width * headers.
channels];
324 png_read_image(png, &row_pointers[0]);
327 png_destroy_read_struct(&png, &png_info,
nullptr);
336 FILE* fp = std::fopen(filename.c_str(),
"rb");
342 png_structp png =
nullptr;
343 png_infop png_info =
nullptr;
344 load_png_headers_intern(fp, &headers, &png, &png_info);
347 png_destroy_read_struct(&png, &png_info,
nullptr);
355 std::string
const& filename,
int compression_level)
357 if (image ==
nullptr)
358 throw std::invalid_argument(
"Null image given");
360 FILE *fp = std::fopen(filename.c_str(),
"wb");
366 png_structp png_ptr = png_create_write_struct
367 (PNG_LIBPNG_VER_STRING,
nullptr,
nullptr,
nullptr);
375 png_infop info_ptr = png_create_info_struct(png_ptr);
378 png_destroy_write_struct(&png_ptr, (png_infopp)
nullptr);
383 png_init_io(png_ptr, fp);
390 switch (image->channels())
392 case 1: color_type = PNG_COLOR_TYPE_GRAY;
break;
393 case 2: color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
break;
394 case 3: color_type = PNG_COLOR_TYPE_RGB;
break;
395 case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
398 png_destroy_write_struct(&png_ptr, &info_ptr);
405 png_set_compression_level(png_ptr, compression_level);
408 png_set_IHDR(png_ptr, info_ptr, image->width(), image->height(),
409 8 , color_type, PNG_INTERLACE_NONE,
410 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
413 std::vector<png_bytep> row_pointers;
414 row_pointers.resize(image->height());
416 for (
int i = 0; i < image->height(); ++i)
417 row_pointers[i] =
const_cast<png_bytep
>(
418 &data[i * image->width() * image->channels()]);
421 int png_transforms = PNG_TRANSFORM_IDENTITY;
425 png_set_rows(png_ptr, info_ptr, &row_pointers[0]);
426 png_write_png(png_ptr, info_ptr, png_transforms,
nullptr);
427 png_write_end(png_ptr, info_ptr);
430 png_destroy_write_struct(&png_ptr, &info_ptr);
438#ifndef MVE_NO_JPEG_SUPPORT
456 FILE* fp = std::fopen(filename.c_str(),
"rb");
460 jpeg_decompress_struct cinfo;
466 cinfo.err = jpeg_std_error(&jerr);
469 jpeg_create_decompress(&cinfo);
470 jpeg_stdio_src(&cinfo, fp);
475 jpeg_save_markers(&cinfo, JPEG_APP0 + 1, 0xffff);
479 int ret = jpeg_read_header(&cinfo,
static_cast<boolean>(
false));
480 if (ret != JPEG_HEADER_OK)
486 jpeg_saved_marker_ptr marker = cinfo.marker_list;
487 if (marker !=
nullptr && marker->marker == JPEG_APP0 + 1
488 && marker->data_length > 6
489 && std::equal(marker->data, marker->data + 6,
"Exif\0\0"))
491 char const* data =
reinterpret_cast<char const*
>(marker->data);
492 exif->append(data, data + marker->data_length);
496 if (cinfo.out_color_space != JCS_GRAYSCALE
497 && cinfo.out_color_space != JCS_RGB)
501 int const width = cinfo.image_width;
502 int const height = cinfo.image_height;
503 int const channels = (cinfo.out_color_space == JCS_RGB ? 3 : 1);
504 image = ByteImage::create(width, height, channels);
508 jpeg_start_decompress(&cinfo);
510 unsigned char* data_ptr = &data[0];
511 while (cinfo.output_scanline < cinfo.output_height)
513 jpeg_read_scanlines(&cinfo, &data_ptr, 1);
514 data_ptr += channels * cinfo.output_width;
518 jpeg_finish_decompress(&cinfo);
519 jpeg_destroy_decompress(&cinfo);
524 jpeg_destroy_decompress(&cinfo);
535 FILE* fp = std::fopen(filename.c_str(),
"rb");
539 jpeg_decompress_struct cinfo;
545 cinfo.err = jpeg_std_error(&jerr);
548 jpeg_create_decompress(&cinfo);
549 jpeg_stdio_src(&cinfo, fp);
552 int ret = jpeg_read_header(&cinfo,
static_cast<boolean>(
false));
553 if (ret != JPEG_HEADER_OK)
556 if (cinfo.out_color_space != JCS_GRAYSCALE
557 && cinfo.out_color_space != JCS_RGB)
560 headers.
width = cinfo.image_width;
561 headers.
height = cinfo.image_height;
562 headers.
channels = (cinfo.out_color_space == JCS_RGB ? 3 : 1);
565 jpeg_destroy_decompress(&cinfo);
570 jpeg_destroy_decompress(&cinfo);
582 if (image ==
nullptr)
583 throw std::invalid_argument(
"Null image given");
585 if (image->channels() != 1 && image->channels() != 3)
588 FILE* fp = std::fopen(filename.c_str(),
"wb");
592 jpeg_compress_struct cinfo;
596 cinfo.err = jpeg_std_error(&jerr);
597 jpeg_create_compress(&cinfo);
598 jpeg_stdio_dest(&cinfo, fp);
601 cinfo.image_width = image->width();
602 cinfo.image_height = image->height();
603 cinfo.input_components = image->channels();
604 cinfo.in_color_space = (image->channels() == 1 ? JCS_GRAYSCALE : JCS_RGB);
607 jpeg_set_defaults(&cinfo);
608 jpeg_set_quality(&cinfo, quality, TRUE);
609 jpeg_start_compress(&cinfo, TRUE);
612 int row_stride = image->width() * image->channels();
613 while (cinfo.next_scanline < cinfo.image_height)
615 JSAMPROW row_pointer =
const_cast<JSAMPROW
>(
616 &data[cinfo.next_scanline * row_stride]);
617 jpeg_write_scanlines(&cinfo, &row_pointer, 1);
619 jpeg_finish_compress(&cinfo);
620 jpeg_destroy_compress(&cinfo);
628#ifndef MVE_NO_TIFF_SUPPORT
634 ::vsprintf(msg, fmt, ap);
642 TIFFSetWarningHandler(
nullptr);
645 TIFF* tif = TIFFOpen(filename.c_str(),
"r");
651 uint32_t width, height;
652 uint16_t channels, bits, sampleFormat;
653 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
654 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
655 TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &channels);
656 TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits);
657 TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &sampleFormat);
659 headers.
width = width;
665 switch(sampleFormat) {
666 case SAMPLEFORMAT_UINT:
669 case SAMPLEFORMAT_INT:
672 case SAMPLEFORMAT_IEEEFP:
678 }
else if (bits == 16) {
679 switch(sampleFormat) {
680 case SAMPLEFORMAT_UINT:
683 case SAMPLEFORMAT_INT:
686 case SAMPLEFORMAT_IEEEFP:
692 }
else if (bits == 32) {
693 switch(sampleFormat) {
694 case SAMPLEFORMAT_UINT:
697 case SAMPLEFORMAT_INT:
700 case SAMPLEFORMAT_IEEEFP:
706 }
else if (bits == 64) {
707 switch(sampleFormat) {
708 case SAMPLEFORMAT_UINT:
711 case SAMPLEFORMAT_INT:
714 case SAMPLEFORMAT_IEEEFP:
723 throw util::Exception(
"TIFF file has unsupported bits and/or sample format.");
729 catch (std::exception& e)
739 TIFFSetWarningHandler(
nullptr);
742 TIFF* tif = TIFFOpen(filename.c_str(),
"r");
749 uint32_t width, height;
750 uint16_t channels, bits;
751 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
752 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
753 TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &channels);
754 TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits);
757 ByteImage::Ptr image = ByteImage::create(width, height, channels);
760 uint32_t rowstride = TIFFScanlineSize(tif);
762 for (uint32_t row = 0; row < height; row++)
764 tdata_t row_pointer = &data[row * rowstride];
765 TIFFReadScanline(tif, row_pointer, row);
771 catch (std::exception& e)
781 if (image ==
nullptr)
782 throw std::invalid_argument(
"Null image given");
784 TIFF* tif = TIFFOpen(filename.c_str(),
"w");
788 uint32_t width = image->width();
789 uint32_t height = image->height();
790 uint32_t channels = image->channels();
791 TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
792 TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
793 TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, channels);
794 TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
795 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
796 TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
797 TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
799 tdata_t buffer =
const_cast<uint8_t*
>(image->get_data_pointer());
800 int64_t ret = TIFFWriteEncodedStrip(tif, 0, buffer,
801 image->get_value_amount());
812 if (
sizeof(uint16_t) != 2)
815 TIFFSetWarningHandler(
nullptr);
818 TIFF* tif = TIFFOpen(filename.c_str(),
"r");
825 uint32_t width, height;
826 uint16_t channels, bits;
827 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
828 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
829 TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &channels);
830 TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits);
837 uint32_t rowstride = TIFFScanlineSize(tif) /
sizeof(uint16_t);
839 for (uint32_t row = 0; row < height; row++)
841 tdata_t row_pointer = &data[row * rowstride];
842 TIFFReadScanline(tif, row_pointer, row);
848 catch (std::exception& e)
858 if (image ==
nullptr)
859 throw std::invalid_argument(
"Null image given");
861 TIFF* tif = TIFFOpen(filename.c_str(),
"w");
865 uint32_t width = image->width();
866 uint32_t height = image->height();
867 uint32_t channels = image->channels();
868 TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
869 TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
870 TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, channels);
871 TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8 *
sizeof(uint16_t));
872 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
873 TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
874 TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
876 tdata_t buffer =
const_cast<uint16_t*
>(image->get_data_pointer());
877 int64_t ret = TIFFWriteEncodedStrip(tif, 0, buffer,
878 image->get_value_amount() *
sizeof(uint16_t));
889 if (
sizeof(
float) != 4)
892 TIFFSetWarningHandler(
nullptr);
895 TIFF* tif = TIFFOpen(filename.c_str(),
"r");
902 uint32_t width, height;
903 uint16_t channels, bits;
904 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
905 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
906 TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &channels);
907 TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits);
914 uint32_t rowstride = TIFFScanlineSize(tif) /
sizeof(float);
916 for (uint32_t row = 0; row < height; row++)
918 tdata_t row_pointer = &data[row * rowstride];
919 TIFFReadScanline(tif, row_pointer, row);
925 catch (std::exception& e)
935 if (image ==
nullptr)
936 throw std::invalid_argument(
"Null image given");
938 TIFF* tif = TIFFOpen(filename.c_str(),
"w");
942 uint32_t width = image->width();
943 uint32_t height = image->height();
944 uint32_t channels = image->channels();
945 TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
946 TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
947 TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, channels);
948 TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8 *
sizeof(
float));
949 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
950 TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
951 TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
952 TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
954 tdata_t buffer =
const_cast<float*
>(image->get_data_pointer());
955 int64_t ret = TIFFWriteEncodedStrip(tif, 0, buffer,
956 image->get_value_amount() *
sizeof(
float));
977 std::ifstream in(filename.c_str(), std::ios::binary);
982 in.read(signature, 2);
986 if (signature[0] ==
'P' && signature[1] ==
'f')
988 else if (signature[0] ==
'P' && signature[1] ==
'F')
1000 in >> width >> height >> scale;
1015 std::size_t row_size = image->get_byte_size() / image->height();
1016 char* ptr =
reinterpret_cast<char*
>(image->end()) - row_size;
1017 for (
int y = 0; y < height; ++y, ptr -= row_size)
1018 in.read(ptr, row_size);
1024 std::transform(image->begin(), image->end(), image->begin(),
1025 (
float(*)(
float const&))util::system::letoh<float>);
1030 std::transform(image->begin(), image->end(), image->begin(),
1031 (
float(*)(
float const&))util::system::betoh<float>);
1037 std::for_each(image->begin(), image->end(),
1047 if (image ==
nullptr)
1048 throw std::invalid_argument(
"Null image given");
1050 std::string magic_number;
1051 if (image->channels() == 1)
1052 magic_number =
"Pf";
1053 else if (image->channels() == 3)
1054 magic_number =
"PF";
1056 throw std::invalid_argument(
"Supports 1 and 3 channel images only");
1058#ifdef HOST_BYTEORDER_LE
1059 std::string scale =
"-1.0";
1061 std::string scale =
"1.0";
1064 std::ofstream out(filename.c_str(), std::ios::binary);
1068 out << magic_number <<
"\n";
1069 out << image->width() <<
" " << image->height() <<
" " << scale <<
"\n";
1072 std::size_t row_size = image->get_byte_size() / image->height();
1073 char const* ptr =
reinterpret_cast<char const*
>(image->end()) - row_size;
1074 for (
int y = 0; y < image->height(); ++y, ptr -= row_size)
1075 out.write(ptr, row_size);
1090 std::ifstream in(filename.c_str(), std::ios::binary);
1095 in.read(signature, 2);
1099 if (signature[0] ==
'P' && signature[1] ==
'5')
1101 else if (signature[0] ==
'P' && signature[1] ==
'6')
1113 in >> width >> height >> maxval;
1129 if (maxval < 256 && bit8)
1132 ByteImage::Ptr image = ByteImage::create(width, height, channels);
1133 in.read(image->get_byte_pointer(), image->get_byte_size());
1136 else if (maxval < 65536 && !bit8)
1139 RawImage::Ptr image = RawImage::create(width, height, channels);
1140 in.read(image->get_byte_pointer(), image->get_byte_size());
1141 for (
int i = 0; i < image->get_value_amount(); ++i)
1158 return std::dynamic_pointer_cast<RawImage>
1165 return std::dynamic_pointer_cast<ByteImage>
1172 if (image ==
nullptr)
1173 throw std::invalid_argument(
"Null image given");
1175 std::string magic_number;
1176 if (image->channels() == 1)
1177 magic_number =
"P5";
1178 else if (image->channels() == 3)
1179 magic_number =
"P6";
1181 throw std::invalid_argument(
"Supports 1 and 3 channel images only");
1189 throw std::invalid_argument(
"Invalid image format");
1191 std::ofstream out(filename.c_str(), std::ios::binary);
1195 out << magic_number <<
"\n";
1196 out << image->width() <<
" " << image->height() <<
" " << maxval <<
"\n";
1201 out.write(image->get_byte_pointer(), image->get_byte_size());
1207 = std::dynamic_pointer_cast<RawImage const>(image);
1208 for (
int i = 0; i < handle->get_value_amount(); ++i)
1234 load_mvei_headers_intern (std::istream& in, ImageHeaders* headers)
1243 int32_t width, height, channels, raw_type;
1244 in.read(
reinterpret_cast<char*
>(&width),
sizeof(int32_t));
1245 in.read(
reinterpret_cast<char*
>(&height),
sizeof(int32_t));
1246 in.read(
reinterpret_cast<char*
>(&channels),
sizeof(int32_t));
1247 in.read(
reinterpret_cast<char*
>(&raw_type),
sizeof(int32_t));
1252 headers->width = width;
1253 headers->height = height;
1254 headers->channels = channels;
1255 headers->type =
static_cast<ImageType>(raw_type);
1262 std::ifstream in(filename.c_str(), std::ios::binary);
1268 load_mvei_headers_intern(in, &headers);
1275 in.read(image->get_byte_pointer(), image->get_byte_size());
1285 std::ifstream in(filename.c_str(), std::ios::binary);
1290 load_mvei_headers_intern(in, &headers);
1297 if (image ==
nullptr)
1298 throw std::invalid_argument(
"Null image given");
1301 int32_t width =
static_cast<int32_t
>(image->width());
1302 int32_t height =
static_cast<int32_t
>(image->height());
1303 int32_t channels =
static_cast<int32_t
>(image->channels());
1304 int32_t type = image->get_type();
1305 char const* data = image->get_byte_pointer();
1306 std::size_t size = image->get_byte_size();
1308 std::ofstream out(filename.c_str(), std::ios::binary);
1313 out.write(
reinterpret_cast<char const*
>(&width),
sizeof(int32_t));
1314 out.write(
reinterpret_cast<char const*
>(&height),
sizeof(int32_t));
1315 out.write(
reinterpret_cast<char const*
>(&channels),
sizeof(int32_t));
1316 out.write(
reinterpret_cast<char const*
>(&type),
sizeof(int32_t));
1317 out.write(data, size);
std::shared_ptr< ImageBase const > ConstPtr
std::shared_ptr< ImageBase > Ptr
Multi-channel image class of arbitrary but homogenous data type.
std::shared_ptr< Image< T > > Ptr
std::shared_ptr< Image< T > const > ConstPtr
std::vector< T > ImageData
Universal, simple exception class.
virtual const char * what(void) const
Exception class for file exceptions with additional filename.
#define MVEI_FILE_SIGNATURE
#define MVEI_FILE_SIGNATURE_LEN
#define PPM_MAX_PIXEL_AMOUNT
#define MVEI_MAX_PIXEL_AMOUNT
#define MVE_IMAGE_NAMESPACE_END
#define MVE_NAMESPACE_BEGIN
#define MVE_IMAGE_NAMESPACE_BEGIN
#define MVE_NAMESPACE_END
void save_tiff_float_file(FloatImage::ConstPtr image, std::string const &filename)
Writes a 32bit float TIFF to file.
void save_mvei_file(ImageBase::ConstPtr image, std::string const &filename)
Writes a native MVE image.
void tiff_error_handler(char const *, char const *fmt, va_list ap)
void save_ppm_16_file(RawImage::ConstPtr image, std::string const &filename)
Save a 16 bit PPM file.
ByteImage::Ptr load_png_file(std::string const &filename)
Loads a PNG file.
ByteImage::Ptr load_file(std::string const &filename)
Loads an image, detecting file type.
ByteImage::Ptr load_tiff_file(std::string const &filename)
Loads a TIFF file.
RawImage::Ptr load_tiff_16_file(std::string const &filename)
Loads a 16bit TIFF file.
FloatImage::Ptr load_tiff_float_file(std::string const &filename)
Loads a 32bit float TIFF file.
ImageBase::Ptr load_mvei_file(std::string const &filename)
Loads a native MVE image.
void save_ppm_file_intern(ImageBase::ConstPtr image, std::string const &filename)
ImageHeaders load_file_headers(std::string const &filename)
Loads the image headers, detecting file type.
ImageHeaders load_mvei_file_headers(std::string const &filename)
Loads the meta information for a native MVE image.
ByteImage::Ptr load_ppm_file(std::string const &filename)
Loads a 8 bit PPM file.
RawImage::Ptr load_ppm_16_file(std::string const &filename)
Loads a 16 bit PPM file.
void save_jpg_file(ByteImage::ConstPtr image, std::string const &filename, int quality)
Saves image data to a JPEG file.
ImageHeaders load_png_file_headers(std::string const &filename)
Loads PNG file headers only.
void save_pfm_file(FloatImage::ConstPtr image, std::string const &filename)
Saves float image data to PFM file.
void save_tiff_file(ByteImage::ConstPtr image, std::string const &filename)
Writes a TIFF to file.
void save_ppm_file(ByteImage::ConstPtr image, std::string const &filename)
Writes a 8 bit PPM file.
void jpg_message_handler(j_common_ptr, int msg_level)
void save_png_file(ByteImage::ConstPtr image, std::string const &filename, int compression_level)
Saves image data to a PNG file.
ByteImage::Ptr load_jpg_file(std::string const &filename, std::string *exif)
Loads a JPEG file.
void save_tiff_16_file(RawImage::ConstPtr image, std::string const &filename)
Writes a 16bit TIFF to file.
ImageBase::Ptr create_for_type(ImageType type, int64_t width, int64_t height, int64_t chans)
Creates an image instance for a given type.
void save_file(ByteImage::ConstPtr image, std::string const &filename)
Saves a byte image to file, detecting file type.
ImageHeaders load_jpg_file_headers(std::string const &filename)
Loads JPEG file headers only.
ImageBase::Ptr load_ppm_file_intern(std::string const &filename, bool bit8)
FloatImage::Ptr load_pfm_file(std::string const &filename)
Loads a PFM file.
ImageHeaders load_tiff_file_headers(std::string const &filename)
Loads TIFF file headers only.
void jpg_error_handler(j_common_ptr)
ImageType
Identifiers for image types.
String conversions and helper functions.
T betoh(T const &x)
Big endian to host order conversion.
for-each functor: multiplies operand with constant factor.