40#include "numerictraits.hxx"
41#include "rgbvalue.hxx"
42#include "multi_shape.hxx"
52typedef TIFF TiffImage;
142template <
class ImageIterator,
class Accessor>
147 NumericTraits<typename Accessor::value_type>::isScalar
152template <
class ImageIterator,
class Accessor>
159template <
class T,
class S>
166template <
class ImageIterator,
class Accessor>
168importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraTrueType)
173template <
class ImageIterator,
class Accessor>
175importTiffImage(TiffImage * tiff, ImageIterator iter, Accessor a, VigraFalseType)
304template <
class ImageIterator,
class Accessor>
308 vigra_precondition(
tiff != 0,
309 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
310 "NULL pointer to input data.");
326 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
327 "Image isn't grayscale.");
330 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
331 "Image is multiband, not scalar.");
334 "tiffToScalarImage(TiffImage *, ScalarImageIterator): "
335 "undefined pixeltype (SAMPLEFORMAT_VOID).");
342 int offset, scale, max, min;
367 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
372 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
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)
393 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
402 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
407 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
416 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
421 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
429 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
430 "unsupported number of bits per pixel");
440 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
445 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
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)
466 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
475 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
480 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
489 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
494 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
502 vigra_fail(
"tiffToScalarImage(TiffImage *, ScalarImageIterator): "
503 "unsupported number of bits per pixel");
511 case sizeof(
float)*8:
513 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
518 for(
unsigned int x=0; x<w; ++x, ++
xd.x)
520 a.set(((
float *)buf)[x],
xd);
527 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
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): "
561template <
class ImageIterator,
class Accessor>
695template <
class RGBImageIterator,
class RGBAccessor>
699 vigra_precondition(
tiff != 0,
700 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
701 "NULL pointer to input data.");
717 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
721 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
722 "undefined pixeltype (SAMPLEFORMAT_VOID).");
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;
762 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
763 "number of samples per pixel must be 3.");
782 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
803 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
804 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
812 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
833 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
834 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
842 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
863 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
864 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
872 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
873 "unsupported number of bits per pixel");
884 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
905 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
906 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
914 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
934 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
935 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
943 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
964 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
965 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
972 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
973 "unsupported number of bits per pixel");
981 case sizeof(
float)*8:
983 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
1004 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
1005 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
1013 for(
unsigned int y=0; y<
h; ++y, ++
yd.y)
1034 typename RGBImageIterator::row_iterator
rowit =
yd.rowIterator();
1035 typename RGBImageIterator::row_iterator
rowend =
rowit + w;
1042 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
1043 "unsupported number of bits per pixel");
1050 vigra_fail(
"tiffToRGBImage(TiffImage *, RGBImageIterator): "
1072 "tiffToRGBImage(TiffImage *, RGBImageIterator): "
1078template <
class ImageIterator,
class VectorComponentAccessor>
1080tiffToRGBImage(TiffImage * tiff, pair<ImageIterator, VectorComponentAccessor> dest)
1086struct CreateTiffImage;
1174template <
class ImageIterator,
class Accessor>
1177 Accessor a, TiffImage *
tiff)
1179 CreateTiffImage<typename Accessor::value_type>::
1180 exec(upperleft, lowerright, a,
tiff);
1183template <
class ImageIterator,
class Accessor>
1185createTiffImage(triple<ImageIterator, ImageIterator, Accessor> src, TiffImage * tiff)
1190template <
class T,
class S>
1278template <
class ImageIterator,
class Accessor>
1281 Accessor a, TiffImage *
tiff)
1283 CreateTiffImage<typename Accessor::value_type>::
1284 exec(upperleft, lowerright, a,
tiff);
1287template <
class ImageIterator,
class Accessor>
1294template <
class ImageIterator,
class Accessor>
1296createBScalarTiffImage(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);
1337template <
class ImageIterator,
class Accessor>
1339createShortScalarTiffImage(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);
1380template <
class ImageIterator,
class Accessor>
1382createUShortScalarTiffImage(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);
1423template <
class ImageIterator,
class Accessor>
1425createIScalarTiffImage(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);
1466template <
class ImageIterator,
class Accessor>
1468createFScalarTiffImage(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);
1509template <
class ImageIterator,
class Accessor>
1511createDScalarTiffImage(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);
1553struct 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);
1565struct 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);
1577struct 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);
1589struct 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);
1601struct 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);
1613struct 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);
1707template <
class RGBImageIterator,
class RGBAccessor>
1712 CreateTiffImage<typename RGBAccessor::value_type>::
1713 exec(upperleft, lowerright, a,
tiff);
1716template <
class RGBImageIterator,
class RGBAccessor>
1718createRGBTiffImage(triple<RGBImageIterator, RGBImageIterator, RGBAccessor> src, TiffImage * tiff)
1723template <
class RGBImageIterator,
class RGBAccessor>
1725createBRGBTiffImage(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);
1771template <
class RGBImageIterator,
class RGBAccessor>
1773createShortRGBTiffImage(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);
1819template <
class RGBImageIterator,
class RGBAccessor>
1821createIRGBTiffImage(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);
1867template <
class RGBImageIterator,
class RGBAccessor>
1869createFRGBTiffImage(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);
1915template <
class RGBImageIterator,
class RGBAccessor>
1917createDRGBTiffImage(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);
1964struct 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);
1976struct 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);
1988struct 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);
2000struct 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);
2012struct 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);
Standard 2D random access iterator for images that store the data in a linear array.
Definition imageiterator.hxx:851
Definition rgbvalue.hxx:987
Class for a single RGB value.
Definition rgbvalue.hxx:128
void tiffToScalarImage(...)
Convert single-band TiffImage to scalar image.
void createScalarTiffImage(...)
Create a single-band TiffImage from the given scalar image.
void importTiffImage(...)
Read a given TIFF image.
void createTiffImage(...)
Create a TiffImage from the given iterator range.
void createRGBTiffImage(...)
Create a 3-band TiffImage from the given RGB image.
void tiffToRGBImage(...)
Import a RGB (3-band or color-mapped) TiffImage into a RGB image.