Operations1bpp Class Reference

#include <layeroperations.hh>

Inheritance diagram for Operations1bpp:

Collaboration diagram for Operations1bpp:

Public Member Functions
	Operations1bpp (ColormapProvider::Ptr colormapProvider)
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)
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)

Private Attributes
ColormapProvider::Ptr	colormapProvider

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

Constructor & Destructor Documentation

Operations1bpp()

Operations1bpp::Operations1bpp ( ColormapProvider::Ptr  colormapProvider )

explicit

  : colormapProvider(std::move(colormapProvider_))
{
}

Member Function Documentation

cache()

Scroom::Utils::Stuff Operations1bpp::cache ( const ConstTile::Ptr &  )

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.

{
  const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, tile->width);
  std::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> bit(tile->data.get() + j * tile->width / 8, 0);
    auto* pixel = reinterpret_cast<uint32_t*>(row);
    for(int i = 0; i < tile->width; i++)
    {
      *pixel = colormap->colors[*bit].getARGB32();
      pixel++;
      ++bit;
    }
  }
 
  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 Operations1bpp::create ( ColormapProvider::Ptr  colormapProvider )

static

{
  return Ptr(new Operations1bpp(std::move(colormapProvider)));
}

Referenced by Scroom::TiledBitmap::GreyscaleBitmap(), and setupTest1bpp().

Here is the caller graph for this function:

draw()

void Operations1bpp::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 / 8;
    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.getHeight(); y++)
    {
      const byte* const data = tile->data.get();
      SampleIterator<const byte> current(data + (tileAreaInt.getTop() + y) * stride, tileAreaInt.getLeft(), 1);
 
      for(int x = 0; x < tileAreaInt.getWidth(); 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 Operations1bpp::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.

{ return 1; }

reduce()

void Operations1bpp::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.

{
  // Reducing by a factor 8. Source tile is 1bpp. Target tile is 8bpp
  const int sourceStride = source->width / 8;
  const byte* sourceBase = source->data.get();
 
  const int targetStride = target->width;
  byte* targetBase = target->data.get() + target->height * y * targetStride / 8 + target->width * x / 8;
 
  for(int j = 0; j < source->height / 8; j++, targetBase += targetStride, sourceBase += sourceStride * 8)
  {
    // Iterate vertically over target
    const byte* sourcePtr = sourceBase;
    byte* targetPtr = targetBase;
 
    for(int i = 0; i < source->width / 8; i++, sourcePtr++, targetPtr++)
    {
      // Iterate horizontally over target
 
      // Goal is to compute a 8-bit grey value from a 8*8 black/white
      // image. To do so, we take each of the 8 bytes, count the
      // number of 1's in each, and add them. Finally, we divide that
      // by 64 (the maximum number of ones in that area
 
      const byte* current = sourcePtr;
      int sum = 0;
      for(int k = 0; k < 8; k++, current += sourceStride)
      {
        sum += bcl.lookup(*current);
      }
 
      *targetPtr = sum * 255 / 64;
    }
  }
}

Here is the call graph for this function:

Member Data Documentation

colormapProvider

ColormapProvider::Ptr Operations1bpp::colormapProvider

private

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

---

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

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