Beatmup::Metric Class Reference

Measures the difference between two bitmaps. More...

#include <metric.h>

Inheritance diagram for Beatmup::Metric:

Public Types
enum class	Norm { L1 , L2 }
	Norm (distance) to measure between two images. 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
	Metric ()
void	setBitmaps (AbstractBitmap *bitmap1, AbstractBitmap *bitmap2)
	Sets input images. More...
void	setBitmaps (AbstractBitmap *bitmap1, const IntRectangle &roi1, AbstractBitmap *bitmap2, const IntRectangle &roi2)
	Sets input images and rectangular regions delimiting the measurement areas. More...
void	setNorm (Norm norm)
	Specifies the norm to use in the measurement. More...
double	getResult () 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 ()

Static Public Member Functions
static float	psnr (AbstractBitmap &bitmap1, AbstractBitmap &bitmap2)
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
ThreadIndex	getMaxThreads () const
	Gives the upper limint on the number of threads the task may be performed by. More...
void	beforeProcessing (ThreadIndex threadCount, ProcessingTarget target, GraphicPipeline *gpu)
	Instruction called before the task is executed. More...
void	afterProcessing (ThreadIndex threadCount, GraphicPipeline *gpu, bool aborted)
	Instruction called after the task is executed. More...
bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. 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)

Private Attributes
AbstractBitmap *	bitmap [2]
IntRectangle	roi [2]
Norm	norm
std::vector< double >	results
double	result

Detailed Description

Measures the difference between two bitmaps.

Definition at line 29 of file metric.h.

Member Enumeration Documentation

Norm

enum Beatmup::Metric::Norm

strong

Norm (distance) to measure between two images.

Enumerator
L1
L2

Definition at line 34 of file metric.h.

                        {
            L1,
            L2
        };

Constructor & Destructor Documentation

Metric()

Metric::Metric

(

)

Definition at line 68 of file metric.cpp.

              : bitmap{ nullptr, nullptr }, norm(Norm::L2), result(0)
{}

Member Function Documentation

getMaxThreads()

ThreadIndex Beatmup::Metric::getMaxThreads ( ) const

inlineprivatevirtual

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 46 of file metric.h.

{ return  MAX_THREAD_INDEX; }

beforeProcessing()

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

privatevirtual

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 90 of file metric.cpp.

                                                                                                    {
    NullTaskInput::check(bitmap[0], "bitmap 1");
    NullTaskInput::check(bitmap[1], "bitmap 2");
    RuntimeError::check(bitmap[0]->getPixelFormat() == bitmap[1]->getPixelFormat(), "Pixel format mismatch");
    RuntimeError::check(roi[0] && roi[1], "Regions of interest are of different size");
    readLock(gpu, bitmap[0], ProcessingTarget::CPU);
    readLock(gpu, bitmap[1], ProcessingTarget::CPU);
    results.resize(threadCount);
}

afterProcessing()

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

privatevirtual

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 101 of file metric.cpp.

                                                                                        {
    unlock(bitmap[0], bitmap[1]);
 
    double sum = 0;
    for (const auto& _ : results)
        sum += _;
 
    switch (norm) {
    case Norm::L1:
        result = sum;
        break;
 
    case Norm::L2:
        result = std::sqrt(sum);
        break;
    }
}

process()

bool Metric::process ( TaskThread &  thread )

privatevirtual

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 120 of file metric.cpp.

                                       {
    const IntRectangle
        myRoi1 = roi[0].split(thread.currentThread(), thread.numThreads()),
        myRoi2 = roi[1].split(thread.currentThread(), thread.numThreads());
 
    switch (norm) {
    case Norm::L1:
        BitmapProcessing::write<Kernels::ComputeL1Metric>(*bitmap[0], *bitmap[1], myRoi1, myRoi2, results[thread.currentThread()]);
        break;
 
    case Norm::L2:
        BitmapProcessing::write<Kernels::ComputeSquaredL2Metric>(*bitmap[0], *bitmap[1], myRoi1, myRoi2, results[thread.currentThread()]);
        break;
    }
 
    return true;
}

setBitmaps() [1/2]

void Metric::setBitmaps	(	AbstractBitmap *	bitmap1,
		AbstractBitmap *	bitmap2
	)

Sets input images.

Definition at line 72 of file metric.cpp.

                                                                        {
    this->bitmap[0] = bitmap1;
    this->bitmap[1] = bitmap2;
    if (this->bitmap[0])
        roi[0] = this->bitmap[0]->getSize().halfOpenedRectangle();
    if (this->bitmap[1])
        roi[1] = this->bitmap[1]->getSize().halfOpenedRectangle();
}

setBitmaps() [2/2]

void Metric::setBitmaps	(	AbstractBitmap *	bitmap1,
		const IntRectangle &	roi1,
		AbstractBitmap *	bitmap2,
		const IntRectangle &	roi2
	)

Sets input images and rectangular regions delimiting the measurement areas.

Definition at line 82 of file metric.cpp.

                                                                                                                            {
    this->bitmap[0] = bitmap1;
    this->bitmap[1] = bitmap2;
    this->roi[0] = roi1;
    this->roi[1] = roi2;
}

setNorm()

void Beatmup::Metric::setNorm ( Norm  norm )

inline

Specifies the norm to use in the measurement.

Definition at line 67 of file metric.h.

{ this->norm = norm; }

getResult()

double Beatmup::Metric::getResult ( ) const

inline

Returns

the measurement result (after the task is executed)

Definition at line 72 of file metric.h.

{ return result; }

psnr()

float Metric::psnr ( AbstractBitmap &  bitmap1, AbstractBitmap &  bitmap2  )

static

Returns

peak signal-to-noise ratio in dB for two given images

Definition at line 139 of file metric.cpp.

                                                                   {
    Metric metric;
    metric.setBitmaps(&bitmap1, &bitmap2);
    metric.setNorm(Norm::L2);
    bitmap1.getContext().performTask(metric);
    const int n = bitmap1.getSize().numPixels() * bitmap1.getNumberOfChannels();
    return 20 * std::log10(std::sqrt((double)n) / metric.getResult());
}

Member Data Documentation

bitmap

AbstractBitmap* Beatmup::Metric::bitmap[2]

private

Definition at line 40 of file metric.h.

roi

IntRectangle Beatmup::Metric::roi[2]

private

Definition at line 41 of file metric.h.

norm

Norm Beatmup::Metric::norm

private

Definition at line 42 of file metric.h.

results

std::vector<double> Beatmup::Metric::results

private

Definition at line 43 of file metric.h.

result

double Beatmup::Metric::result

private

Definition at line 44 of file metric.h.

---

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

• core/bitmap/metric.h
• core/bitmap/metric.cpp