A binary pixelwise operation on images. More...

#include <operator.h>

Inheritance diagram for Beatmup::BitmapBinaryOperation:

Public Types
enum class	Operation { NONE , ADD , MULTIPLY }
	Binary operation specification. More...

Public Types inherited from Beatmup::AbstractTask
enum class	TaskDeviceRequirement { CPU_ONLY , GPU_OR_CPU , GPU_ONLY }
	Specifies which device (CPU and/or GPU) is used to run the task. More...

Public Member Functions
	BitmapBinaryOperation ()

void	setOperand1 (AbstractBitmap *op1)

void	setOperand2 (AbstractBitmap *op2)

void	setOutput (AbstractBitmap *output)

void	setOperation (const Operation operation)

void	setCropSize (int width, int height)

void	setOp1Origin (const IntPoint origin)

void	setOp2Origin (const IntPoint origin)

void	setOutputOrigin (const IntPoint origin)

void	resetCrop ()

int	getCropWidth () const

int	getCropHeight () const

const IntPoint	getOp1Origin () const

const IntPoint	getOp2Origin () const

const IntPoint	getOutputOrigin () const

Public Member Functions inherited from Beatmup::AbstractTask
virtual bool	processOnGPU (GraphicPipeline &gpu, TaskThread &thread)
	Executes the task on GPU. More...

virtual TaskDeviceRequirement	getUsedDevices () const
	Communicates devices (CPU and/or GPU) the task is run on. More...

Public Member Functions inherited from Beatmup::Object
virtual	~Object ()

Protected Member Functions
virtual bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. More...

virtual void	beforeProcessing (ThreadIndex, ProcessingTarget target, GraphicPipeline *)
	Instruction called before the task is executed. More...

virtual void	afterProcessing (ThreadIndex, GraphicPipeline *, bool)
	Instruction called after the task is executed. More...

virtual ThreadIndex	getMaxThreads () const
	Gives the upper limint on the number of threads the task may be performed by. More...

Private Attributes
const int	MIN_PIXEL_COUNT_PER_THREAD = 1000
	minimum number of pixels per worker More...

AbstractBitmap *	op1

AbstractBitmap *	op2

AbstractBitmap *	output
	input and output bitmaps More...

Operation	operation

IntPoint	op1Origin

IntPoint	op2Origin

IntPoint	outputOrigin

int	cropWidth

int	cropHeight

Additional Inherited Members
Static Public Member Functions inherited from Beatmup::AbstractTask
static ThreadIndex	validThreadCount (int number)
	Valid thread count from a given integer value. More...

Private Member Functions inherited from Beatmup::BitmapContentLock
	BitmapContentLock ()

	~BitmapContentLock ()

void	readLock (GraphicPipeline gpu, AbstractBitmap bitmap, ProcessingTarget target)
	Locks content of a bitmap for reading using a specific processing target device. More...

void	writeLock (GraphicPipeline gpu, AbstractBitmap bitmap, ProcessingTarget target)
	Locks content of a bitmap for writing using a specific processing target device. More...

void	unlock (AbstractBitmap *bitmap)
	Drops a lock to the bitmap. More...

void	unlockAll ()
	Unlocks all the locked bitmaps unconditionally. More...

template<const ProcessingTarget target>
void	lock (GraphicPipeline gpu, AbstractBitmap input, AbstractBitmap *output)

void	lock (GraphicPipeline gpu, ProcessingTarget target, AbstractBitmap input, AbstractBitmap *output)

template<const ProcessingTarget target>
void	lock (GraphicPipeline gpu, std::initializer_list< AbstractBitmap > read, std::initializer_list< AbstractBitmap * > write)

template<typename ... Args>
void	unlock (AbstractBitmap *first, Args ... others)

Detailed Description

A binary pixelwise operation on images.

Evaluates expression O = op(L, R) for bitmaps L, R, O and a given pixelwise operation op. Allows to select the operating area in all the three bitmaps.

Definition at line 30 of file operator.h.

Member Enumeration Documentation

◆ Operation

enum Beatmup::BitmapBinaryOperation::Operation

strong

Binary operation specification.

Enumerator
NONE	bypass; the output bitmap remains unchanged
ADD	the input images are added
MULTIPLY	the input images are multiplied

Definition at line 35 of file operator.h.

                              {
             NONE,       //!< bypass; the output bitmap remains unchanged
             ADD,        //!< the input images are added
             MULTIPLY    //!< the input images are multiplied
         };

Constructor & Destructor Documentation

◆ BitmapBinaryOperation()

BitmapBinaryOperation::BitmapBinaryOperation ( )

Definition at line 156 of file operator.cpp.

                                              :
     op1(nullptr), op2(nullptr), output(nullptr),
     operation(Operation::NONE)
 {}

Member Function Documentation

◆ process()

bool BitmapBinaryOperation::process ( TaskThread & thread )

protectedvirtual

Executes the task on CPU within a given thread.

Generally called by multiple threads.

Parameters

thread associated task execution context

Returns: true if the execution is finished correctly, false otherwise

Implements Beatmup::AbstractTask.

Definition at line 240 of file operator.cpp.

                                                       {
 #define PROCESS(IN_T, OUT_T) \
         Kernels::BinaryOpBody<IN_T, OUT_T>::process( \
             IN_T(*op1), IN_T(*op2), OUT_T(*output), \
             operation, cropWidth, cropHeight, op1Origin, op2Origin, outputOrigin, thread);
  
     switch (output->getPixelFormat()) {
         case SingleByte:
             PROCESS(SingleByteBitmapReader, SingleByteBitmapWriter);
             break;
         case TripleByte:
             PROCESS(TripleByteBitmapReader, TripleByteBitmapWriter);
             break;
         case QuadByte:
             PROCESS(QuadByteBitmapReader, QuadByteBitmapWriter);
             break;
         case SingleFloat:
             PROCESS(SingleFloatBitmapReader, SingleFloatBitmapWriter);
             break;
         case TripleFloat:
             PROCESS(TripleFloatBitmapReader, TripleFloatBitmapWriter);
             break;
         case QuadFloat:
             PROCESS(QuadFloatBitmapReader, QuadFloatBitmapWriter);
             break;
         case BinaryMask:
             if (op1Origin.x % 8 == 0 && op2Origin.x % 8 == 0 && outputOrigin.x % 8 == 0)
                 Kernels::BinaryOpBody<BinaryMaskReader, BinaryMaskWriter>::processAlignedBinaryMask(
                         BinaryMaskReader(*op1), BinaryMaskReader(*op2), BinaryMaskWriter(*output),
                         operation, cropWidth, cropHeight, op1Origin, op2Origin, outputOrigin,
                         thread);
             else
                 PROCESS(BinaryMaskReader, BinaryMaskWriter);
             break;
         case QuaternaryMask:
             PROCESS(QuaternaryMaskReader, QuaternaryMaskWriter);
             break;
         case HexMask:
             PROCESS(HexMaskReader, HexMaskWriter);
             break;
     }
     return true;
 }

◆ beforeProcessing()

void BitmapBinaryOperation::beforeProcessing	(	ThreadIndex	threadCount,
		ProcessingTarget	target,
		GraphicPipeline *	gpu
	)

protectedvirtual

Instruction called before the task is executed.

Parameters

threadCount	Number of threads used to perform the task
target	Device used to perform the task
gpu	A graphic pipeline instance; may be null.

Reimplemented from Beatmup::AbstractTask.

Definition at line 217 of file operator.cpp.

                                                                                                                    {
     NullTaskInput::check(op1, "operand 1 bitmap");
     NullTaskInput::check(op2, "operand 2 bitmap");
     NullTaskInput::check(output, "output bitmap");
     RuntimeError::check(op1->getPixelFormat() == op2->getPixelFormat(), "operands pixel formats do not match");
     RuntimeError::check(op1->getPixelFormat() == output->getPixelFormat(), "output pixel format does not match operands pixel format");
     RuntimeError::check(op1Origin.x + cropWidth  <= op1->getWidth(),  "operand 1 width exceeded");
     RuntimeError::check(op1Origin.y + cropHeight <= op1->getHeight(), "operand 1 height exceeded");
     RuntimeError::check(op2Origin.x + cropWidth  <= op2->getWidth(),  "operand 2 width exceeded");
     RuntimeError::check(op2Origin.y + cropHeight <= op2->getHeight(), "operand 2 height exceeded");
     RuntimeError::check(outputOrigin.x + cropWidth  <= output->getWidth(),  "operand 1 width exceeded");
     RuntimeError::check(outputOrigin.y + cropHeight <= output->getHeight(), "operand 1 height exceeded");
  
  
     lock<ProcessingTarget::CPU>(gpu, { op1, op2 }, { output });
 }

◆ afterProcessing()

void BitmapBinaryOperation::afterProcessing	(	ThreadIndex	threadCount,
		GraphicPipeline *	gpu,
		bool	aborted
	)

protectedvirtual

Instruction called after the task is executed.

Parameters

threadCount	Number of threads used to perform the task
gpu	GPU to be used to execute the task; may be null.
aborted	`true` if the task was aborted

Reimplemented from Beatmup::AbstractTask.

Definition at line 235 of file operator.cpp.

                                                                                                        {
     unlock(output, op1, op2);
 }

◆ getMaxThreads()

ThreadIndex BitmapBinaryOperation::getMaxThreads ( ) const

protectedvirtual

Gives the upper limint on the number of threads the task may be performed by.

The actual number of threads running a specific task may be less or equal to the returned value, depending on the number of workers in ThreadPool running the task.

Reimplemented from Beatmup::AbstractTask.

Definition at line 212 of file operator.cpp.

                                                        {
     return AbstractTask::validThreadCount(cropHeight / MIN_PIXEL_COUNT_PER_THREAD);
 }

◆ setOperand1()

void BitmapBinaryOperation::setOperand1 ( AbstractBitmap * op1 )

Definition at line 162 of file operator.cpp.

                                                               {
     this->op1 = bitmap;
 }

◆ setOperand2()

void BitmapBinaryOperation::setOperand2 ( AbstractBitmap * op2 )

Definition at line 167 of file operator.cpp.

                                                               {
     this->op2 = bitmap;
 }

◆ setOutput()

void BitmapBinaryOperation::setOutput ( AbstractBitmap * output )

Definition at line 172 of file operator.cpp.

                                                             {
     this->output = bitmap;
 }

◆ setOperation()

void BitmapBinaryOperation::setOperation ( const Operation operation )

Definition at line 177 of file operator.cpp.

                                                                   {
     this->operation = operation;
 }

◆ setCropSize()

void BitmapBinaryOperation::setCropSize	(	int	width,
		int	height
	)

Definition at line 182 of file operator.cpp.

                                                              {
     this->cropWidth = width;
     this->cropHeight = height;
 }

◆ setOp1Origin()

void BitmapBinaryOperation::setOp1Origin ( const IntPoint origin )

Definition at line 188 of file operator.cpp.

                                                               {
     this->op1Origin = origin;
 }

◆ setOp2Origin()

void BitmapBinaryOperation::setOp2Origin ( const IntPoint origin )

Definition at line 193 of file operator.cpp.

                                                               {
     this->op2Origin = origin;
 }

◆ setOutputOrigin()

void BitmapBinaryOperation::setOutputOrigin ( const IntPoint origin )

Definition at line 198 of file operator.cpp.

                                                                  {
     this->outputOrigin = origin;
 }

◆ resetCrop()

void BitmapBinaryOperation::resetCrop ( )

Definition at line 203 of file operator.cpp.

                                       {
     if (op1 && op2 && output) {
         cropWidth  = std::min(output->getWidth(),  std::min(op1->getWidth(),  op2->getWidth()));
         cropHeight = std::min(output->getHeight(), std::min(op1->getHeight(), op2->getHeight()));
         op1Origin = op2Origin = outputOrigin = IntPoint::ZERO;
     }
 }

◆ getCropWidth()

int Beatmup::BitmapBinaryOperation::getCropWidth ( ) const

inline

Definition at line 68 of file operator.h.

68 { return cropWidth; }

◆ getCropHeight()

int Beatmup::BitmapBinaryOperation::getCropHeight ( ) const

inline

Definition at line 69 of file operator.h.

69 { return cropHeight; }

◆ getOp1Origin()

const IntPoint Beatmup::BitmapBinaryOperation::getOp1Origin ( ) const

inline

Definition at line 70 of file operator.h.

70 { return op1Origin; }

◆ getOp2Origin()

const IntPoint Beatmup::BitmapBinaryOperation::getOp2Origin ( ) const

inline

Definition at line 71 of file operator.h.

71 { return op2Origin; }

◆ getOutputOrigin()

const IntPoint Beatmup::BitmapBinaryOperation::getOutputOrigin ( ) const

inline

Definition at line 72 of file operator.h.

72 { return outputOrigin; }

Member Data Documentation

◆ MIN_PIXEL_COUNT_PER_THREAD

const int Beatmup::BitmapBinaryOperation::MIN_PIXEL_COUNT_PER_THREAD = 1000

private

minimum number of pixels per worker

Definition at line 42 of file operator.h.

◆ op1

AbstractBitmap* Beatmup::BitmapBinaryOperation::op1

private

Definition at line 44 of file operator.h.

◆ op2

AbstractBitmap * Beatmup::BitmapBinaryOperation::op2

private

Definition at line 44 of file operator.h.

◆ output

AbstractBitmap * Beatmup::BitmapBinaryOperation::output

private

input and output bitmaps

Definition at line 44 of file operator.h.

◆ operation

Operation Beatmup::BitmapBinaryOperation::operation

private

Definition at line 45 of file operator.h.

◆ op1Origin

IntPoint Beatmup::BitmapBinaryOperation::op1Origin

private

Definition at line 46 of file operator.h.

◆ op2Origin

IntPoint Beatmup::BitmapBinaryOperation::op2Origin

private

Definition at line 46 of file operator.h.

◆ outputOrigin

IntPoint Beatmup::BitmapBinaryOperation::outputOrigin

private

Definition at line 46 of file operator.h.

◆ cropWidth

int Beatmup::BitmapBinaryOperation::cropWidth

private

Definition at line 47 of file operator.h.

◆ cropHeight

int Beatmup::BitmapBinaryOperation::cropHeight

private

Definition at line 47 of file operator.h.

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

core/bitmap/operator.h
core/bitmap/operator.cpp

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Operation

Constructor & Destructor Documentation

◆ BitmapBinaryOperation()

Member Function Documentation

◆ process()

◆ beforeProcessing()

◆ afterProcessing()

◆ getMaxThreads()

◆ setOperand1()

◆ setOperand2()

◆ setOutput()

◆ setOperation()

◆ setCropSize()

◆ setOp1Origin()

◆ setOp2Origin()

◆ setOutputOrigin()

◆ resetCrop()

◆ getCropWidth()

◆ getCropHeight()

◆ getOp1Origin()

◆ getOp2Origin()

◆ getOutputOrigin()

Member Data Documentation

◆ MIN_PIXEL_COUNT_PER_THREAD

◆ op1

◆ op2

◆ output

◆ operation

◆ op1Origin

◆ op2Origin

◆ outputOrigin

◆ cropWidth

◆ cropHeight