36 #ifndef VIGRA_TIFF_HXX
37 #define VIGRA_TIFF_HXX
40 #include "numerictraits.hxx"
41 #include "rgbvalue.hxx"
42 #include "multi_shape.hxx"
52 typedef TIFF TiffImage;
142 template <
class ImageIterator,
class Accessor>
147 NumericTraits<typename Accessor::value_type>::isScalar
152 template <
class ImageIterator,
class Accessor>
159 template <
class T,
class S>
166 template <
class ImageIterator,
class Accessor>
168 importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraTrueType)
173 template <
class ImageIterator,
class Accessor>
175 importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraFalseType)
304 template <
class ImageIterator,
class Accessor>
308 vigra_precondition(tiff != 0,
309 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
310 "NULL pointer to input data.");
312 uint16 sampleFormat = 1, bitsPerSample,
313 fillorder, samplesPerPixel, photometric;
316 TIFFGetField(tiff, TIFFTAG_SAMPLEFORMAT, &sampleFormat);
317 TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitsPerSample);
318 TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
319 TIFFGetField(tiff, TIFFTAG_FILLORDER, &fillorder);
320 TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
321 TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &w);
322 TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &h);
324 vigra_precondition(photometric == PHOTOMETRIC_MINISWHITE ||
325 photometric == PHOTOMETRIC_MINISBLACK,
326 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
327 "Image isn't grayscale.");
329 vigra_precondition(samplesPerPixel == 1,
330 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
331 "Image is multiband, not scalar.");
333 vigra_precondition(sampleFormat != SAMPLEFORMAT_VOID,
334 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
335 "undefined pixeltype (SAMPLEFORMAT_VOID).");
337 ImageIterator yd(iter);
339 int bufsize = TIFFScanlineSize(tiff);
340 tdata_t * buf =
new tdata_t[bufsize];
342 int offset, scale, max, min;
343 if(photometric == PHOTOMETRIC_MINISWHITE)
361 case SAMPLEFORMAT_UINT:
363 switch (bitsPerSample)
367 for(
unsigned int y=0; y<h; ++y, ++yd.y)
369 TIFFReadScanline(tiff, buf, y);
370 ImageIterator xd(yd);
372 for(
unsigned int x=0; x<w; ++x, ++xd.x)
374 if(fillorder == FILLORDER_MSB2LSB)
376 a.set(((((uint8 *)buf)[x/8] >> (7 - x%8)) & 1) ? max : min, xd);
380 a.set(((((uint8 *)buf)[x/8] >> (x%8)) & 1) ? max : min, xd);
388 for(
unsigned int y=0; y<h; ++y, ++yd.y)
390 TIFFReadScanline(tiff, buf, y);
391 ImageIterator xd(yd);
393 for(
unsigned int x=0; x<w; ++x, ++xd.x)
395 a.set(offset + scale*((uint8 *)buf)[x], xd);
402 for(
unsigned int y=0; y<h; ++y, ++yd.y)
404 TIFFReadScanline(tiff, buf, y);
405 ImageIterator xd(yd);
407 for(
unsigned int x=0; x<w; ++x, ++xd.x)
409 a.set(((uint16 *)buf)[x], xd);
416 for(
unsigned int y=0; y<h; ++y, ++yd.y)
418 TIFFReadScanline(tiff, buf, y);
419 ImageIterator xd(yd);
421 for(
unsigned int x=0; x<w; ++x, ++xd.x)
423 a.set(((uint32 *)buf)[x], xd);
429 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
430 "unsupported number of bits per pixel");
434 case SAMPLEFORMAT_INT:
436 switch (bitsPerSample)
440 for(
unsigned int y=0; y<h; ++y, ++yd.y)
442 TIFFReadScanline(tiff, buf, y);
443 ImageIterator xd(yd);
445 for(
unsigned int x=0; x<w; ++x, ++xd.x)
447 if(fillorder == FILLORDER_MSB2LSB)
449 a.set(((((int8 *)buf)[x/8] >> (7 - x%8)) & 1) ? max : min, xd);
453 a.set(((((int8 *)buf)[x/8] >> (x%8)) & 1) ? max : min, xd);
461 for(
unsigned int y=0; y<h; ++y, ++yd.y)
463 TIFFReadScanline(tiff, buf, y);
464 ImageIterator xd(yd);
466 for(
unsigned int x=0; x<w; ++x, ++xd.x)
468 a.set(offset + scale*((uint8 *)buf)[x], xd);
475 for(
unsigned int y=0; y<h; ++y, ++yd.y)
477 TIFFReadScanline(tiff, buf, y);
478 ImageIterator xd(yd);
480 for(
unsigned int x=0; x<w; ++x, ++xd.x)
482 a.set(((int16 *)buf)[x], xd);
489 for(
unsigned int y=0; y<h; ++y, ++yd.y)
491 TIFFReadScanline(tiff, buf, y);
492 ImageIterator xd(yd);
494 for(
unsigned int x=0; x<w; ++x, ++xd.x)
496 a.set(((int32 *)buf)[x], xd);
502 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
503 "unsupported number of bits per pixel");
507 case SAMPLEFORMAT_IEEEFP:
509 switch (bitsPerSample)
511 case sizeof(float)*8:
513 for(
unsigned int y=0; y<h; ++y, ++yd.y)
515 TIFFReadScanline(tiff, buf, y);
516 ImageIterator xd(yd);
518 for(
unsigned int x=0; x<w; ++x, ++xd.x)
520 a.set(((
float *)buf)[x], xd);
525 case sizeof(double)*8:
527 for(
unsigned int y=0; y<h; ++y, ++yd.y)
529 TIFFReadScanline(tiff, buf, y);
530 ImageIterator xd(yd);
532 for(
unsigned int x=0; x<w; ++x, ++xd.x)
534 a.set(((
double *)buf)[x], xd);
540 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
541 "unsupported number of bits per pixel");
548 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
561 template <
class ImageIterator,
class Accessor>
695 template <
class RGBImageIterator,
class RGBAccessor>
697 tiffToRGBImage(TiffImage * tiff, RGBImageIterator iter, RGBAccessor a)
699 vigra_precondition(tiff != 0,
700 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
701 "NULL pointer to input data.");
703 uint16 sampleFormat = 1, bitsPerSample,
704 samplesPerPixel, planarConfig, photometric;
707 TIFFGetField(tiff, TIFFTAG_SAMPLEFORMAT, &sampleFormat);
708 TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitsPerSample);
709 TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
710 TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
711 TIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planarConfig);
712 TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &w);
713 TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &h);
715 vigra_precondition(photometric == PHOTOMETRIC_RGB ||
716 photometric == PHOTOMETRIC_PALETTE,
717 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
720 vigra_precondition(sampleFormat != SAMPLEFORMAT_VOID,
721 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
722 "undefined pixeltype (SAMPLEFORMAT_VOID).");
724 RGBImageIterator yd(iter);
728 case PHOTOMETRIC_PALETTE:
730 uint32 * raster =
new uint32[w*h];
733 if (!TIFFReadRGBAImage(tiff, w, h, raster, 0))
736 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
737 "unable to read image data.");
740 for(
unsigned int y=0; y<h; ++y, ++yd.y)
742 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
743 typename RGBImageIterator::row_iterator rowend = rowit + w;
744 for(
int x=0; rowit<rowend; ++rowit,++x )
746 uint32 rast = raster[x+y*w];
747 a.setRGB(TIFFGetR(rast),TIFFGetG(rast),TIFFGetB(rast),rowit);
759 case PHOTOMETRIC_RGB:
761 vigra_precondition(samplesPerPixel == 3,
762 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
763 "number of samples per pixel must be 3.");
765 int bufsize = TIFFScanlineSize(tiff);
766 tdata_t * bufr =
new tdata_t[bufsize];
767 tdata_t * bufg =
new tdata_t[bufsize];
768 tdata_t * bufb =
new tdata_t[bufsize];
770 int offset = (planarConfig == PLANARCONFIG_CONTIG) ? 3 : 1;
776 case SAMPLEFORMAT_UINT:
778 switch (bitsPerSample)
782 for(
unsigned int y=0; y<h; ++y, ++yd.y)
786 if(planarConfig == PLANARCONFIG_CONTIG)
788 TIFFReadScanline(tiff, bufr, y);
795 TIFFReadScanline(tiff, bufr, y, 0);
796 TIFFReadScanline(tiff, bufg, y, 1);
797 TIFFReadScanline(tiff, bufb, y, 2);
803 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
804 typename RGBImageIterator::row_iterator rowend = rowit + w;
805 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
806 a.setRGB(*pr,*pg, *pb, rowit);
812 for(
unsigned int y=0; y<h; ++y, ++yd.y)
814 uint16 *pr, *pg, *pb;
816 if(planarConfig == PLANARCONFIG_CONTIG)
818 TIFFReadScanline(tiff, bufr, y);
825 TIFFReadScanline(tiff, bufr, y, 0);
826 TIFFReadScanline(tiff, bufg, y, 1);
827 TIFFReadScanline(tiff, bufb, y, 2);
833 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
834 typename RGBImageIterator::row_iterator rowend = rowit + w;
835 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
836 a.setRGB(*pr,*pg, *pb, rowit);
842 for(
unsigned int y=0; y<h; ++y, ++yd.y)
844 uint32 *pr, *pg, *pb;
846 if(planarConfig == PLANARCONFIG_CONTIG)
848 TIFFReadScanline(tiff, bufr, y);
855 TIFFReadScanline(tiff, bufr, y, 0);
856 TIFFReadScanline(tiff, bufg, y, 1);
857 TIFFReadScanline(tiff, bufb, y, 2);
863 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
864 typename RGBImageIterator::row_iterator rowend = rowit + w;
865 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
866 a.setRGB(*pr,*pg, *pb, rowit);
872 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
873 "unsupported number of bits per pixel");
878 case SAMPLEFORMAT_INT:
880 switch (bitsPerSample)
884 for(
unsigned int y=0; y<h; ++y, ++yd.y)
888 if(planarConfig == PLANARCONFIG_CONTIG)
890 TIFFReadScanline(tiff, bufr, y);
897 TIFFReadScanline(tiff, bufr, y, 0);
898 TIFFReadScanline(tiff, bufg, y, 1);
899 TIFFReadScanline(tiff, bufb, y, 2);
905 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
906 typename RGBImageIterator::row_iterator rowend = rowit + w;
907 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
908 a.setRGB(*pr,*pg, *pb, rowit);
914 for(
unsigned int y=0; y<h; ++y, ++yd.y)
918 if(planarConfig == PLANARCONFIG_CONTIG)
920 TIFFReadScanline(tiff, bufr, y);
927 TIFFReadScanline(tiff, bufr, y, 0);
928 TIFFReadScanline(tiff, bufg, y, 1);
929 TIFFReadScanline(tiff, bufb, y, 2);
934 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
935 typename RGBImageIterator::row_iterator rowend = rowit + w;
936 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
937 a.setRGB(*pr,*pg, *pb, rowit);
943 for(
unsigned int y=0; y<h; ++y, ++yd.y)
947 if(planarConfig == PLANARCONFIG_CONTIG)
949 TIFFReadScanline(tiff, bufr, y);
956 TIFFReadScanline(tiff, bufr, y, 0);
957 TIFFReadScanline(tiff, bufg, y, 1);
958 TIFFReadScanline(tiff, bufb, y, 2);
964 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
965 typename RGBImageIterator::row_iterator rowend = rowit + w;
966 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
967 a.setRGB(*pr,*pg, *pb, rowit);
972 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
973 "unsupported number of bits per pixel");
977 case SAMPLEFORMAT_IEEEFP:
979 switch (bitsPerSample)
981 case sizeof(float)*8:
983 for(
unsigned int y=0; y<h; ++y, ++yd.y)
987 if(planarConfig == PLANARCONFIG_CONTIG)
989 TIFFReadScanline(tiff, bufr, y);
996 TIFFReadScanline(tiff, bufr, y, 0);
997 TIFFReadScanline(tiff, bufg, y, 1);
998 TIFFReadScanline(tiff, bufb, y, 2);
1004 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
1005 typename RGBImageIterator::row_iterator rowend = rowit + w;
1006 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
1007 a.setRGB(*pr,*pg, *pb, rowit);
1011 case sizeof(double)*8:
1013 for(
unsigned int y=0; y<h; ++y, ++yd.y)
1015 double *pr, *pg, *pb;
1017 if(planarConfig == PLANARCONFIG_CONTIG)
1019 TIFFReadScanline(tiff, bufr, y);
1020 pr = (
double *)bufr;
1026 TIFFReadScanline(tiff, bufr, y, 0);
1027 TIFFReadScanline(tiff, bufg, y, 1);
1028 TIFFReadScanline(tiff, bufb, y, 2);
1029 pr = (
double *)bufr;
1030 pg = (
double *)bufg;
1031 pb = (
double *)bufb;
1034 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
1035 typename RGBImageIterator::row_iterator rowend = rowit + w;
1036 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
1037 a.setRGB(*pr,*pg, *pb, rowit);
1042 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
1043 "unsupported number of bits per pixel");
1050 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
1072 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
1078 template <
class ImageIterator,
class VectorComponentAccessor>
1080 tiffToRGBImage(TiffImage * tiff, pair<ImageIterator, VectorComponentAccessor> dest)
1086 struct CreateTiffImage;
1174 template <
class ImageIterator,
class Accessor>
1177 Accessor a, TiffImage * tiff)
1179 CreateTiffImage<typename Accessor::value_type>::
1180 exec(upperleft, lowerright, a, tiff);
1183 template <
class ImageIterator,
class Accessor>
1185 createTiffImage(triple<ImageIterator, ImageIterator, Accessor> src, TiffImage * tiff)
1190 template <
class T,
class S>
1192 createTiffImage(MultiArrayView<2, T, S>
const & src, TiffImage * tiff)
1278 template <
class ImageIterator,
class Accessor>
1281 Accessor a, TiffImage * tiff)
1283 CreateTiffImage<typename Accessor::value_type>::
1284 exec(upperleft, lowerright, a, tiff);
1287 template <
class ImageIterator,
class Accessor>
1294 template <
class ImageIterator,
class Accessor>
1296 createBScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1297 Accessor a, TiffImage * tiff)
1299 int w = lowerright.x - upperleft.x;
1300 int h = lowerright.y - upperleft.y;
1302 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1303 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1304 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8);
1305 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1306 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1307 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1308 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1310 int bufsize = TIFFScanlineSize(tiff);
1311 tdata_t * buf =
new tdata_t[bufsize];
1313 ImageIterator ys(upperleft);
1317 for(
int y=0; y<h; ++y, ++ys.y)
1319 uint8 * p = (uint8 *)buf;
1320 ImageIterator xs(ys);
1322 for(
int x=0; x<w; ++x, ++xs.x)
1326 TIFFWriteScanline(tiff, buf, y);
1337 template <
class ImageIterator,
class Accessor>
1339 createShortScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1340 Accessor a, TiffImage * tiff)
1342 int w = lowerright.x - upperleft.x;
1343 int h = lowerright.y - upperleft.y;
1345 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1346 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1347 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1348 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1349 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1350 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1351 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1353 int bufsize = TIFFScanlineSize(tiff);
1354 tdata_t * buf =
new tdata_t[bufsize];
1356 ImageIterator ys(upperleft);
1360 for(
int y=0; y<h; ++y, ++ys.y)
1362 int16 * p = (int16 *)buf;
1363 ImageIterator xs(ys);
1365 for(
int x=0; x<w; ++x, ++xs.x)
1369 TIFFWriteScanline(tiff, buf, y);
1380 template <
class ImageIterator,
class Accessor>
1382 createUShortScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1383 Accessor a, TiffImage * tiff)
1385 int w = lowerright.x - upperleft.x;
1386 int h = lowerright.y - upperleft.y;
1388 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1389 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1390 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1391 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1392 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1393 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1394 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1396 int bufsize = TIFFScanlineSize(tiff);
1397 tdata_t * buf =
new tdata_t[bufsize];
1399 ImageIterator ys(upperleft);
1403 for(
int y=0; y<h; ++y, ++ys.y)
1405 uint16 * p = (uint16 *)buf;
1406 ImageIterator xs(ys);
1408 for(
int x=0; x<w; ++x, ++xs.x)
1412 TIFFWriteScanline(tiff, buf, y);
1423 template <
class ImageIterator,
class Accessor>
1425 createIScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1426 Accessor a, TiffImage * tiff)
1428 int w = lowerright.x - upperleft.x;
1429 int h = lowerright.y - upperleft.y;
1431 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1432 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1433 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 32);
1434 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1435 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1436 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1437 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1439 int bufsize = TIFFScanlineSize(tiff);
1440 tdata_t * buf =
new tdata_t[bufsize];
1442 ImageIterator ys(upperleft);
1446 for(
int y=0; y<h; ++y, ++ys.y)
1448 int32 * p = (int32 *)buf;
1449 ImageIterator xs(ys);
1451 for(
int x=0; x<w; ++x, ++xs.x)
1455 TIFFWriteScanline(tiff, buf, y);
1466 template <
class ImageIterator,
class Accessor>
1468 createFScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1469 Accessor a, TiffImage * tiff)
1471 int w = lowerright.x - upperleft.x;
1472 int h = lowerright.y - upperleft.y;
1474 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1475 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1476 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
float)*8);
1477 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1478 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1479 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1480 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1482 int bufsize = TIFFScanlineSize(tiff);
1483 tdata_t * buf =
new tdata_t[bufsize];
1485 ImageIterator ys(upperleft);
1489 for(
int y=0; y<h; ++y, ++ys.y)
1491 float * p = (
float *)buf;
1492 ImageIterator xs(ys);
1494 for(
int x=0; x<w; ++x, ++xs.x)
1498 TIFFWriteScanline(tiff, buf, y);
1509 template <
class ImageIterator,
class Accessor>
1511 createDScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1512 Accessor a, TiffImage * tiff)
1514 int w = lowerright.x - upperleft.x;
1515 int h = lowerright.y - upperleft.y;
1517 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1518 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1519 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
double)*8);
1520 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1521 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1522 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1523 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1525 int bufsize = TIFFScanlineSize(tiff);
1526 tdata_t * buf =
new tdata_t[bufsize];
1528 ImageIterator ys(upperleft);
1532 for(
int y=0; y<h; ++y, ++ys.y)
1534 double * p = (
double *)buf;
1535 ImageIterator xs(ys);
1537 for(
int x=0; x<w; ++x, ++xs.x)
1541 TIFFWriteScanline(tiff, buf, y);
1553 struct CreateTiffImage<unsigned char>
1555 template <
class ImageIterator,
class Accessor>
1557 exec(ImageIterator upperleft, ImageIterator lowerright,
1558 Accessor a, TiffImage * tiff)
1560 createBScalarTiffImage(upperleft, lowerright, a, tiff);
1565 struct CreateTiffImage<short>
1567 template <
class ImageIterator,
class Accessor>
1569 exec(ImageIterator upperleft, ImageIterator lowerright,
1570 Accessor a, TiffImage * tiff)
1572 createShortScalarTiffImage(upperleft, lowerright, a, tiff);
1577 struct CreateTiffImage<unsigned short>
1579 template <
class ImageIterator,
class Accessor>
1581 exec(ImageIterator upperleft, ImageIterator lowerright,
1582 Accessor a, TiffImage * tiff)
1584 createUShortScalarTiffImage(upperleft, lowerright, a, tiff);
1589 struct CreateTiffImage<int>
1591 template <
class ImageIterator,
class Accessor>
1593 exec(ImageIterator upperleft, ImageIterator lowerright,
1594 Accessor a, TiffImage * tiff)
1596 createIScalarTiffImage(upperleft, lowerright, a, tiff);
1601 struct CreateTiffImage<float>
1603 template <
class ImageIterator,
class Accessor>
1605 exec(ImageIterator upperleft, ImageIterator lowerright,
1606 Accessor a, TiffImage * tiff)
1608 createFScalarTiffImage(upperleft, lowerright, a, tiff);
1613 struct CreateTiffImage<double>
1615 template <
class ImageIterator,
class Accessor>
1617 exec(ImageIterator upperleft, ImageIterator lowerright,
1618 Accessor a, TiffImage * tiff)
1620 createDScalarTiffImage(upperleft, lowerright, a, tiff);
1707 template <
class RGBImageIterator,
class RGBAccessor>
1710 RGBAccessor a, TiffImage * tiff)
1712 CreateTiffImage<typename RGBAccessor::value_type>::
1713 exec(upperleft, lowerright, a, tiff);
1716 template <
class RGBImageIterator,
class RGBAccessor>
1718 createRGBTiffImage(triple<RGBImageIterator, RGBImageIterator, RGBAccessor> src, TiffImage * tiff)
1723 template <
class RGBImageIterator,
class RGBAccessor>
1725 createBRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1726 RGBAccessor a, TiffImage * tiff)
1728 int w = lowerright.x - upperleft.x;
1729 int h = lowerright.y - upperleft.y;
1731 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1732 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1733 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8);
1734 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1735 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1736 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1737 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1739 int bufsize = TIFFScanlineSize(tiff);
1740 tdata_t * buf =
new tdata_t[bufsize];
1742 RGBImageIterator ys(upperleft);
1746 for(
int y=0; y<h; ++y, ++ys.y)
1748 uint8 * pr = (uint8 *)buf;
1752 RGBImageIterator xs(ys);
1754 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1760 TIFFWriteScanline(tiff, buf, y);
1771 template <
class RGBImageIterator,
class RGBAccessor>
1773 createShortRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1774 RGBAccessor a, TiffImage * tiff)
1776 int w = lowerright.x - upperleft.x;
1777 int h = lowerright.y - upperleft.y;
1779 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1780 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1781 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1782 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1783 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1784 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1785 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1787 int bufsize = TIFFScanlineSize(tiff);
1788 tdata_t * buf =
new tdata_t[bufsize];
1790 RGBImageIterator ys(upperleft);
1794 for(
int y=0; y<h; ++y, ++ys.y)
1796 uint16 * pr = (uint16 *)buf;
1800 RGBImageIterator xs(ys);
1802 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1808 TIFFWriteScanline(tiff, buf, y);
1819 template <
class RGBImageIterator,
class RGBAccessor>
1821 createIRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1822 RGBAccessor a, TiffImage * tiff)
1824 int w = lowerright.x - upperleft.x;
1825 int h = lowerright.y - upperleft.y;
1827 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1828 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1829 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 32);
1830 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1831 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1832 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1833 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1835 int bufsize = TIFFScanlineSize(tiff);
1836 tdata_t * buf =
new tdata_t[bufsize];
1838 RGBImageIterator ys(upperleft);
1842 for(
int y=0; y<h; ++y, ++ys.y)
1844 uint32 * pr = (uint32 *)buf;
1848 RGBImageIterator xs(ys);
1850 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1856 TIFFWriteScanline(tiff, buf, y);
1867 template <
class RGBImageIterator,
class RGBAccessor>
1869 createFRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1870 RGBAccessor a, TiffImage * tiff)
1872 int w = lowerright.x - upperleft.x;
1873 int h = lowerright.y - upperleft.y;
1875 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1876 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1877 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
float)*8);
1878 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1879 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1880 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1881 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1883 int bufsize = TIFFScanlineSize(tiff);
1884 tdata_t * buf =
new tdata_t[bufsize];
1886 RGBImageIterator ys(upperleft);
1890 for(
int y=0; y<h; ++y, ++ys.y)
1892 float * pr = (
float *)buf;
1896 RGBImageIterator xs(ys);
1898 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1904 TIFFWriteScanline(tiff, buf, y);
1915 template <
class RGBImageIterator,
class RGBAccessor>
1917 createDRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1918 RGBAccessor a, TiffImage * tiff)
1920 int w = lowerright.x - upperleft.x;
1921 int h = lowerright.y - upperleft.y;
1923 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1924 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1925 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
double)*8);
1926 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1927 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1928 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1929 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1931 int bufsize = TIFFScanlineSize(tiff);
1932 tdata_t * buf =
new tdata_t[bufsize];
1934 RGBImageIterator ys(upperleft);
1938 for(
int y=0; y<h; ++y, ++ys.y)
1940 double * pr = (
double *)buf;
1944 RGBImageIterator xs(ys);
1946 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1952 TIFFWriteScanline(tiff, buf, y);
1964 struct CreateTiffImage<RGBValue<unsigned char> >
1966 template <
class ImageIterator,
class Accessor>
1968 exec(ImageIterator upperleft, ImageIterator lowerright,
1969 Accessor a, TiffImage * tiff)
1971 createBRGBTiffImage(upperleft, lowerright, a, tiff);
1976 struct CreateTiffImage<RGBValue<short> >
1978 template <
class ImageIterator,
class Accessor>
1980 exec(ImageIterator upperleft, ImageIterator lowerright,
1981 Accessor a, TiffImage * tiff)
1983 createShortRGBTiffImage(upperleft, lowerright, a, tiff);
1988 struct CreateTiffImage<RGBValue<int> >
1990 template <
class ImageIterator,
class Accessor>
1992 exec(ImageIterator upperleft, ImageIterator lowerright,
1993 Accessor a, TiffImage * tiff)
1995 createIRGBTiffImage(upperleft, lowerright, a, tiff);
2000 struct CreateTiffImage<RGBValue<float> >
2002 template <
class ImageIterator,
class Accessor>
2004 exec(ImageIterator upperleft, ImageIterator lowerright,
2005 Accessor a, TiffImage * tiff)
2007 createFRGBTiffImage(upperleft, lowerright, a, tiff);
2012 struct CreateTiffImage<RGBValue<double> >
2014 template <
class ImageIterator,
class Accessor>
2016 exec(ImageIterator upperleft, ImageIterator lowerright,
2017 Accessor a, TiffImage * tiff)
2019 createDRGBTiffImage(upperleft, lowerright, a, tiff);
void createScalarTiffImage(...)
Create a single-band TiffImage from the given scalar image.
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays.
void tiffToScalarImage(...)
Convert single-band TiffImage to scalar image.
void importTiffImage(...)
Read a given TIFF image.
void tiffToRGBImage(...)
Import a RGB (3-band or color-mapped) TiffImage into a RGB image.
void createRGBTiffImage(...)
Create a 3-band TiffImage from the given RGB image.
void createTiffImage(...)
Create a TiffImage from the given iterator range.