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.