Operations Class Reference

#include <layeroperations.hh>

Inheritance diagram for Operations:

Collaboration diagram for Operations:

Public Member Functions
	Operations (ColormapProvider::Ptr colormapProvider, int bpp)
int	getBpp () override
Scroom::Utils::Stuff	cache (const ConstTile::Ptr &tile) override
void	reduce (Tile::Ptr target, ConstTile::Ptr source, int x, int y) override
void	draw (cairo_t *cr, const ConstTile::Ptr &tile, Scroom::Utils::Rectangle< double > tileArea, Scroom::Utils::Rectangle< double > viewArea, int zoom, Scroom::Utils::Stuff cache) override
Public Member Functions inherited from CommonOperations
void	initializeCairo (cairo_t *cr) override
void	drawState (cairo_t *cr, TileState s, Scroom::Utils::Rectangle< double > viewArea) override
Scroom::Utils::Stuff	cacheZoom (const ConstTile::Ptr &tile, int zoom, Scroom::Utils::Stuff &cache) override

Static Public Member Functions
static Ptr	create (ColormapProvider::Ptr colormapProvider, int bpp)
Static Public Member Functions inherited from CommonOperations
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value)
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value, Color const &bgColor)

Protected Attributes
ColormapProvider::Ptr	colormapProvider
const unsigned	bpp
const unsigned	pixelsPerByte
const unsigned	pixelOffset
const unsigned	pixelMask

Additional Inherited Members
Public Types inherited from LayerOperations
using	Ptr = boost::shared_ptr< LayerOperations >

Constructor & Destructor Documentation

Operations()

Operations::Operations	(	ColormapProvider::Ptr	colormapProvider,
		int	bpp
	)

  : colormapProvider(std::move(colormapProvider_))
  , bpp(bpp_)
  , pixelsPerByte(8 / bpp_)
  , pixelOffset(bpp_)
  , pixelMask((1 << bpp_) - 1)
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

cache()

Scroom::Utils::Stuff Operations::cache ( const ConstTile::Ptr &  tile )

overridevirtual

Cache data for use during later cacheZoom() calls.

This function is called for a given tile, and then the results are passed to the cacheZoom() function. Because draw() is called relatively frequently (i.e. when scrolling), it is recommended to do cpu-intensive work in the cache() and cacheZoom() functions, and then re-use the data to make the draw() faster.

The default implementation returns an empty reference, meaning nothing is cached. As a result, the draw() function will receive an empty reference.

Parameters

tile	the Tile for which caching is requested

Reimplemented from LayerOperations.

Reimplemented in OperationsColormapped.

{
  const int                              stride   = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, tile->width);
  boost::shared_ptr<unsigned char> const data     = shared_malloc(stride * tile->height);
  Colormap::Ptr const                    colormap = colormapProvider->getColormap();
 
  unsigned char* row = data.get();
  for(int j = 0; j < tile->height; j++, row += stride)
  {
    SampleIterator<const byte> pixelIn(tile->data.get() + j * tile->width / pixelsPerByte, 0, bpp);
 
    auto* pixelOut = reinterpret_cast<uint32_t*>(row);
    for(int i = 0; i < tile->width; i++)
    {
      *pixelOut = colormap->colors[*pixelIn].getARGB32();
      pixelOut++;
      ++pixelIn;
    }
  }
 
  return BitmapSurface::create(tile->width, tile->height, CAIRO_FORMAT_ARGB32, stride, data);
}

Referenced by draw().

Here is the call graph for this function:

Here is the caller graph for this function:

create()

LayerOperations::Ptr Operations::create ( ColormapProvider::Ptr  colormapProvider, int  bpp  )

static

{
  return Ptr(new Operations(std::move(colormapProvider), bpp));
}

Referenced by Scroom::TiledBitmap::ColormappedBitmap(), Scroom::TiledBitmap::GreyscaleBitmap(), setupTest2bpp(), setupTest4bpp(), and setupTest8bppColormapped().

Here is the call graph for this function:

Here is the caller graph for this function:

draw()

void Operations::draw ( cairo_t *  cr, const ConstTile::Ptr &  tile, Scroom::Utils::Rectangle< double >  tileArea, Scroom::Utils::Rectangle< double >  viewArea, int  zoom, Scroom::Utils::Stuff  cache  )

overridevirtual

Draw the given tileArea into the given viewArea at the requested zoom level

Parameters

cr	The canvas on which to draw
tile	The tile to take data from
tileArea	Area of the tile that needs to be drawn
viewArea	Area of the canvas that the tile needs to be drawn in
zoom	The requested zoom level. One pixel of your presentation should have size 2**zoom when drawn. zoom will be negative for all but the first layer.
cache	Depending on whether the cacheZoom() function finished already, this may either be an empty reference, or a reference to the value returned by cacheZoom()

Reimplemented from CommonOperations.

{
  cairo_save(cr);
  CommonOperations::draw(cr, tile, tileArea, viewArea, zoom, cache);
  cairo_restore(cr);
 
  // Draw pixelvalues at 32:1 zoom
  if(zoom == 5)
  {
    const int multiplier = 1 << zoom;
    const int stride     = tile->width / pixelsPerByte;
    cairo_select_font_face(cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
    cairo_set_font_size(cr, 12.0);
 
    Colormap::Ptr const colormap = colormapProvider->getColormap();
 
    auto tileAreaInt = roundOutward(tileArea).to<int>();
    auto offset      = tileAreaInt.getTopLeft() - tileArea.getTopLeft();
    viewArea += offset * multiplier;
 
    for(int y = 0; y < tileAreaInt.height(); y++)
    {
      const byte* const          data = tile->data.get();
      SampleIterator<const byte> current(data + (tileAreaInt.y() + y) * stride, tileAreaInt.x(), bpp);
 
      for(int x = 0; x < tileAreaInt.width(); x++, ++current)
      {
        const int value = *current;
 
        cairo_save(cr);
        drawPixelValue(
          cr, viewArea.x() + multiplier * x, viewArea.y() + multiplier * y, multiplier, value, colormap->colors[value]);
        cairo_restore(cr);
      }
    }
  }
}

Here is the call graph for this function:

getBpp()

int Operations::getBpp ( )

overridevirtual

Return the number of bits per pixel that the layer will use.

This number will be used to compute the amount of memory required to store one tile

Implements LayerOperations.

Reimplemented in OperationsColormapped.

{ return bpp; }

reduce()

void Operations::reduce ( Tile::Ptr  target, ConstTile::Ptr  source, int  x, int  y  )

overridevirtual

Reduce the source tile by a factor of 8

The target tile will contain data for 8*8 source tiles. Offsets x and y indicate which of those 64 source tiles is currently being processed

Parameters

target	Tile that will contain the reduced bitmap
source	Tile that is to be reduced
x	x-offset (0..7) of the source tile in the target tile
y	y-offset (0..7) of the source tile in the target tile

Note

The target tile belongs to a different layer, and hence possibly has a different bpp than the current one, depending on the LayerSpec given to createTiledBitmap()

Implements LayerOperations.

Reimplemented in OperationsColormapped.

{
  // Reducing by a factor 8. Target is 2*bpp and expects two indices into the colormap
  const int   sourceStride = source->width / pixelsPerByte;
  const byte* sourceBase   = source->data.get();
 
  const int targetMultiplier = 2; // target is 2*bpp
  const int targetStride     = targetMultiplier * target->width / pixelsPerByte;
  byte*     targetBase =
    target->data.get() + target->height * targetStride * y / 8 + targetMultiplier * target->width * x / 8 / pixelsPerByte;
 
  for(int j = 0; j < source->height / 8; j++, targetBase += targetStride, sourceBase += sourceStride * 8)
  {
    // Iterate vertically over target
    const byte*              sourcePtr = sourceBase;
    SampleIterator<uint16_t> targetPtr(reinterpret_cast<uint16_t*>(targetBase), 0, targetMultiplier * bpp);
 
    for(int i = 0; i < source->width / 8; i++, sourcePtr += 8 / pixelsPerByte, ++targetPtr)
    {
      // Iterate horizontally over target
 
      // Goal is to determine which values occurs most often in a 8*8
      // rectangle, and pick the top two.
      const byte* base = sourcePtr;
      byte        lookup[pixelMask + 1];
      memset(lookup, 0, sizeof(lookup));
 
      for(int k = 0; k < 8; k++, base += sourceStride)
      {
        SampleIterator<const byte> current(base, 0, bpp);
        for(int l = 0; l < 8; l++, ++current)
        {
          ++(lookup[*current]);
        }
      }
      unsigned first  = 0;
      unsigned second = 1;
      if(lookup[1] > lookup[0])
      {
        first  = 1;
        second = 0;
      }
      for(unsigned c = 2; c < pixelMask + 1; c++)
      {
        if(lookup[c] > lookup[first])
        {
          second = first;
          first  = c;
        }
        else if(lookup[c] > lookup[second])
        {
          second = c;
        }
      }
      if(lookup[second] == 0)
      {
        second = first;
      }
 
      targetPtr.set(first << pixelOffset | second);
    }
  }
}

Here is the call graph for this function:

Member Data Documentation

bpp

const unsigned Operations::bpp

protected

Referenced by cache(), OperationsColormapped::cache(), create(), OperationsColormapped::create(), draw(), getBpp(), OperationsColormapped::getBpp(), reduce(), and OperationsColormapped::reduce().

colormapProvider

ColormapProvider::Ptr Operations::colormapProvider

protected

Referenced by cache(), OperationsColormapped::cache(), create(), OperationsColormapped::create(), and draw().

pixelMask

const unsigned Operations::pixelMask

protected

Referenced by OperationsColormapped::cache(), reduce(), and OperationsColormapped::reduce().

pixelOffset

const unsigned Operations::pixelOffset

protected

Referenced by OperationsColormapped::cache(), reduce(), and OperationsColormapped::reduce().

pixelsPerByte

const unsigned Operations::pixelsPerByte

protected

Referenced by cache(), OperationsColormapped::cache(), draw(), reduce(), and OperationsColormapped::reduce().

---

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

• inc/scroom/layeroperations.hh
• libs/tiled-bitmap/src/layeroperations.cc