Scroom::Tiff Namespace Reference

Classes
class	Source

Typedefs
using	TIFFPtr = std::shared_ptr< TIFF >

Functions
Colormap::Ptr	getColorMap (const TIFFPtr &tif, uint16_t bps)
boost::optional< Scroom::Utils::Point< double > >	getAspectRatio (const TIFFPtr &tif)
ColormapHelperBase::Ptr	getColormapHelper (const TIFFPtr &tif, uint16_t bps)
boost::optional< std::tuple< Scroom::TiledBitmap::BitmapMetaData, TIFFPtr > >	open (const Scroom::Logger &logger, const std::string &fileName)

Typedef Documentation

TIFFPtr

using Scroom::Tiff::TIFFPtr = typedef std::shared_ptr<TIFF>

Function Documentation

getAspectRatio()

boost::optional< Scroom::Utils::Point< double > > Scroom::Tiff::getAspectRatio

(

const TIFFPtr &

tif

)

  {
    float resolutionX{};
    float resolutionY{};
    uint16_t resolutionUnit{};
 
    if(
      TIFFGetField(tif.get(), TIFFTAG_XRESOLUTION, &resolutionX) && TIFFGetField(tif.get(), TIFFTAG_YRESOLUTION, &resolutionY)
      && TIFFGetField(tif.get(), TIFFTAG_RESOLUTIONUNIT, &resolutionUnit)
    )
    {
      if(resolutionUnit != RESUNIT_NONE)
      {
        // Fix aspect ratio only
        float const base = std::max(resolutionX, resolutionY);
        resolutionX = base / resolutionX;
        resolutionY = base / resolutionY;
      }
      return Scroom::Utils::make_point<double>(resolutionX, resolutionY);
    }
 
    return {};
  }

Referenced by open().

Here is the caller graph for this function:

getColorMap()

Colormap::Ptr Scroom::Tiff::getColorMap	(	const TIFFPtr &	tif,
		uint16_t	bps
	)

  {
    uint16_t* r{};
    uint16_t* g{};
    uint16_t* b{};
    Colormap::Ptr colormap;
 
    const int result = TIFFGetField(tif.get(), TIFFTAG_COLORMAP, &r, &g, &b);
    if(result == 1)
    {
      colormap = Colormap::create();
      colormap->name = "Original";
      const size_t count = 1UL << bps;
      colormap->colors.resize(count);
 
      for(size_t i = 0; i < count; i++)
      {
        colormap->colors[i] = Color(1.0 * r[i] / 0xFFFF, 1.0 * g[i] / 0xFFFF, 1.0 * b[i] / 0xFFFF);
      }
    }
 
    return colormap;
  }

Referenced by getColormapHelper().

Here is the call graph for this function:

Here is the caller graph for this function:

getColormapHelper()

ColormapHelperBase::Ptr Scroom::Tiff::getColormapHelper	(	const TIFFPtr &	tif,
		uint16_t	bps
	)

  {
    auto colorMap = getColorMap(tif, bps);
    return colorMap ? ColormapHelper::create(colorMap) : nullptr;
  }

Referenced by open().

Here is the call graph for this function:

Here is the caller graph for this function:

open()

boost::optional< std::tuple< Scroom::TiledBitmap::BitmapMetaData, TIFFPtr > > Scroom::Tiff::open	(	const Scroom::Logger &	logger,
		const std::string &	fileName
	)

  {
    try
    {
      TIFFPtr const tif(TIFFOpen(fileName.c_str(), "r"), &TIFFCloseUnlessNull);
      if(!tif)
      {
        // Todo: report error
        logger->error("Failed to open file {}", fileName);
        return {};
      }
 
      auto spp = TIFFGetFieldCheckedOr<uint16_t>(tif, TT(TIFFTAG_SAMPLESPERPIXEL), 1); // Default value, according to tiff spec
      auto bps = TIFFGetFieldCheckedOr<uint16_t>(tif, TT(TIFFTAG_BITSPERSAMPLE), (spp == 1) ? 1 : 8);
      auto width = TIFFGetFieldChecked<uint32_t>(tif, TT(TIFFTAG_IMAGEWIDTH));
      auto height = TIFFGetFieldChecked<uint32_t>(tif, TT(TIFFTAG_IMAGELENGTH));
      auto photometric = TIFFGetFieldChecked<uint16_t>(tif, TT(TIFFTAG_PHOTOMETRIC));
 
      ColormapHelperBase::Ptr colormapHelper = getColormapHelper(tif, bps);
 
      if(photometric != PHOTOMETRIC_PALETTE && colormapHelper)
      {
        logger->warn("Tiff contains a colormap, but photometric isn't palette");
        colormapHelper.reset();
      }
 
      auto numberOfGreyscaleColors = (bps == 2 || bps == 4) ? (1 << bps) : 2; // Yuk
      switch(photometric)
      {
      case PHOTOMETRIC_MINISBLACK:
        colormapHelper = MonochromeColormapHelper::create(numberOfGreyscaleColors);
        break;
 
      case PHOTOMETRIC_MINISWHITE:
        colormapHelper = MonochromeColormapHelper::createInverted(numberOfGreyscaleColors);
        break;
 
      case PHOTOMETRIC_PALETTE:
        if(!colormapHelper)
        {
          logger->warn("Photometric is palette, but tiff doesn't contain a colormap");
          colormapHelper = ColormapHelper::create(1 << bps);
        }
        break;
 
      case PHOTOMETRIC_RGB:
      case PHOTOMETRIC_SEPARATED:
        break;
 
      default:
        logger->error("Unrecognized value {} for photometric", photometric);
        return {};
      }
 
      auto aspectRatio = getAspectRatio(tif);
      if(aspectRatio)
      {
        logger->debug("This bitmap has size {}*{}, aspect ratio {:.2}*{:.2}", width, height, aspectRatio->x, aspectRatio->y);
      }
      else
      {
        logger->debug("This bitmap has size {}*{}", width, height);
      }
 
      BitmapMetaData bmd{{}, bps, spp, Scroom::Utils::make_rect<int>(0, 0, width, height), aspectRatio, colormapHelper};
 
      if(bps != 1 && bps != 2 && bps != 4 && bps != 8)
      {
        logger->error("{} bits per sample not supported (yet)", bps);
        return {};
      }
 
      if(spp == 4)
      {
        bmd.type = CMYK;
      }
      else if(spp == 3)
      {
        bmd.type = RGB;
 
        if(bps != 8)
        {
          logger->error("A RGB bitmap with {} samples per pixel isn't supported (yet)", bps);
          return {};
        }
      }
      else if(spp == 1)
      {
        bmd.type = (photometric == PHOTOMETRIC_PALETTE) ? Colormapped : Greyscale;
      }
      else
      {
        logger->error("{} samples per pixel not supported (yet)", spp);
        return {};
      }
 
      return std::make_tuple(bmd, tif);
    }
    catch(const std::exception& ex)
    {
      logger->error("{}", ex.what());
      return {};
    }
  }

Referenced by Tiff::open(), and Scroom::Tiff::Source::reset().

Here is the call graph for this function:

Here is the caller graph for this function: