Generates GLSL fragment shader code sampling a local neighborhood around the current texture coordinates for further filtering. More...

#include <operation.h>

Inheritance diagram for Beatmup::NNets::SpatialFilteringMixin:

Protected Member Functions
	SpatialFilteringMixin (const int nbSizeX, const int nbSizeY)
	Initializes spatial filtering mixin. More...

	~SpatialFilteringMixin ()

void	writeHeader (StringBuilder &code, bool useUniformShift)
	Writes out the very GLSL fragment shader header required for spatial neighborhood sampling. More...

void	declare (StringBuilder &code, const char *datatype, bool inlineSampling=false)
	Declares GLSL fragment shader main(..) code part required for spatial neighborhood sampling. More...

void	sample (StringBuilder &code, const char inputName, const int inputIndex, const Point &shift, const bool isFirstSample=true, const char suffix="")
	Samples a neighborhood of a given texture. More...

void	sampleInline (StringBuilder &code, const char inputName, const int inputIndex, const IntPoint &position, const Point &shift, const char suffix="")

void	setup (const int width, const int height)
	Prepares the spatial filtering operation execution. More...

void	setUniformShift (GL::Program &program, const IntPoint &shift, const IntPoint &inputSize)
	Applies an offset to the sampling position at runtime. More...

void	setupProgram (GL::Program &program)
	Prepares a given program for spatial filtering. More...

IntRectangle	getSamplingArea (const IntPoint &size, const IntPoint &stride, const Size::Padding padding) const
	Implements common padding policies by computing a rectangular area of positions the sampling kernel takes in order to get the result with the required padding. More...

IntRectangle	getSamplingArea (const Storage::View &storage, const int channel, const IntPoint &stride, const Size::Padding padding) const
	Computes area in pixels to sample a given storage according to specific stride and padding. More...

Rectangle	getTextureCoordinates (const Storage::View &storage, const int channel, const IntPoint &stride, const Size::Padding padding, const IntPoint &outputSize) const
	Computes texture coordinates sampling a specific storage channel for given stride, padding and output size. More...

std::string	getInputSamplingPos () const
	Retrieves input sampling point position for the current fragment. More...

bool	isUniformShiftUsed () const

Static Protected Attributes
static const char *	SAMPLE_ID_PREFIX = "i"
	prefix of variables declaring a neighbor sample More...

Private Member Functions
int	getDeltasSize () const

Private Attributes
const int	nbSizeX

const int	nbSizeY

Point	shift
	current static shift of the sampling position More...

float *	deltas
	array storing pixel position differences for neighborhood sampling More...

bool	useUniformShift
	if `true`, the sampling position can be shifted dynamically at every run More...

Detailed Description

Generates GLSL fragment shader code sampling a local neighborhood around the current texture coordinates for further filtering.

Definition at line 272 of file operation.h.

Constructor & Destructor Documentation

◆ SpatialFilteringMixin()

SpatialFilteringMixin::SpatialFilteringMixin	(	const int	nbSizeX,
		const int	nbSizeY
	)

protected

Initializes spatial filtering mixin.

Parameters

[in]	nbSizeX	Neighborhood width in samples
[in]	nbSizeY	Neighborhood height in samples

Definition at line 98 of file operation.cpp.

                                                                                 :
     nbSizeX(nbSizeX), nbSizeY(nbSizeY), useUniformShift(false)
 {
     deltas = new float[2 * getDeltasSize()];
 }

◆ ~SpatialFilteringMixin()

SpatialFilteringMixin::~SpatialFilteringMixin ( )

protected

Definition at line 105 of file operation.cpp.

                                               {
     delete[] deltas;
 }

Member Function Documentation

◆ getDeltasSize()

int Beatmup::NNets::SpatialFilteringMixin::getDeltasSize ( ) const

inlineprivate

Returns: number of 2D delta-vectors stored in a uniform variable in the fragment shader

Definition at line 282 of file operation.h.

282 { return std::max(1, std::max(nbSizeX, nbSizeY) / 2); }

std::max

CustomPoint< numeric > max(const CustomPoint< numeric > &a, const CustomPoint< numeric > &b)

Definition: geometry.h:728

◆ writeHeader()

void SpatialFilteringMixin::writeHeader	(	StringBuilder &	code,
		bool	useUniformShift
	)

protected

Writes out the very GLSL fragment shader header required for spatial neighborhood sampling.

Parameters

[in,out]	code	The GLSL code storage
[in]	useUniformShift	If `true`, the sampling position can be shifted dynamically at every run

Definition at line 110 of file operation.cpp.

                                                                                  {
     if (nbSizeX > 1 || nbSizeY > 1)
         code.printf("uniform highp vec2 %s[%d];\n", UNIFORM_DELTA, getDeltasSize());
     if (useUniformShift)
         code.printf("uniform highp vec2 %s;\n", UNIFORM_SHIFT);
     this->useUniformShift = useUniformShift;
 }

◆ declare()

void SpatialFilteringMixin::declare	(	StringBuilder &	code,
		const char *	datatype,
		bool	inlineSampling = `false`
	)

protected

Declares GLSL fragment shader main(..) code part required for spatial neighborhood sampling.

Parameters

[in,out]	code	The GLSL code storage
[in]	datatype	The neighborhood samples datatype
[in]	inlineSampling	If `true`, sampled values are not stored in intermediate variables (sampleInline() can only be used, not sample())

Definition at line 119 of file operation.cpp.

                                                                                                   {
     // declaring neighborhood samples
     const int nbSize = std::max(nbSizeX, nbSizeY);
     code.printf("%s i00", datatype);
     for (int i = 1; i < nbSize * nbSize; ++i)
         code.printf(", %s%d%d", SAMPLE_ID_PREFIX, i % nbSize, i / nbSize);
     code.line(";");
  
     // declaring/computing neighborhood positions
     const int mid = (nbSize - 1) / 2;
     code.printf("highp vec2 p%d = %s", mid, GL::RenderingPrograms::TEXTURE_COORDINATES_ID);
     if (useUniformShift)
         code.printf(" + %s", UNIFORM_SHIFT);
     for (int i = 0; i < nbSize; ++i) {
         if (i != mid) code(", ");
         if (i < mid)
             code.printf("p%d = p%d - %s[%d]", i, mid, UNIFORM_DELTA, mid - i - 1);
         else if (i > mid)
             code.printf("p%d = p%d + %s[%d]", i, mid, UNIFORM_DELTA, i - mid - 1);
     }
  
     // declaring neighborhood positions shifted for a current input channel
     if (!inlineSampling) {
         code(", cp0");
         for (int i = 1; i < nbSize; ++i)
             code.printf(", cp%d", i);
     }
     code.line(";");
 }

◆ sample()

void SpatialFilteringMixin::sample	(	StringBuilder &	code,
		const char *	inputName,
		const int	inputIndex,
		const Point &	shift,
		const bool	isFirstSample = `true`,
		const char *	suffix = `""`
	)

protected

Samples a neighborhood of a given texture.

Parameters

[in,out]	code	The GLSL code storage
[in]	inputName	The texture sampler array variable name
[in]	inputIndex	Index of the texture in the array
[in]	shift	Sampling position shift
[in]	isFirstSample	If `true`, this is a very first sampling operation. A required initial setup will be run.
[in]	suffix	Sampling operation suffix, e.g. ".rgb" to sample 3 values only

Definition at line 150 of file operation.cpp.

                                                                                                                                                                      {
     // shift neighborhood positions to the channel origin
     if (isFirstSample || this->shift != shift) {
         const int nbSize = std::max(nbSizeX, nbSizeY);
         for (int i = 0; i < nbSize; ++i)
             if (shift == Point::ZERO)
                 code.printf("cp%d = p%d;\n", i, i);
             else
                 code.printf("cp%d = p%d + vec2(" POS_FMT ", " POS_FMT ");\n", i, i, shift.x, shift.y);
         this->shift = shift;
     }
  
     // sample input
     for (int y = 0; y < nbSizeY; ++y)
     for (int x = 0; x < nbSizeX; ++x)
         if (x == y)
             code.printf("%s%d%d = texture2D(%s[%d], cp%d)%s;\n",
                 SAMPLE_ID_PREFIX, x, y, inputName, inputIndex, x, suffix);
         else
             code.printf("%s%d%d = texture2D(%s[%d], vec2(cp%d.x, cp%d.y))%s;\n",
                 SAMPLE_ID_PREFIX, x, y, inputName, inputIndex, x, y, suffix);
 }

◆ sampleInline()

void SpatialFilteringMixin::sampleInline	(	StringBuilder &	code,
		const char *	inputName,
		const int	inputIndex,
		const IntPoint &	position,
		const Point &	shift,
		const char *	suffix = `""`
	)

protected

Definition at line 174 of file operation.cpp.

                                                                                                                                                                            {
 #ifdef BEATMUP_DEBUG
     OutOfRange::check(position.x, 0, nbSizeX - 1, "neighbor X coordinate is out of range: %d");
     OutOfRange::check(position.y, 0, nbSizeY - 1, "neighbor X coordinate is out of range: %d");
 #endif
  
     // begin texture sampling statement
     code.printf("texture2D(%s[%d], ", inputName, inputIndex);
  
     // print out texture coordinate
     if (position.x == position.y)
         code.printf("p%d", position.x);
     else
         code.printf("vec2(p%d.x, p%d.y)", position.x, position.y);
  
     if (shift != Point::ZERO)
         code.printf(" + vec2(" POS_FMT ", " POS_FMT ")", shift.x, shift.y);
  
     // print the remainder
     code.printf(")%s", suffix);
 }

◆ setup()

void SpatialFilteringMixin::setup	(	const int	width,
		const int	height
	)

protected

Prepares the spatial filtering operation execution.

Parameters

[in]	width	Input texture width in pixels
[in]	height	Input texture height in pixels

Definition at line 197 of file operation.cpp.

                                                                    {
     if (nbSizeX > 1 || nbSizeY > 1) {
         const int deltaSize = getDeltasSize();
         for (int i = 0; i < deltaSize; ++i) {
             const float f = (float)(i + 1);
             deltas[2*i  ] = f / width;
             deltas[2*i+1] = f / height;
         }
     }
 }

◆ setUniformShift()

void SpatialFilteringMixin::setUniformShift	(	GL::Program &	program,
		const IntPoint &	shift,
		const IntPoint &	inputSize
	)

protected

Applies an offset to the sampling position at runtime.

Only used if the uniform shift is enabled when writing out the header code.

Parameters

[in,out]	program	The program
[in]	shift	The shift in pixels
[in]	inputSize	Size of the sampled input texture in pixels

Definition at line 209 of file operation.cpp.

                                                                                                                 {
 #ifdef BEATMUP_DEBUG
     DebugAssertion::check(useUniformShift, "Uniform shift is not enabled");
 #endif
     program.setVector2(UNIFORM_SHIFT, (float)shift.x / inputSize.x, (float)shift.y / inputSize.y);
 }

◆ setupProgram()

void SpatialFilteringMixin::setupProgram ( GL::Program & program )

protected

Prepares a given program for spatial filtering.

Parameters

[in,out] program The program

Definition at line 217 of file operation.cpp.

                                                            {
     if (nbSizeX > 1 || nbSizeY > 1)
         program.setVec2Array(UNIFORM_DELTA, deltas, getDeltasSize());
 }

◆ getSamplingArea() [1/2]

IntRectangle SpatialFilteringMixin::getSamplingArea	(	const IntPoint &	size,
		const IntPoint &	stride,
		const Size::Padding	padding
	)		const

protected

Implements common padding policies by computing a rectangular area of positions the sampling kernel takes in order to get the result with the required padding.

Parameters

[in]	size	The input size in pixels
[in]	stride	The stride
[in]	padding	The padding policy

Returns: kernel center point positions in pixels.

Definition at line 223 of file operation.cpp.

                                                                                                                                  {
     const IntPoint halfKernel((nbSizeX - 1) / 2, (nbSizeY - 1) / 2);
  
     if (padding == Size::Padding::VALID) {
         const IntPoint
             // number of times the kernel is applied
             n((size - IntPoint(nbSizeX, nbSizeY)) / stride + 1);
  
         return IntRectangle(halfKernel, halfKernel + (n - 1) * stride);
     }
  
     else {
         const IntPoint
             // number of times the kernel is applied
             n(ceili(size,  stride)),
  
             // pixels participating in all the kernels applications (distance from border to border)
             coverage = (n - 1) * stride + IntPoint(nbSizeX, nbSizeX),
  
             // excessive pixels to be padded on one side
             ledge = (coverage - size) / 2,
  
             // the ledge part covered by kernel
             kernelShift = std::min(halfKernel, halfKernel - ledge);
  
         return IntRectangle(kernelShift, kernelShift + (n - 1) * stride);
     }
 }

◆ getSamplingArea() [2/2]

IntRectangle SpatialFilteringMixin::getSamplingArea	(	const Storage::View &	storage,
		const int	channel,
		const IntPoint &	stride,
		const Size::Padding	padding
	)		const

protected

Computes area in pixels to sample a given storage according to specific stride and padding.

Parameters

[in]	storage	The input storage to sample
[in]	channel	Number of the channel to sample
[in]	stride	The stride
[in]	padding	The padding policy

Returns: kernel center point positions in pixels.

Definition at line 253 of file operation.cpp.

                                                                                                                                                           {
     return getSamplingArea(
         IntPoint(storage.getWidth(), storage.getHeight()),
         stride, padding
     ).translated(storage.getChannelOrigin(channel));
 }

◆ getTextureCoordinates()

Rectangle SpatialFilteringMixin::getTextureCoordinates	(	const Storage::View &	storage,
		const int	channel,
		const IntPoint &	stride,
		const Size::Padding	padding,
		const IntPoint &	outputSize
	)		const

protected

Computes texture coordinates sampling a specific storage channel for given stride, padding and output size.

Parameters

[in]	storage	The storage to sample
[in]	channel	The channel number in the storage to sample
[in]	stride	The stride
[in]	padding	The padding
[in]	outputSize	Size of output texture in pixels

Returns: rectangle containing texture coordinates.

Definition at line 261 of file operation.cpp.

         {
     return GraphicPipeline::getTextureCoordinates(
         getSamplingArea(storage, channel, stride, padding),
         IntPoint(storage.getTextureWidth(), storage.getTextureHeight()),
         outputSize
     );
 }

◆ getInputSamplingPos()

std::string SpatialFilteringMixin::getInputSamplingPos ( ) const

protected

Retrieves input sampling point position for the current fragment.

Defined after declare() is called.

Returns: the GLSL expression of the sampling position.

Definition at line 276 of file operation.cpp.

                                                            {
     const int mid = (std::max(nbSizeX, nbSizeY) - 1) / 2;
     return "p" + std::to_string(mid);
 }

◆ isUniformShiftUsed()

bool Beatmup::NNets::SpatialFilteringMixin::isUniformShiftUsed ( ) const

inlineprotected

Definition at line 394 of file operation.h.

394 { return useUniformShift; }

Member Data Documentation

◆ nbSizeX

const int Beatmup::NNets::SpatialFilteringMixin::nbSizeX

private

Definition at line 274 of file operation.h.

◆ nbSizeY

const int Beatmup::NNets::SpatialFilteringMixin::nbSizeY

private

Definition at line 274 of file operation.h.

◆ shift

Point Beatmup::NNets::SpatialFilteringMixin::shift

private

current static shift of the sampling position

Definition at line 275 of file operation.h.

◆ deltas

float* Beatmup::NNets::SpatialFilteringMixin::deltas

private

array storing pixel position differences for neighborhood sampling

Definition at line 276 of file operation.h.

◆ useUniformShift

bool Beatmup::NNets::SpatialFilteringMixin::useUniformShift

private

if true, the sampling position can be shifted dynamically at every run

Definition at line 277 of file operation.h.

◆ SAMPLE_ID_PREFIX

const char * SpatialFilteringMixin::SAMPLE_ID_PREFIX = "i"

staticprotected

prefix of variables declaring a neighbor sample

Definition at line 285 of file operation.h.

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

core/nnets/operation.h
core/nnets/operation.cpp

Protected Member Functions

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SpatialFilteringMixin()

◆ ~SpatialFilteringMixin()

Member Function Documentation

◆ getDeltasSize()

◆ writeHeader()

◆ declare()

◆ sample()

◆ sampleInline()

◆ setup()

◆ setUniformShift()

◆ setupProgram()

◆ getSamplingArea() [1/2]

◆ getSamplingArea() [2/2]

◆ getTextureCoordinates()

◆ getInputSamplingPos()

◆ isUniformShiftUsed()

Member Data Documentation

◆ nbSizeX

◆ nbSizeY

◆ shift

◆ deltas

◆ useUniformShift

◆ SAMPLE_ID_PREFIX