Scroom::TiledBitmap Namespace Reference

Namespaces
	anonymous_namespace{layerspecforbitmap.cc}

Classes
struct	BitmapMetaData
class	LayerSpecForBitmapper
class	OpenTiledBitmapInterface

Typedefs
using	ReloadFunction = std::function< Scroom::Utils::Stuff(const ProgressInterface::Ptr &)>
using	LayerSpecResult = std::tuple< LayerSpec, ColormapHelperBase::Ptr >
using	LayerSpecForBitmapFunc = std::function< LayerSpecResult(const BitmapMetaData &bitmapMetaData)>

Functions
std::ostream &	to_stream (std::ostream &os, const BitmapMetaData &bmd)
std::string	to_string (const BitmapMetaData &bmd)
Metadata::Metadata	to_metadata (const BitmapMetaData &bmd)
OpenPresentationInterface::Ptr	ToOpenPresentationInterface (OpenTiledBitmapInterface::Ptr openTiledBitmapInterface)
LayerSpecResult	LayerSpecForBitmap (const BitmapMetaData &bitmapMetaData)
Scroom::Utils::Stuff	scheduleLoadingBitmap (const SourcePresentation::Ptr &sp, const Layer::Ptr &layer, const ProgressInterface::Ptr &progress)
LayerSpecResult	RGBBitmap (const BitmapMetaData &bmd)
LayerSpecResult	CMYKBitmap (const BitmapMetaData &bmd)
LayerSpecResult	GreyscaleBitmap (const BitmapMetaData &bmd)
LayerSpecResult	ColormappedBitmap (const BitmapMetaData &bmd)

Variables
const std::string	RGB = "RGB"
const std::string	CMYK = "CMYK"
const std::string	Greyscale = "Greyscale"
const std::string	Colormapped = "Colormapped"

Typedef Documentation

LayerSpecForBitmapFunc

using Scroom::TiledBitmap::LayerSpecForBitmapFunc = typedef std::function<LayerSpecResult(const BitmapMetaData& bitmapMetaData)>

LayerSpecResult

using Scroom::TiledBitmap::LayerSpecResult = typedef std::tuple<LayerSpec, ColormapHelperBase::Ptr>

ReloadFunction

using Scroom::TiledBitmap::ReloadFunction = typedef std::function<Scroom::Utils::Stuff(const ProgressInterface::Ptr&)>

Function type for starting the loading of the bottom Layer of a bitmap.

This function is called on the UI thread. You cannot do a significant amount of work in this function, or you'll block the UI. Typical implementations will schedule work on the Sequentially() ThreadPool, such that bitmaps will be loaded sequentially.

Parameters

progressInterface

call setProgress(0) on this once the work actually starts

Returns

a shared pointer. Typically a ThreadPool::Queue or similar. The expectation is that when this object is destroyed by the caller, the loading is cancelled.

See also

Layer

OpenTiledBitmapInterface::open()

Sequentially()

scheduleLoadingBitmap() for an example implementation

Function Documentation

CMYKBitmap()

LayerSpecResult Scroom::TiledBitmap::CMYKBitmap

(

const BitmapMetaData &

bmd

)

  {
    if(bmd.type != CMYK)
    {
      return {};
    }
 
    require(bmd.samplesPerPixel == 4);
    require(!bmd.colormapHelper);
 
    LayerSpec ls;
 
    if(bmd.bitsPerSample == 8)
    {
      ls.emplace_back(OperationsCMYK32::create());
    }
    else if(bmd.bitsPerSample == 4)
    {
      ls.emplace_back(OperationsCMYK16::create());
      ls.emplace_back(OperationsCMYK32::create());
    }
    else if(bmd.bitsPerSample == 2)
    {
      ls.emplace_back(OperationsCMYK8::create());
      ls.emplace_back(OperationsCMYK32::create());
    }
    else if(bmd.bitsPerSample == 1)
    {
      ls.emplace_back(OperationsCMYK4::create());
      ls.emplace_back(OperationsCMYK32::create());
    }
    else
    {
      spdlog::error("CMYK bitmaps with {} bits per sample are not supported", bmd.bitsPerSample);
      return {};
    }
 
    return LayerSpecResult(ls, nullptr);
  }

Referenced by Scroom::TiledBitmap::LayerSpecForBitmapper::LayerSpecForBitmapper().

Here is the call graph for this function:

Here is the caller graph for this function:

ColormappedBitmap()

LayerSpecResult Scroom::TiledBitmap::ColormappedBitmap

(

const BitmapMetaData &

bmd

)

  {
    if(bmd.type != Colormapped)
    {
      return {};
    }
    require(bmd.samplesPerPixel == 1);
    require(bmd.colormapHelper);
 
    if(bmd.bitsPerSample != 1 && bmd.bitsPerSample != 2 && bmd.bitsPerSample != 4 && bmd.bitsPerSample != 8)
    {
      spdlog::error("Colormapped bitmaps with {} bits per pixel are not supported (yet)", bmd.bitsPerSample);
      return {};
    }
 
    LayerSpec ls;
    ls.push_back(Operations::create(bmd.colormapHelper, bmd.bitsPerSample));
    ls.push_back(OperationsColormapped::create(bmd.colormapHelper, bmd.bitsPerSample));
 
    return LayerSpecResult(ls, bmd.colormapHelper);
  }

Referenced by Scroom::TiledBitmap::LayerSpecForBitmapper::LayerSpecForBitmapper().

Here is the call graph for this function:

Here is the caller graph for this function:

GreyscaleBitmap()

LayerSpecResult Scroom::TiledBitmap::GreyscaleBitmap

(

const BitmapMetaData &

bmd

)

  {
    if(bmd.type != Greyscale)
    {
      return {};
    }
 
    require(bmd.samplesPerPixel == 1);
 
    if(bmd.bitsPerSample != 1 && bmd.bitsPerSample != 2 && bmd.bitsPerSample != 4 && bmd.bitsPerSample != 8)
    {
      spdlog::error("Greyscale bitmaps with {} bits per pixel are not supported (yet)", bmd.bitsPerSample);
      return {};
    }
 
    LayerSpec               ls;
    ColormapHelperBase::Ptr colormapHelper = bmd.colormapHelper;
    if(!colormapHelper)
    {
      colormapHelper = MonochromeColormapHelper::create(2);
    }
 
    if(bmd.bitsPerSample == 2 || bmd.bitsPerSample == 4)
    {
      ls.push_back(Operations::create(colormapHelper, bmd.bitsPerSample));
      ls.push_back(OperationsColormapped::create(colormapHelper, bmd.bitsPerSample));
    }
    else
    {
      if(bmd.bitsPerSample == 1)
      {
        ls.push_back(Operations1bpp::create(colormapHelper));
      }
      ls.push_back(Operations8bpp::create(colormapHelper));
    }
 
    return LayerSpecResult(ls, colormapHelper);
  }

Referenced by Scroom::TiledBitmap::LayerSpecForBitmapper::LayerSpecForBitmapper().

Here is the call graph for this function:

Here is the caller graph for this function:

LayerSpecForBitmap()

LayerSpecResult Scroom::TiledBitmap::LayerSpecForBitmap

(

const BitmapMetaData &

bitmapMetaData

)

  {
    return LayerSpecForBitmapper::instance()->get(bitmapMetaData);
  }

Referenced by anonymous_namespace{tiledbitmappresentation.cc}::OpenTiledBitmapAsPresentation::open().

Here is the call graph for this function:

Here is the caller graph for this function:

RGBBitmap()

LayerSpecResult Scroom::TiledBitmap::RGBBitmap

(

const BitmapMetaData &

bmd

)

  {
    if(bmd.type != RGB)
    {
      return {};
    };
 
    require(bmd.samplesPerPixel == 3);
    require(!bmd.colormapHelper);
 
    if(bmd.bitsPerSample != 8)
    {
      spdlog::error("RGB bitmaps with {} bits per sample are not supported", bmd.bitsPerSample);
      return {};
    }
 
    return LayerSpecResult({Operations24bpp::create()}, nullptr);
  }

Referenced by Scroom::TiledBitmap::LayerSpecForBitmapper::LayerSpecForBitmapper().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduleLoadingBitmap()

Scroom::Utils::Stuff Scroom::TiledBitmap::scheduleLoadingBitmap	(	const SourcePresentation::Ptr &	sp,
		const Layer::Ptr &	layer,
		const ProgressInterface::Ptr &	progress
	)

{
  auto wait_until_done = boost::make_shared<Scroom::Semaphore>();
  auto queue           = ThreadPool::Queue::createAsync();
  auto weakQueue       = queue->getWeak();
  auto abort           = [wait_until_done, queue]() mutable
  {
    queue.reset();
    wait_until_done->V();
  };
 
  auto on_finished = [wait_until_done] { wait_until_done->V(); };
  progress->setWaiting();
 
  Sequentially()->schedule(
    [progress, layer, sp, weakQueue, on_finished, wait_until_done]
    {
      Scroom::GtkHelpers::sync_on_ui_thread([=] { progress->setWorking(0); });
      layer->fetchData(sp, weakQueue, on_finished);
      wait_until_done->P();
    });
 
  return Scroom::Utils::on_destruction(abort);
}

Referenced by Tiff::open(), and TiledBitmap::setSource().

Here is the call graph for this function:

Here is the caller graph for this function:

to_metadata()

Metadata::Metadata Scroom::TiledBitmap::to_metadata

(

const BitmapMetaData &

bmd

)

  {
    Scroom::Utils::Point<double> const aspectRatio = bmd.aspectRatio ? *bmd.aspectRatio : Scroom::Utils::Point<double>{1, 1};
    std::string                        aspect_ratio_text = fmt::format("{:.2f} : {:.2f}", aspectRatio.x, aspectRatio.y);
 
    return {
      {"Color representation", bmd.type},
      {"Samples per pixel", std::to_string(bmd.samplesPerPixel)},
      {"Bits per sample", std::to_string(bmd.bitsPerSample)},
      {"Aspect ratio", aspect_ratio_text},
      {"Width", std::to_string(bmd.rect.getWidth())},
      {"Height", std::to_string(bmd.rect.getHeight())},
    };
  }

Here is the call graph for this function:

to_stream()

std::ostream & Scroom::TiledBitmap::to_stream	(	std::ostream &	os,
		const BitmapMetaData &	bmd
	)

  {
    os << "Type=\"" << bmd.type << "\", rect=" << bmd.rect << ", spp=" << bmd.samplesPerPixel << ", bps=" << bmd.bitsPerSample
       << ", colormapped=" << to_string(static_cast<bool>(bmd.colormapHelper));
 
    return os;
  }

Referenced by to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

to_string()

std::string Scroom::TiledBitmap::to_string

(

const BitmapMetaData &

bmd

)

  {
    std::stringstream ss;
    to_stream(ss, bmd);
    return ss.str();
  }

Referenced by Ruler::drawTicks(), Scroom::Tiff::Source::reset(), and to_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

ToOpenPresentationInterface()

OpenPresentationInterface::Ptr Scroom::TiledBitmap::ToOpenPresentationInterface

(

OpenTiledBitmapInterface::Ptr

openTiledBitmapInterface

)

  {
    return OpenTiledBitmapAsPresentation::create(std::move(openTiledBitmapInterface));
  }

Referenced by PluginManager::registerOpenTiledBitmapInterface().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CMYK

const std::string Scroom::TiledBitmap::CMYK = "CMYK"

Referenced by CMYKBitmap(), and Scroom::Tiff::open().

Colormapped

const std::string Scroom::TiledBitmap::Colormapped = "Colormapped"

Referenced by ColormappedBitmap(), and Scroom::Tiff::open().

Greyscale

const std::string Scroom::TiledBitmap::Greyscale = "Greyscale"

Referenced by GreyscaleBitmap(), and Scroom::Tiff::open().

RGB

const std::string Scroom::TiledBitmap::RGB = "RGB"

Referenced by Scroom::Tiff::open(), and RGBBitmap().