36 #ifndef VIGRA_TIFF_HXX
37 #define VIGRA_TIFF_HXX
39 #include "utilities.hxx"
40 #include "numerictraits.hxx"
41 #include "rgbvalue.hxx"
50 typedef TIFF TiffImage;
129 template <
class ImageIterator,
class Accessor>
134 NumericTraits<typename Accessor::value_type>::isScalar
139 template <
class ImageIterator,
class Accessor>
146 template <
class ImageIterator,
class Accessor>
148 importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraTrueType)
153 template <
class ImageIterator,
class Accessor>
155 importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraFalseType)
253 template <
class ImageIterator,
class Accessor>
257 vigra_precondition(tiff != 0,
258 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
259 "NULL pointer to input data.");
261 uint16 sampleFormat = 1, bitsPerSample,
262 fillorder, samplesPerPixel, photometric;
265 TIFFGetField(tiff, TIFFTAG_SAMPLEFORMAT, &sampleFormat);
266 TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitsPerSample);
267 TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
268 TIFFGetField(tiff, TIFFTAG_FILLORDER, &fillorder);
269 TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
270 TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &w);
271 TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &h);
273 vigra_precondition(photometric == PHOTOMETRIC_MINISWHITE ||
274 photometric == PHOTOMETRIC_MINISBLACK,
275 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
276 "Image isn't grayscale.");
278 vigra_precondition(samplesPerPixel == 1,
279 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
280 "Image is multiband, not scalar.");
282 vigra_precondition(sampleFormat != SAMPLEFORMAT_VOID,
283 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
284 "undefined pixeltype (SAMPLEFORMAT_VOID).");
286 ImageIterator yd(iter);
288 int bufsize = TIFFScanlineSize(tiff);
289 tdata_t * buf =
new tdata_t[bufsize];
291 int offset, scale,
max,
min;
292 if(photometric == PHOTOMETRIC_MINISWHITE)
310 case SAMPLEFORMAT_UINT:
312 switch (bitsPerSample)
316 for(
unsigned int y=0; y<h; ++y, ++yd.y)
318 TIFFReadScanline(tiff, buf, y);
319 ImageIterator xd(yd);
321 for(
unsigned int x=0; x<w; ++x, ++xd.x)
323 if(fillorder == FILLORDER_MSB2LSB)
325 a.set(((((uint8 *)buf)[x/8] >> (7 - x%8)) & 1) ? max : min, xd);
329 a.set(((((uint8 *)buf)[x/8] >> (x%8)) & 1) ? max : min, xd);
337 for(
unsigned int y=0; y<h; ++y, ++yd.y)
339 TIFFReadScanline(tiff, buf, y);
340 ImageIterator xd(yd);
342 for(
unsigned int x=0; x<w; ++x, ++xd.x)
344 a.set(offset + scale*((uint8 *)buf)[x], xd);
351 for(
unsigned int y=0; y<h; ++y, ++yd.y)
353 TIFFReadScanline(tiff, buf, y);
354 ImageIterator xd(yd);
356 for(
unsigned int x=0; x<w; ++x, ++xd.x)
358 a.set(((uint16 *)buf)[x], xd);
365 for(
unsigned int y=0; y<h; ++y, ++yd.y)
367 TIFFReadScanline(tiff, buf, y);
368 ImageIterator xd(yd);
370 for(
unsigned int x=0; x<w; ++x, ++xd.x)
372 a.set(((uint32 *)buf)[x], xd);
378 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
379 "unsupported number of bits per pixel");
383 case SAMPLEFORMAT_INT:
385 switch (bitsPerSample)
389 for(
unsigned int y=0; y<h; ++y, ++yd.y)
391 TIFFReadScanline(tiff, buf, y);
392 ImageIterator xd(yd);
394 for(
unsigned int x=0; x<w; ++x, ++xd.x)
396 if(fillorder == FILLORDER_MSB2LSB)
398 a.set(((((int8 *)buf)[x/8] >> (7 - x%8)) & 1) ? max : min, xd);
402 a.set(((((int8 *)buf)[x/8] >> (x%8)) & 1) ? max : min, xd);
410 for(
unsigned int y=0; y<h; ++y, ++yd.y)
412 TIFFReadScanline(tiff, buf, y);
413 ImageIterator xd(yd);
415 for(
unsigned int x=0; x<w; ++x, ++xd.x)
417 a.set(offset + scale*((uint8 *)buf)[x], xd);
424 for(
unsigned int y=0; y<h; ++y, ++yd.y)
426 TIFFReadScanline(tiff, buf, y);
427 ImageIterator xd(yd);
429 for(
unsigned int x=0; x<w; ++x, ++xd.x)
431 a.set(((int16 *)buf)[x], xd);
438 for(
unsigned int y=0; y<h; ++y, ++yd.y)
440 TIFFReadScanline(tiff, buf, y);
441 ImageIterator xd(yd);
443 for(
unsigned int x=0; x<w; ++x, ++xd.x)
445 a.set(((int32 *)buf)[x], xd);
451 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
452 "unsupported number of bits per pixel");
456 case SAMPLEFORMAT_IEEEFP:
458 switch (bitsPerSample)
460 case sizeof(float)*8:
462 for(
unsigned int y=0; y<h; ++y, ++yd.y)
464 TIFFReadScanline(tiff, buf, y);
465 ImageIterator xd(yd);
467 for(
unsigned int x=0; x<w; ++x, ++xd.x)
469 a.set(((
float *)buf)[x], xd);
474 case sizeof(double)*8:
476 for(
unsigned int y=0; y<h; ++y, ++yd.y)
478 TIFFReadScanline(tiff, buf, y);
479 ImageIterator xd(yd);
481 for(
unsigned int x=0; x<w; ++x, ++xd.x)
483 a.set(((
double *)buf)[x], xd);
489 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
490 "unsupported number of bits per pixel");
497 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
510 template <
class ImageIterator,
class Accessor>
614 template <
class RGBImageIterator,
class RGBAccessor>
616 tiffToRGBImage(TiffImage * tiff, RGBImageIterator iter, RGBAccessor a)
618 vigra_precondition(tiff != 0,
619 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
620 "NULL pointer to input data.");
622 uint16 sampleFormat = 1, bitsPerSample,
623 samplesPerPixel, planarConfig, photometric;
626 TIFFGetField(tiff, TIFFTAG_SAMPLEFORMAT, &sampleFormat);
627 TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitsPerSample);
628 TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
629 TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
630 TIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planarConfig);
631 TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &w);
632 TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &h);
634 vigra_precondition(photometric == PHOTOMETRIC_RGB ||
635 photometric == PHOTOMETRIC_PALETTE,
636 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
639 vigra_precondition(sampleFormat != SAMPLEFORMAT_VOID,
640 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
641 "undefined pixeltype (SAMPLEFORMAT_VOID).");
643 RGBImageIterator yd(iter);
647 case PHOTOMETRIC_PALETTE:
649 uint32 * raster =
new uint32[w*h];
652 if (!TIFFReadRGBAImage(tiff, w, h, raster, 0))
655 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
656 "unable to read image data.");
659 for(
unsigned int y=0; y<h; ++y, ++yd.y)
661 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
662 typename RGBImageIterator::row_iterator rowend = rowit + w;
663 for(
int x=0; rowit<rowend; ++rowit,++x )
665 uint32 rast = raster[x+y*w];
666 a.setRGB(TIFFGetR(rast),TIFFGetG(rast),TIFFGetB(rast),rowit);
678 case PHOTOMETRIC_RGB:
680 vigra_precondition(samplesPerPixel == 3,
681 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
682 "number of samples per pixel must be 3.");
684 int bufsize = TIFFScanlineSize(tiff);
685 tdata_t * bufr =
new tdata_t[bufsize];
686 tdata_t * bufg =
new tdata_t[bufsize];
687 tdata_t * bufb =
new tdata_t[bufsize];
689 int offset = (planarConfig == PLANARCONFIG_CONTIG) ? 3 : 1;
695 case SAMPLEFORMAT_UINT:
697 switch (bitsPerSample)
701 for(
unsigned int y=0; y<h; ++y, ++yd.y)
705 if(planarConfig == PLANARCONFIG_CONTIG)
707 TIFFReadScanline(tiff, bufr, y);
714 TIFFReadScanline(tiff, bufr, y, 0);
715 TIFFReadScanline(tiff, bufg, y, 1);
716 TIFFReadScanline(tiff, bufb, y, 2);
722 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
723 typename RGBImageIterator::row_iterator rowend = rowit + w;
724 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
725 a.setRGB(*pr,*pg, *pb, rowit);
731 for(
unsigned int y=0; y<h; ++y, ++yd.y)
733 uint16 *pr, *pg, *pb;
735 if(planarConfig == PLANARCONFIG_CONTIG)
737 TIFFReadScanline(tiff, bufr, y);
744 TIFFReadScanline(tiff, bufr, y, 0);
745 TIFFReadScanline(tiff, bufg, y, 1);
746 TIFFReadScanline(tiff, bufb, y, 2);
752 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
753 typename RGBImageIterator::row_iterator rowend = rowit + w;
754 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
755 a.setRGB(*pr,*pg, *pb, rowit);
761 for(
unsigned int y=0; y<h; ++y, ++yd.y)
763 uint32 *pr, *pg, *pb;
765 if(planarConfig == PLANARCONFIG_CONTIG)
767 TIFFReadScanline(tiff, bufr, y);
774 TIFFReadScanline(tiff, bufr, y, 0);
775 TIFFReadScanline(tiff, bufg, y, 1);
776 TIFFReadScanline(tiff, bufb, y, 2);
782 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
783 typename RGBImageIterator::row_iterator rowend = rowit + w;
784 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
785 a.setRGB(*pr,*pg, *pb, rowit);
791 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
792 "unsupported number of bits per pixel");
797 case SAMPLEFORMAT_INT:
799 switch (bitsPerSample)
803 for(
unsigned int y=0; y<h; ++y, ++yd.y)
807 if(planarConfig == PLANARCONFIG_CONTIG)
809 TIFFReadScanline(tiff, bufr, y);
816 TIFFReadScanline(tiff, bufr, y, 0);
817 TIFFReadScanline(tiff, bufg, y, 1);
818 TIFFReadScanline(tiff, bufb, y, 2);
824 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
825 typename RGBImageIterator::row_iterator rowend = rowit + w;
826 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
827 a.setRGB(*pr,*pg, *pb, rowit);
833 for(
unsigned int y=0; y<h; ++y, ++yd.y)
837 if(planarConfig == PLANARCONFIG_CONTIG)
839 TIFFReadScanline(tiff, bufr, y);
846 TIFFReadScanline(tiff, bufr, y, 0);
847 TIFFReadScanline(tiff, bufg, y, 1);
848 TIFFReadScanline(tiff, bufb, y, 2);
853 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
854 typename RGBImageIterator::row_iterator rowend = rowit + w;
855 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
856 a.setRGB(*pr,*pg, *pb, rowit);
862 for(
unsigned int y=0; y<h; ++y, ++yd.y)
866 if(planarConfig == PLANARCONFIG_CONTIG)
868 TIFFReadScanline(tiff, bufr, y);
875 TIFFReadScanline(tiff, bufr, y, 0);
876 TIFFReadScanline(tiff, bufg, y, 1);
877 TIFFReadScanline(tiff, bufb, y, 2);
883 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
884 typename RGBImageIterator::row_iterator rowend = rowit + w;
885 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
886 a.setRGB(*pr,*pg, *pb, rowit);
891 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
892 "unsupported number of bits per pixel");
896 case SAMPLEFORMAT_IEEEFP:
898 switch (bitsPerSample)
900 case sizeof(float)*8:
902 for(
unsigned int y=0; y<h; ++y, ++yd.y)
906 if(planarConfig == PLANARCONFIG_CONTIG)
908 TIFFReadScanline(tiff, bufr, y);
915 TIFFReadScanline(tiff, bufr, y, 0);
916 TIFFReadScanline(tiff, bufg, y, 1);
917 TIFFReadScanline(tiff, bufb, y, 2);
923 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
924 typename RGBImageIterator::row_iterator rowend = rowit + w;
925 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
926 a.setRGB(*pr,*pg, *pb, rowit);
930 case sizeof(double)*8:
932 for(
unsigned int y=0; y<h; ++y, ++yd.y)
934 double *pr, *pg, *pb;
936 if(planarConfig == PLANARCONFIG_CONTIG)
938 TIFFReadScanline(tiff, bufr, y);
945 TIFFReadScanline(tiff, bufr, y, 0);
946 TIFFReadScanline(tiff, bufg, y, 1);
947 TIFFReadScanline(tiff, bufb, y, 2);
953 typename RGBImageIterator::row_iterator rowit = yd.rowIterator();
954 typename RGBImageIterator::row_iterator rowend = rowit + w;
955 for(; rowit<rowend; ++rowit, pr+=offset, pg+=offset, pb+=offset)
956 a.setRGB(*pr,*pg, *pb, rowit);
961 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
962 "unsupported number of bits per pixel");
969 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
991 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
997 template <
class ImageIterator,
class VectorComponentAccessor>
999 tiffToRGBImage(TiffImage * tiff, pair<ImageIterator, VectorComponentAccessor> dest)
1005 struct CreateTiffImage;
1069 template <
class ImageIterator,
class Accessor>
1072 Accessor a, TiffImage * tiff)
1074 CreateTiffImage<typename Accessor::value_type>::
1075 exec(upperleft, lowerright, a, tiff);
1078 template <
class ImageIterator,
class Accessor>
1080 createTiffImage(triple<ImageIterator, ImageIterator, Accessor> src, TiffImage * tiff)
1146 template <
class ImageIterator,
class Accessor>
1149 Accessor a, TiffImage * tiff)
1151 CreateTiffImage<typename Accessor::value_type>::
1152 exec(upperleft, lowerright, a, tiff);
1155 template <
class ImageIterator,
class Accessor>
1162 template <
class ImageIterator,
class Accessor>
1164 createBScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1165 Accessor a, TiffImage * tiff)
1167 int w = lowerright.x - upperleft.x;
1168 int h = lowerright.y - upperleft.y;
1170 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1171 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1172 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8);
1173 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1174 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1175 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1176 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1178 int bufsize = TIFFScanlineSize(tiff);
1179 tdata_t * buf =
new tdata_t[bufsize];
1181 ImageIterator ys(upperleft);
1185 for(
int y=0; y<h; ++y, ++ys.y)
1187 uint8 * p = (uint8 *)buf;
1188 ImageIterator xs(ys);
1190 for(
int x=0; x<w; ++x, ++xs.x)
1194 TIFFWriteScanline(tiff, buf, y);
1205 template <
class ImageIterator,
class Accessor>
1207 createShortScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1208 Accessor a, TiffImage * tiff)
1210 int w = lowerright.x - upperleft.x;
1211 int h = lowerright.y - upperleft.y;
1213 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1214 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1215 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1216 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1217 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1218 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1219 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1221 int bufsize = TIFFScanlineSize(tiff);
1222 tdata_t * buf =
new tdata_t[bufsize];
1224 ImageIterator ys(upperleft);
1228 for(
int y=0; y<h; ++y, ++ys.y)
1230 int16 * p = (int16 *)buf;
1231 ImageIterator xs(ys);
1233 for(
int x=0; x<w; ++x, ++xs.x)
1237 TIFFWriteScanline(tiff, buf, y);
1248 template <
class ImageIterator,
class Accessor>
1250 createUShortScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1251 Accessor a, TiffImage * tiff)
1253 int w = lowerright.x - upperleft.x;
1254 int h = lowerright.y - upperleft.y;
1256 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1257 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1258 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1259 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1260 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1261 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1262 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1264 int bufsize = TIFFScanlineSize(tiff);
1265 tdata_t * buf =
new tdata_t[bufsize];
1267 ImageIterator ys(upperleft);
1271 for(
int y=0; y<h; ++y, ++ys.y)
1273 uint16 * p = (uint16 *)buf;
1274 ImageIterator xs(ys);
1276 for(
int x=0; x<w; ++x, ++xs.x)
1280 TIFFWriteScanline(tiff, buf, y);
1291 template <
class ImageIterator,
class Accessor>
1293 createIScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1294 Accessor a, TiffImage * tiff)
1296 int w = lowerright.x - upperleft.x;
1297 int h = lowerright.y - upperleft.y;
1299 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1300 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1301 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 32);
1302 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1303 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1304 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1305 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1307 int bufsize = TIFFScanlineSize(tiff);
1308 tdata_t * buf =
new tdata_t[bufsize];
1310 ImageIterator ys(upperleft);
1314 for(
int y=0; y<h; ++y, ++ys.y)
1316 int32 * p = (int32 *)buf;
1317 ImageIterator xs(ys);
1319 for(
int x=0; x<w; ++x, ++xs.x)
1323 TIFFWriteScanline(tiff, buf, y);
1334 template <
class ImageIterator,
class Accessor>
1336 createFScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1337 Accessor a, TiffImage * tiff)
1339 int w = lowerright.x - upperleft.x;
1340 int h = lowerright.y - upperleft.y;
1342 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1343 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1344 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
float)*8);
1345 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1346 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1347 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1348 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1350 int bufsize = TIFFScanlineSize(tiff);
1351 tdata_t * buf =
new tdata_t[bufsize];
1353 ImageIterator ys(upperleft);
1357 for(
int y=0; y<h; ++y, ++ys.y)
1359 float * p = (
float *)buf;
1360 ImageIterator xs(ys);
1362 for(
int x=0; x<w; ++x, ++xs.x)
1366 TIFFWriteScanline(tiff, buf, y);
1377 template <
class ImageIterator,
class Accessor>
1379 createDScalarTiffImage(ImageIterator upperleft, ImageIterator lowerright,
1380 Accessor a, TiffImage * tiff)
1382 int w = lowerright.x - upperleft.x;
1383 int h = lowerright.y - upperleft.y;
1385 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1386 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1387 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
double)*8);
1388 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
1389 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1390 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1391 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
1393 int bufsize = TIFFScanlineSize(tiff);
1394 tdata_t * buf =
new tdata_t[bufsize];
1396 ImageIterator ys(upperleft);
1400 for(
int y=0; y<h; ++y, ++ys.y)
1402 double * p = (
double *)buf;
1403 ImageIterator xs(ys);
1405 for(
int x=0; x<w; ++x, ++xs.x)
1409 TIFFWriteScanline(tiff, buf, y);
1421 struct CreateTiffImage<unsigned char>
1423 template <
class ImageIterator,
class Accessor>
1425 exec(ImageIterator upperleft, ImageIterator lowerright,
1426 Accessor a, TiffImage * tiff)
1428 createBScalarTiffImage(upperleft, lowerright, a, tiff);
1433 struct CreateTiffImage<short>
1435 template <
class ImageIterator,
class Accessor>
1437 exec(ImageIterator upperleft, ImageIterator lowerright,
1438 Accessor a, TiffImage * tiff)
1440 createShortScalarTiffImage(upperleft, lowerright, a, tiff);
1445 struct CreateTiffImage<unsigned short>
1447 template <
class ImageIterator,
class Accessor>
1449 exec(ImageIterator upperleft, ImageIterator lowerright,
1450 Accessor a, TiffImage * tiff)
1452 createUShortScalarTiffImage(upperleft, lowerright, a, tiff);
1457 struct CreateTiffImage<int>
1459 template <
class ImageIterator,
class Accessor>
1461 exec(ImageIterator upperleft, ImageIterator lowerright,
1462 Accessor a, TiffImage * tiff)
1464 createIScalarTiffImage(upperleft, lowerright, a, tiff);
1469 struct CreateTiffImage<float>
1471 template <
class ImageIterator,
class Accessor>
1473 exec(ImageIterator upperleft, ImageIterator lowerright,
1474 Accessor a, TiffImage * tiff)
1476 createFScalarTiffImage(upperleft, lowerright, a, tiff);
1481 struct CreateTiffImage<double>
1483 template <
class ImageIterator,
class Accessor>
1485 exec(ImageIterator upperleft, ImageIterator lowerright,
1486 Accessor a, TiffImage * tiff)
1488 createDScalarTiffImage(upperleft, lowerright, a, tiff);
1557 template <
class RGBImageIterator,
class RGBAccessor>
1560 RGBAccessor a, TiffImage * tiff)
1562 CreateTiffImage<typename RGBAccessor::value_type>::
1563 exec(upperleft, lowerright, a, tiff);
1566 template <
class RGBImageIterator,
class RGBAccessor>
1568 createRGBTiffImage(triple<RGBImageIterator, RGBImageIterator, RGBAccessor> src, TiffImage * tiff)
1573 template <
class RGBImageIterator,
class RGBAccessor>
1575 createBRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1576 RGBAccessor a, TiffImage * tiff)
1578 int w = lowerright.x - upperleft.x;
1579 int h = lowerright.y - upperleft.y;
1581 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1582 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1583 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8);
1584 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1585 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1586 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1587 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1589 int bufsize = TIFFScanlineSize(tiff);
1590 tdata_t * buf =
new tdata_t[bufsize];
1592 RGBImageIterator ys(upperleft);
1596 for(
int y=0; y<h; ++y, ++ys.y)
1598 uint8 * pr = (uint8 *)buf;
1602 RGBImageIterator xs(ys);
1604 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1610 TIFFWriteScanline(tiff, buf, y);
1621 template <
class RGBImageIterator,
class RGBAccessor>
1623 createShortRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1624 RGBAccessor a, TiffImage * tiff)
1626 int w = lowerright.x - upperleft.x;
1627 int h = lowerright.y - upperleft.y;
1629 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1630 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1631 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16);
1632 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1633 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1634 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1635 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1637 int bufsize = TIFFScanlineSize(tiff);
1638 tdata_t * buf =
new tdata_t[bufsize];
1640 RGBImageIterator ys(upperleft);
1644 for(
int y=0; y<h; ++y, ++ys.y)
1646 uint16 * pr = (uint16 *)buf;
1650 RGBImageIterator xs(ys);
1652 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1658 TIFFWriteScanline(tiff, buf, y);
1669 template <
class RGBImageIterator,
class RGBAccessor>
1671 createIRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1672 RGBAccessor a, TiffImage * tiff)
1674 int w = lowerright.x - upperleft.x;
1675 int h = lowerright.y - upperleft.y;
1677 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1678 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1679 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 32);
1680 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1681 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1682 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1683 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1685 int bufsize = TIFFScanlineSize(tiff);
1686 tdata_t * buf =
new tdata_t[bufsize];
1688 RGBImageIterator ys(upperleft);
1692 for(
int y=0; y<h; ++y, ++ys.y)
1694 uint32 * pr = (uint32 *)buf;
1698 RGBImageIterator xs(ys);
1700 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1706 TIFFWriteScanline(tiff, buf, y);
1717 template <
class RGBImageIterator,
class RGBAccessor>
1719 createFRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1720 RGBAccessor a, TiffImage * tiff)
1722 int w = lowerright.x - upperleft.x;
1723 int h = lowerright.y - upperleft.y;
1725 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1726 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1727 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
float)*8);
1728 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1729 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1730 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1731 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1733 int bufsize = TIFFScanlineSize(tiff);
1734 tdata_t * buf =
new tdata_t[bufsize];
1736 RGBImageIterator ys(upperleft);
1740 for(
int y=0; y<h; ++y, ++ys.y)
1742 float * pr = (
float *)buf;
1746 RGBImageIterator xs(ys);
1748 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1754 TIFFWriteScanline(tiff, buf, y);
1765 template <
class RGBImageIterator,
class RGBAccessor>
1767 createDRGBTiffImage(RGBImageIterator upperleft, RGBImageIterator lowerright,
1768 RGBAccessor a, TiffImage * tiff)
1770 int w = lowerright.x - upperleft.x;
1771 int h = lowerright.y - upperleft.y;
1773 TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, w);
1774 TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, h);
1775 TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE,
sizeof(
double)*8);
1776 TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
1777 TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1778 TIFFSetField(tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1779 TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
1781 int bufsize = TIFFScanlineSize(tiff);
1782 tdata_t * buf =
new tdata_t[bufsize];
1784 RGBImageIterator ys(upperleft);
1788 for(
int y=0; y<h; ++y, ++ys.y)
1790 double * pr = (
double *)buf;
1794 RGBImageIterator xs(ys);
1796 for(
int x=0; x<w; ++x, ++xs.x, pr+=3, pg+=3, pb+=3)
1802 TIFFWriteScanline(tiff, buf, y);
1814 struct CreateTiffImage<RGBValue<unsigned char> >
1816 template <
class ImageIterator,
class Accessor>
1818 exec(ImageIterator upperleft, ImageIterator lowerright,
1819 Accessor a, TiffImage * tiff)
1821 createBRGBTiffImage(upperleft, lowerright, a, tiff);
1826 struct CreateTiffImage<RGBValue<short> >
1828 template <
class ImageIterator,
class Accessor>
1830 exec(ImageIterator upperleft, ImageIterator lowerright,
1831 Accessor a, TiffImage * tiff)
1833 createShortRGBTiffImage(upperleft, lowerright, a, tiff);
1838 struct CreateTiffImage<RGBValue<int> >
1840 template <
class ImageIterator,
class Accessor>
1842 exec(ImageIterator upperleft, ImageIterator lowerright,
1843 Accessor a, TiffImage * tiff)
1845 createIRGBTiffImage(upperleft, lowerright, a, tiff);
1850 struct CreateTiffImage<RGBValue<float> >
1852 template <
class ImageIterator,
class Accessor>
1854 exec(ImageIterator upperleft, ImageIterator lowerright,
1855 Accessor a, TiffImage * tiff)
1857 createFRGBTiffImage(upperleft, lowerright, a, tiff);
1862 struct CreateTiffImage<RGBValue<double> >
1864 template <
class ImageIterator,
class Accessor>
1866 exec(ImageIterator upperleft, ImageIterator lowerright,
1867 Accessor a, TiffImage * tiff)
1869 createDRGBTiffImage(upperleft, lowerright, a, tiff);