anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation Class Reference

Inheritance diagram for anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation:

Collaboration diagram for anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation:

Public Types
using	Ptr = std::shared_ptr< TiledBitmapPresentation >
Public Types inherited from PresentationInterface
using	Ptr = std::shared_ptr< PresentationInterface >
using	WeakPtr = std::weak_ptr< PresentationInterface >
Public Types inherited from Viewable
using	Ptr = std::shared_ptr< Viewable >
using	WeakPtr = std::weak_ptr< Viewable >
Public Types inherited from Scroom::Utils::Observable< T >
using	Observer = std::shared_ptr< T >
using	Ptr = std::shared_ptr< Observable< T > >
Public Types inherited from Colormappable
using	Ptr = std::shared_ptr< Colormappable >
using	WeakPtr = std::weak_ptr< Colormappable >
Public Types inherited from PipetteViewInterface
using	Ptr = std::shared_ptr< PipetteViewInterface >
Public Types inherited from ShowMetadataInterface
using	Ptr = std::shared_ptr< ShowMetadataInterface >

Public Member Functions
Scroom::Utils::Rectangle< double >	getRect () override
void	redraw (const ViewInterface::Ptr &vi, cairo_t *cr, Scroom::Utils::Rectangle< double > presentationArea, int zoom) override
bool	getProperty (const std::string &propertyName, std::string &value) override
bool	isPropertyDefined (const std::string &propertyName) override
std::string	getTitle () override
PipetteLayerOperations::PipetteColor	getPixelAverages (Scroom::Utils::Rectangle< double > area) override
void	showMetadata (GtkWindow *parent) override
void	setColormap (Colormap::Ptr colormap) override
Colormap::Ptr	getOriginalColormap () override
int	getNumberOfColors () override
Color	getMonochromeColor () override
void	setMonochromeColor (const Color &c) override
void	setTransparentBackground () override
void	disableTransparentBackground () override
bool	getTransparentBackground () override
void	add (Scroom::Utils::Stuff s)
Scroom::Utils::Context::ConstPtr	getContext () const override
Public Member Functions inherited from PresentationBase
void	open (ViewInterface::WeakPtr vi) override
void	close (ViewInterface::WeakPtr vi) override
Public Member Functions inherited from Scroom::Utils::Observable< T >
	Observable ()
	~Observable () override
	Observable (const Observable &)=delete
	Observable (Observable &&)=delete
Observable	operator= (const Observable &)=delete
Observable	operator= (Observable &&)=delete
Scroom::Bookkeeping::Token	registerStrongObserver (Observer const &observer)
Scroom::Bookkeeping::Token	registerObserver (ObserverWeak const &observer)
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::shared_ptr< R const >	shared_from_this () const
For monochrome presentations: Set/Get the current color
Manipulate the "Transparent Background" setting of the presentation

Static Public Member Functions
static TiledBitmapPresentation::Ptr	create (std::string name_, BitmapMetaData bmd_, TiledBitmapInterface::Ptr tbi_, std::map< std::string, std::string > properties_, ColormapHelperBase::Ptr colormapHelper_, PipetteLayerOperations::Ptr pipetteLayerOperation_)

Protected Member Functions
void	viewAdded (ViewInterface::WeakPtr vi) override
void	viewRemoved (ViewInterface::WeakPtr vi) override
Scroom::Utils::WeakKeySet< ViewInterface::WeakPtr >	getViews () override
Protected Member Functions inherited from PresentationBase
void	observerAdded (Viewable::Ptr const &viewable, Scroom::Bookkeeping::Token const &t) override
Protected Member Functions inherited from Scroom::Utils::Observable< T >
std::list< Observer >	getObservers ()
virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)

Private Types
using	Views = Scroom::Utils::WeakKeySet< ViewInterface::WeakPtr >

Private Member Functions
void	clearCaches ()
	TiledBitmapPresentation (std::string &&name_, BitmapMetaData &&bmd_, TiledBitmapInterface::Ptr &&tbi_, std::map< std::string, std::string > &&properties_, ColormapHelperBase::Ptr &&colormapHelper_, PipetteLayerOperations::Ptr &&pipetteLayerOperation_)

Private Attributes
std::string	name
Scroom::TiledBitmap::BitmapMetaData	bmd
TiledBitmapInterface::Ptr	tbi
std::map< std::string, std::string >	properties
Views	views
ColormapHelperBase::Ptr	colormapHelper
PipetteLayerOperations::Ptr	pipetteLayerOperation
Scroom::Utils::Context::Ptr	context
Scroom::Utils::StuffList	stuff
Scroom::Logger	logger

Member Typedef Documentation

Ptr

using anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::Ptr = std::shared_ptr<TiledBitmapPresentation>

Views

using anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::Views = Scroom::Utils::WeakKeySet<ViewInterface::WeakPtr>

private

Constructor & Destructor Documentation

TiledBitmapPresentation()

anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::TiledBitmapPresentation ( std::string &&  name_, BitmapMetaData &&  bmd_, TiledBitmapInterface::Ptr &&  tbi_, std::map< std::string, std::string > &&  properties_, ColormapHelperBase::Ptr &&  colormapHelper_, PipetteLayerOperations::Ptr &&  pipetteLayerOperation_  )

inlineprivate

      : name(name_)
      , bmd(bmd_)
      , tbi(tbi_)
      , properties(properties_)
      , colormapHelper(colormapHelper_)
      , pipetteLayerOperation(pipetteLayerOperation_)
      , context(Scroom::Utils::Context::create())
    {
    }

Member Function Documentation

add()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::add ( Scroom::Utils::Stuff  s )

inline

{ stuff.push_back(std::move(s)); }

clearCaches()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::clearCaches ( )

private

  {
    for(const Views::value_type& p: views)
    {
      ViewInterface::Ptr const v = p.lock();
      if(v)
      {
        if(tbi)
        {
          tbi->clearCaches(v);
        }
        v->invalidate();
      }
    }
  }

Referenced by disableTransparentBackground(), setColormap(), setMonochromeColor(), and setTransparentBackground().

Here is the caller graph for this function:

create()

static TiledBitmapPresentation::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::create ( std::string  name_, BitmapMetaData  bmd_, TiledBitmapInterface::Ptr  tbi_, std::map< std::string, std::string >  properties_, ColormapHelperBase::Ptr  colormapHelper_, PipetteLayerOperations::Ptr  pipetteLayerOperation_  )

inlinestatic

    {
      return Ptr(new TiledBitmapPresentation(
        std::move(name_),
        std::move(bmd_),
        std::move(tbi_),
        std::move(properties_),
        std::move(colormapHelper_),
        std::move(pipetteLayerOperation_)
      ));
    }

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

Here is the caller graph for this function:

disableTransparentBackground()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::disableTransparentBackground ( )

overridevirtual

Implements Colormappable.

  {
    colormapHelper->disableTransparentBackground();
    clearCaches();
  }

Here is the call graph for this function:

getContext()

Scroom::Utils::Context::ConstPtr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getContext ( ) const

overridevirtual

Implements PresentationInterface.

{ return context; }

getMonochromeColor()

Color anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getMonochromeColor ( )

overridevirtual

Implements Colormappable.

{ return colormapHelper->getMonochromeColor(); }

getNumberOfColors()

int anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getNumberOfColors ( )

overridevirtual

Retrieve the number of colors in use by the presentation

Implements Colormappable.

{ return colormapHelper->getNumberOfColors(); }

getOriginalColormap()

Colormap::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getOriginalColormap ( )

overridevirtual

Retrieve the images colormap (if any)

Implements Colormappable.

{ return colormapHelper->getOriginalColormap(); }

getPixelAverages()

PipetteLayerOperations::PipetteColor anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getPixelAverages ( Scroom::Utils::Rectangle< double >  area )

overridevirtual

Returns the average pixel values for each component, contained in the area.

Parameters

area	selected area to get the pixel values from.

Implements PipetteViewInterface.

  {
    require(pipetteLayerOperation);
 
    auto intArea = roundOutward(area.intersection(getRect())).to<int>();
 
    Layer::Ptr const bottomLayer = tbi->getBottomLayer();
    PipetteLayerOperations::PipetteColor pipetteColors;
 
    const int totalPixels = intArea.getWidth() * intArea.getHeight();
 
    if(totalPixels == 0)
    {
      return {};
    }
 
    // Get start tile (tile_pos_x_start, tile_pos_y_start)
    const int tile_pos_x_start = intArea.getLeft() / TILESIZE;
    const int tile_pos_y_start = intArea.getTop() / TILESIZE;
 
    // Get end tile (tile_pos_x_end, tile_pos_y_end)
    const int tile_pos_x_end = (intArea.getRight() - 1) / TILESIZE;
    const int tile_pos_y_end = (intArea.getBottom() - 1) / TILESIZE;
 
    for(int x = tile_pos_x_start; x <= tile_pos_x_end; x++)
    {
      for(int y = tile_pos_y_start; y <= tile_pos_y_end; y++)
      {
        ConstTile::Ptr const tile = bottomLayer->getTile(x, y)->getConstTileSync();
        Scroom::Utils::Rectangle<int> const tile_rectangle(x * TILESIZE, y * TILESIZE, tile->width, tile->height);
 
        Scroom::Utils::Rectangle<int> inter_rect = tile_rectangle.intersection(intArea);
        Scroom::Utils::Point<int> const base(x * TILESIZE, y * TILESIZE);
 
        inter_rect -= base; // rectangle coordinates relative to constTile with topleft corner (0,0)
 
        pipetteColors = sumPipetteColors(pipetteColors, pipetteLayerOperation->sumPixelValues(inter_rect, tile));
      }
    }
    return dividePipetteColors(pipetteColors, totalPixels);
  }

Here is the call graph for this function:

getProperty()

bool anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getProperty ( const std::string &  name, std::string &  value  )

overridevirtual

Return the value of the requested property

Parameters

[in]	name	The name of the requested property
[out]	value	The value of the requested property

Return values

true	if the property existed
false	if the property didn't exist

Implements PresentationInterface.

  {
    auto p = properties.find(propertyName);
    bool found = false;
    if(p == properties.end())
    {
      found = false;
      value = "";
    }
    else
    {
      found = true;
      value = p->second;
    }
 
    return found;
  }

getRect()

Scroom::Utils::Rectangle< double > anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getRect ( )

overridevirtual

Return the dimensions of your presentation

Implements PresentationInterface.

{ return Scroom::Utils::Rectangle<double>(bmd.rect); }

Referenced by getPixelAverages(), and redraw().

Here is the caller graph for this function:

getTitle()

std::string anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getTitle ( )

overridevirtual

Return the title of the presentation

Implements PresentationInterface.

{ return name; }

Referenced by showMetadata().

Here is the caller graph for this function:

getTransparentBackground()

bool anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getTransparentBackground ( )

overridevirtual

Implements Colormappable.

{ return colormapHelper->getTransparentBackground(); }

getViews()

Scroom::Utils::WeakKeySet< ViewInterface::WeakPtr > anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::getViews ( )

overrideprotectedvirtual

Implements PresentationBase.

{ return views; }

isPropertyDefined()

bool anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::isPropertyDefined ( const std::string &  name )

overridevirtual

Return true if the named property exists

Implements PresentationInterface.

  {
    return properties.end() != properties.find(propertyName);
  }

redraw()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::redraw ( const ViewInterface::Ptr &  vi, cairo_t *  cr, Scroom::Utils::Rectangle< double >  presentationArea, int  zoom  )

overridevirtual

Draw the requested ara at the requested zoom level

Parameters

vi	The ViewInterface on whose behalf the request is made
cr	The context to draw the area on
presentationArea	the area that is to be drawn. The given x and y coordinates should map on 0,0 of the given context cr.
zoom	The requested zoom level. One pixel of your presentation should have size 2**zoom when drawn. zoom may be negative.

Implements PresentationInterface.

  {
    drawOutOfBoundsWithoutBackground(cr, presentationArea, getRect(), pixelSizeFromZoom(zoom));
 
    if(tbi)
    {
      tbi->redraw(vi, cr, presentationArea, zoom);
    }
  }

Here is the call graph for this function:

setColormap()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::setColormap ( Colormap::Ptr  colormap )

overridevirtual

Request that the presentation use the given colormap

Implements Colormappable.

  {
    colormapHelper->setColormap(colormap);
    clearCaches();
  }

Here is the call graph for this function:

setMonochromeColor()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::setMonochromeColor ( const Color &  c )

overridevirtual

Implements Colormappable.

  {
    colormapHelper->setMonochromeColor(c);
    clearCaches();
  }

Here is the call graph for this function:

setTransparentBackground()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::setTransparentBackground ( )

overridevirtual

Implements Colormappable.

  {
    colormapHelper->setTransparentBackground();
    clearCaches();
  }

Here is the call graph for this function:

showMetadata()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::showMetadata ( GtkWindow *  parent )

overridevirtual

Show all metadata in the image properties window for a tiledbitmappresentation @override the base showMetadata() function in PresentationBase

Implements ShowMetadataInterface.

  {
    const std::string filepath = getTitle();
    const std::string title = "Properties: " + filepath.substr(filepath.find_last_of("/\\") + 1);
 
    Scroom::Metadata::showMetaData(parent, title, to_metadata(bmd));
  }

Here is the call graph for this function:

viewAdded()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::viewAdded ( ViewInterface::WeakPtr  vi )

overrideprotectedvirtual

Implements PresentationBase.

  {
    views.insert(viewInterface);
 
    if(tbi)
    {
      tbi->open(viewInterface);
    }
    else
    {
      logger->error("TiffPresentation::open(): No TiledBitmapInterface available!");
    }
  }

viewRemoved()

void anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::viewRemoved ( ViewInterface::WeakPtr  vi )

overrideprotectedvirtual

Implements PresentationBase.

  {
    views.erase(vi);
 
    if(tbi)
    {
      tbi->close(vi);
    }
    else
    {
      logger->error("TiffPresentation::close(): No TiledBitmapInterface available!");
    }
  }

Member Data Documentation

bmd

Scroom::TiledBitmap::BitmapMetaData anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::bmd

private

colormapHelper

ColormapHelperBase::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::colormapHelper

private

context

Scroom::Utils::Context::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::context

private

logger

Scroom::Logger anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::logger

private

name

std::string anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::name

private

pipetteLayerOperation

PipetteLayerOperations::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::pipetteLayerOperation

private

properties

std::map<std::string, std::string> anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::properties

private

stuff

Scroom::Utils::StuffList anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::stuff

private

tbi

TiledBitmapInterface::Ptr anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::tbi

private

views

Views anonymous_namespace{tiledbitmappresentation.cc}::TiledBitmapPresentation::views

private

---

The documentation for this class was generated from the following file:

• libs/tiled-bitmap/src/tiledbitmappresentation.cc