Operations24bpp Class Reference

#include <layeroperations.hh>

Inheritance diagram for Operations24bpp:

Collaboration diagram for Operations24bpp:

Public Member Functions
	Operations24bpp ()
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
Public Member Functions inherited from PipetteCommonOperationsRGB
	PipetteCommonOperationsRGB (int bps_)
PipetteLayerOperations::PipetteColor	sumPixelValues (Scroom::Utils::Rectangle< int > area, const ConstTile::Ptr &tile) override
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 >
boost::shared_ptr< R >	shared_from_this ()
template<typename R >
boost::shared_ptr< R const >	shared_from_this () const
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
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

Static Public Member Functions
static Ptr	create ()
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)

Additional Inherited Members
Public Types inherited from PipetteCommonOperationsRGB
using	Ptr = boost::shared_ptr< PipetteCommonOperationsRGB >
Public Types inherited from PipetteLayerOperations
using	Ptr = boost::shared_ptr< PipetteLayerOperations >
using	PipetteColor = std::vector< std::pair< std::string, double > >
Public Types inherited from LayerOperations
using	Ptr = boost::shared_ptr< LayerOperations >
Protected Attributes inherited from PipetteCommonOperationsRGB
int	bps

Constructor & Destructor Documentation

Operations24bpp()

Operations24bpp::Operations24bpp

(

)

  : PipetteCommonOperationsRGB(8)
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

cache()

Scroom::Utils::Stuff Operations24bpp::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.

{
  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);
  unsigned char*                         row    = data.get();
  for(int j = 0; j < tile->height; j++, row += stride)
  {
    const byte* cur = tile->data.get() + 3 * j * tile->width;
 
    auto* pixel = reinterpret_cast<uint32_t*>(row);
    for(int i = 0; i < tile->width; i++)
    {
      //         A          R              G             B
      *pixel = 0xFF000000 | cur[0] << 16 | cur[1] << 8 | cur[2];
 
      pixel++;
      cur += 3;
    }
  }
 
  return BitmapSurface::create(tile->width, tile->height, CAIRO_FORMAT_ARGB32, stride, data);
}

Here is the call graph for this function:

create()

PipetteCommonOperationsRGB::Ptr Operations24bpp::create ( )

static

{ return PipetteCommonOperationsRGB::Ptr(new Operations24bpp()); }

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

Here is the call graph for this function:

Here is the caller graph for this function:

getBpp()

int Operations24bpp::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 24; }

reduce()

void Operations24bpp::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 24bpp. Target tile is 24bpp
  const int   sourceStride = 3 * source->width; // stride in bytes
  const byte* sourceBase   = source->data.get();
 
  const int targetStride = 3 * target->width; // stride in bytes
  byte*     targetBase   = target->data.get() + target->height * y * targetStride / 8 + targetStride * 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 += 8 * 3, targetPtr += 3)
    {
      // Iterate horizontally over target
 
      // Goal is to compute a average RGB value from a 8*8 RGB image.
      const byte* base  = sourcePtr;
      int         sum_r = 0;
      int         sum_g = 0;
      int         sum_b = 0;
      for(int k = 0; k < 8; k++, base += sourceStride)
      {
        const byte* current = base;
        for(int l = 0; l < 8; l++, current += 3)
        {
          sum_r += current[0];
          sum_g += current[1];
          sum_b += current[2];
        }
      }
      targetPtr[0] = sum_r / 64;
      targetPtr[1] = sum_g / 64;
      targetPtr[2] = sum_b / 64;
    }
  }
}

---

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

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