Operations1bppClipped Class Reference

#include <layeroperations.hh>

Inheritance diagram for Operations1bppClipped:

Collaboration diagram for Operations1bppClipped:

Public Member Functions
	Operations1bppClipped (ColormapProvider::Ptr colormapProvider)
int	getBpp () override
Scroom::Utils::Stuff	cacheZoom (const ConstTile::Ptr &tile, int zoom, Scroom::Utils::Stuff &cache) override
void	reduce (Tile::Ptr target, ConstTile::Ptr source, int x, int y) 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
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 LayerOperations
virtual Scroom::Utils::Stuff	cache (const ConstTile::Ptr &tile)

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 = boost::shared_ptr< LayerOperations >

Constructor & Destructor Documentation

Operations1bppClipped()

Operations1bppClipped::Operations1bppClipped ( ColormapProvider::Ptr  colormapProvider )

explicit

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

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

cacheZoom()

Scroom::Utils::Stuff Operations1bppClipped::cacheZoom ( const ConstTile::Ptr &  tile, int  zoom, Scroom::Utils::Stuff &  cache  )

overridevirtual

Cache data for use during later draw() calls.

This function is called for a given tile and zoom level, and then the results are passed to the draw() 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
zoom	the requested zoom level
cache	the output of cache(const ConstTile::Ptr)

Reimplemented from CommonOperations.

{
  UNUSED(cache);
 
  if(zoom >= 0)
  {
    zoom = 0;
  }
 
  const int pixelSize    = 1 << (-zoom);
  const int outputWidth  = tile->width / pixelSize;
  const int outputHeight = tile->height / pixelSize;
 
  const int                              stride   = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, outputWidth);
  boost::shared_ptr<unsigned char> const data     = shared_malloc(stride * outputHeight);
  Colormap::Ptr const                    colormap = colormapProvider->getColormap();
 
  unsigned char* row = data.get();
  for(int j = 0; j < outputHeight; j++, row += stride)
  {
    auto* pixel = reinterpret_cast<uint32_t*>(row);
    for(int i = 0; i < outputWidth; i++)
    {
      int sum = 0;
 
      for(int y = 0; y < pixelSize; y++)
      {
        const byte* inputByte = tile->data.get() + (j * pixelSize + y) * tile->width / 8 + pixelSize * i / 8;
        byte const  inputBit  = pixelSize * i % 8;
 
        SampleIterator<const byte> bit(inputByte, inputBit);
 
        for(int x = 0; x < pixelSize; x++, ++bit)
        {
          if(*bit)
          {
            sum++;
          }
        }
      }
 
      if(sum > 0)
      {
        sum = 1;
      }
      *pixel = colormap->colors[sum].getARGB32();
      pixel++;
    }
  }
 
  return BitmapSurface::create(outputWidth, outputHeight, CAIRO_FORMAT_ARGB32, stride, data);
}

Here is the call graph for this function:

create()

LayerOperations::Ptr Operations1bppClipped::create ( ColormapProvider::Ptr  colormapProvider )

static

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

Here is the call graph for this function:

getBpp()

int Operations1bppClipped::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 Operations1bppClipped::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 1bpp
  const int   sourceStride = source->width / 8;
  const byte* sourceBase   = source->data.get();
 
  const int targetStride = target->width / 8;
  byte*     targetBase   = target->data.get() + target->height * y * targetStride / 8 + target->width * x / 8 / 8;
 
  for(int j = 0; j < source->height / 8; j++, targetBase += targetStride, sourceBase += sourceStride * 8)
  {
    // Iterate vertically over target
    const byte*          sourcePtr = sourceBase;
    SampleIterator<byte> targetPtr(targetBase, 0);
 
    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.set((sum > 0) ? 1 : 0);
    }
  }
}

Here is the call graph for this function:

Member Data Documentation

colormapProvider

ColormapProvider::Ptr Operations1bppClipped::colormapProvider

private

Referenced by cacheZoom(), and create().

---

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

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