OperationsCMYK32 Class Reference

#include <layeroperations.hh>

Inheritance diagram for OperationsCMYK32:

Collaboration diagram for OperationsCMYK32:

Public Member Functions
	OperationsCMYK32 ()
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 PipetteCommonOperationsCMYK
	PipetteCommonOperationsCMYK (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 >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::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 PipetteCommonOperationsCMYK
using	Ptr = std::shared_ptr< PipetteCommonOperationsCMYK >
Public Types inherited from PipetteLayerOperations
using	Ptr = std::shared_ptr< PipetteLayerOperations >
using	PipetteColor = std::vector< std::pair< std::string, double > >
Public Types inherited from LayerOperations
using	Ptr = std::shared_ptr< LayerOperations >
Protected Attributes inherited from PipetteCommonOperationsCMYK
int	bps

Constructor & Destructor Documentation

OperationsCMYK32()

OperationsCMYK32::OperationsCMYK32

(

)

  : PipetteCommonOperationsCMYK(8)
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

cache()

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

overridevirtual

Cache the given tile

Reimplemented from LayerOperations.

{
  // Allocate the space for the cache - stride is the height of one row
  const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, tile->width);
  std::shared_ptr<uint8_t> const data = Scroom::Utils::shared_malloc(static_cast<size_t>(stride * tile->height));
 
  // Row is a pointer to a row of pixels (destination)
  auto* row = reinterpret_cast<uint32_t*>(data.get());
  // Cur is a pointer to the start of the row in the tile (source)
  const uint8_t* cur = tile->data.get();
 
  for(int i = 0; i < 4 * tile->height * tile->width; i += 4)
  {
    // Convert CMYK to ARGB, because cairo doesn't know how to render CMYK.
    auto C_i = static_cast<uint8_t>(255 - cur[i]);
    auto M_i = static_cast<uint8_t>(255 - cur[i + 1]);
    auto Y_i = static_cast<uint8_t>(255 - cur[i + 2]);
    auto K_i = static_cast<uint8_t>(255 - cur[i + 3]);
 
    uint32_t const R = static_cast<uint8_t>((C_i * K_i) / 255);
    uint32_t const G = static_cast<uint8_t>((M_i * K_i) / 255);
    uint32_t const B = static_cast<uint8_t>((Y_i * K_i) / 255);
 
    // Write 255 as alpha (fully opaque)
    row[i / 4] = 255u << 24 | R << 16 | G << 8 | B;
  }
 
  return Scroom::Bitmap::BitmapSurface::create(tile->width, tile->height, CAIRO_FORMAT_ARGB32, stride, data);
}

Here is the call graph for this function:

create()

PipetteCommonOperationsCMYK::Ptr OperationsCMYK32::create ( )

static

{ return PipetteCommonOperationsCMYK::Ptr(new OperationsCMYK32()); }

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

Here is the call graph for this function:

Here is the caller graph for this function:

getBpp()

int OperationsCMYK32::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 32; }

reduce()

void OperationsCMYK32::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
  const int sourceStride = 8 * source->width / 2; // stride in bytes
  const byte* sourceBase = source->data.get();
 
  const int targetStride = 8 * target->width / 2; // stride in bytes
  byte* targetBase = target->data.get() + (target->height * top_left_y + top_left_x) * targetStride / 8;
 
  for(int y = 0; y < source->height / 8; y++)
  {
    byte* targetPtr = targetBase;
 
    for(int x = 0; x < source->width / 8; x++)
    {
      // We want to store the average colour of the 8*8 pixel image
      // with (x, y) as its top-left corner into targetPtr.
      const byte* base = sourceBase + 8 * 4 * x; // start of the row
      const byte* end = base + 8 * sourceStride; // end of the row
 
      int sum_c = 0;
      int sum_m = 0;
      int sum_y = 0;
      int sum_k = 0;
      for(const byte* row = base; row < end; row += sourceStride)
      {
        for(size_t current = 0; current < 8 * 4; current += 4)
        {
          sum_c += row[current];
          sum_m += row[current + 1];
          sum_y += row[current + 2];
          sum_k += row[current + 3];
        }
      }
 
      targetPtr[0] = static_cast<byte>(sum_c / 64);
      targetPtr[1] = static_cast<byte>(sum_m / 64);
      targetPtr[2] = static_cast<byte>(sum_y / 64);
      targetPtr[3] = static_cast<byte>(sum_k / 64);
 
      targetPtr += 4;
    }
 
    targetBase += targetStride;
    sourceBase += sourceStride * 8;
  }
}

---

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

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