Beatmup::BitmapTools Namespace Reference

Set of handy operations with images. More...

Functions
InternalBitmap *	makeCopy (AbstractBitmap &bitmap)
	Makes a copy of a bitmap. More...
InternalBitmap *	makeCopy (AbstractBitmap &bitmap, PixelFormat pixelFormat)
	Makes a copy of a bitmap converting the data to a given pixel format. More...
InternalBitmap *	makeCopy (AbstractBitmap &bitmap, Context &context, PixelFormat pixelFormat)
	Makes a copy of a bitmap for a given Context converting the data to a given pixel format. More...
InternalBitmap *	chessboard (Context &context, int width, int height, int cellSize, PixelFormat pixelFormat=BinaryMask)
	Renders a chessboard image. More...
void	noise (AbstractBitmap &bitmap, IntRectangle area)
	Replaces a rectangular area in a bitmap by random noise. More...
void	noise (AbstractBitmap &bitmap)
	Fills a given bitmap with random noise. More...
void	makeOpaque (AbstractBitmap &bitmap, IntRectangle area)
	Makes a bitmap area opaque. More...
void	invert (AbstractBitmap &input, AbstractBitmap &output)
	Inverses colors of an image in a pixelwise fashion. More...
IntPoint	scanlineSearch (AbstractBitmap &source, pixint4 val, const IntPoint &startFrom)
	Goes through a bitmap in scanline order (left to right, top to bottom) until a pixel of a given color is met. More...
IntPoint	scanlineSearch (AbstractBitmap &source, pixfloat4 val, const IntPoint &startFrom)

Detailed Description

Set of handy operations with images.

Function Documentation

makeCopy() [1/3]

InternalBitmap * Beatmup::BitmapTools::makeCopy

(

AbstractBitmap &

bitmap

)

Makes a copy of a bitmap.

The copy is done in an AbstractTask run in the default thread pool of the context the bitmap is attached to.

Parameters

[in]

bitmap

The bitmap to copy

Definition at line 72 of file tools.cpp.

                                                            {
    return makeCopy(source, source.getPixelFormat());
}

makeCopy() [2/3]

InternalBitmap * Beatmup::BitmapTools::makeCopy	(	AbstractBitmap &	bitmap,
		PixelFormat	pixelFormat
	)

Makes a copy of a bitmap converting the data to a given pixel format.

The copy is done in an AbstractTask run in the default thread pool of the context the bitmap is attached to.

Parameters

[in]	bitmap	The bitmap to copy
[in]	pixelFormat	Pixel format of the copy

Definition at line 77 of file tools.cpp.

                                                                                        {
    return makeCopy(source, source.getContext(), newPixelFormat);
}

makeCopy() [3/3]

InternalBitmap * Beatmup::BitmapTools::makeCopy	(	AbstractBitmap &	bitmap,
		Context &	context,
		PixelFormat	pixelFormat
	)

Makes a copy of a bitmap for a given Context converting the data to a given pixel format.

Can be used to exchange image content between different instances of Context. The copy is done in an AbstractTask run in the default thread pool of the source bitmap context.

Parameters

[in]	bitmap	The bitmap to copy
[in]	context	The Context instance the copy is associated with
[in]	pixelFormat	Pixel format of the copy

Definition at line 82 of file tools.cpp.

                                                                                                          {
    InternalBitmap* copy = new Beatmup::InternalBitmap(context, newPixelFormat, source.getWidth(), source.getHeight());
    FormatConverter converter;
    converter.setBitmaps(&source, copy);
    source.getContext().performTask(converter);
    return copy;
}

chessboard()

InternalBitmap * Beatmup::BitmapTools::chessboard	(	Context &	context,
		int	width,
		int	height,
		int	cellSize,
		PixelFormat	pixelFormat = BinaryMask
	)

Renders a chessboard image.

Parameters

[in]	context	A Context instance
[in]	width	Width in pixels of the resulting bitmap
[in]	height	Height in pixels of the resulting bitmap
[in]	cellSize	Size of a single chessboard cell in pixels
[in]	pixelFormat	Pixel format of the resulting bitmap

Definition at line 91 of file tools.cpp.

                                                                                                                  {
    RuntimeError::check(cellSize > 0, "Chessboard cell size must be positive");
    InternalBitmap* chess = new Beatmup::InternalBitmap(ctx, pixelFormat, width, height);
    AbstractBitmap::WriteLock<ProcessingTarget::CPU> lock(*chess);
    BitmapProcessing::write<Kernels::ChessboardRendering>(*chess, width, height, cellSize);
    return chess;
}

noise() [1/2]

void Beatmup::BitmapTools::noise	(	AbstractBitmap &	bitmap,
		IntRectangle	area
	)

Replaces a rectangular area in a bitmap by random noise.

Parameters

[in]	bitmap	The bitmap
[in]	area	The area in pixels to process

Definition at line 100 of file tools.cpp.

                                                                 {
    AbstractBitmap::WriteLock<ProcessingTarget::CPU> lock(bitmap);
    const int n = bitmap.getNumberOfChannels();
 
    if (bitmap.isMask())
        throw ImplementationUnsupported("Noise is not implemented for mask bitmaps");
    // floating-point bitmap
    else if (bitmap.isFloat())
        for (int y = area.a.y; y <= area.b.y; ++y) {
            pixfloat* p = (pixfloat*)bitmap.getData(area.a.x, y);
            for (int x = area.a.x; x <= area.b.x; ++x)
                for (int i = 0; i < n; ++i, ++p)
                    *p = (float)std::rand() / RAND_MAX;
        }
    // integer bitmap
    else if (bitmap.isInteger()) {
        for (int y = area.a.y; y <= area.b.y; ++y) {
            pixbyte* p = bitmap.getData(area.a.x, y);
            for (int x = area.a.x; x <= area.b.x; ++x)
                for (int i = 0; i < n; ++i, ++p)
                    *p = std::rand() % 256;
        }
    }
}

noise() [2/2]

void Beatmup::BitmapTools::noise

(

AbstractBitmap &

bitmap

)

Fills a given bitmap with random noise.

Parameters

[in]

bitmap

The bitmap to fill

Definition at line 126 of file tools.cpp.

                                              {
    noise(bitmap, IntRectangle(0, 0, bitmap.getWidth() - 1, bitmap.getHeight() - 1));
}

makeOpaque()

void Beatmup::BitmapTools::makeOpaque	(	AbstractBitmap &	bitmap,
		IntRectangle	area
	)

Makes a bitmap area opaque.

Applies for bitmaps having the alpha channel (of QuadByte and QuadFloat pixel formats). Bitmaps of other pixel formats remain unchanged.

Parameters

[in]	bitmap	The bitmap
[in]	area	The area in pixels to process

Definition at line 131 of file tools.cpp.

                                                                      {
    AbstractBitmap::WriteLock<ProcessingTarget::CPU> lock(bitmap);
 
    // floating-point bitmap
    if (bitmap.getPixelFormat() == QuadFloat)
        for (int y = area.a.y; y <= area.b.y; ++y) {
            pixfloat* p = (pixfloat*)bitmap.getData(area.a.x, y);
            p += CHANNELS_4.A;
            *p = 1.0f;
            for (int x = area.a.x + 1; x <= area.b.x; ++x)
                *(p += 4) = 1.0f;
        }
    // integer bitmap
    else if (bitmap.getPixelFormat() == QuadByte)
        for (int y = area.a.y; y <= area.b.y; ++y) {
            pixbyte* p = bitmap.getData(area.a.x, y);
            p += CHANNELS_4.A;
            *p = 255;
            for (int x = area.a.x + 1; x <= area.b.x; ++x)
                *(p += 4) = 255;
        }
}

invert()

void Beatmup::BitmapTools::invert	(	AbstractBitmap &	input,
		AbstractBitmap &	output
	)

Inverses colors of an image in a pixelwise fashion.

Parameters

[in]	input	The input image. Its content unchanged.
[in]	output	The output image.

Definition at line 155 of file tools.cpp.

                                                                      {
    RuntimeError::check(input.getWidth() == output.getWidth() && input.getHeight() <= output.getHeight(),
        "Input size does not fit output size");
    RuntimeError::check(input.getPixelFormat() == output.getPixelFormat(),
        "Input/output pixel formats mismatch");
 
    AbstractBitmap::WriteLock<ProcessingTarget::CPU> outputLock(output);
    AbstractBitmap::ReadLock* readLock = (&input == &output) ? nullptr : new AbstractBitmap::ReadLock(input);
 
 
    const size_t NPIX = input.getSize().numPixels();
    if (input.isFloat()) {
        pixfloat
            *pi = (pixfloat*)input.getData(0, 0),
            *po = (pixfloat*)output.getData(0, 0);
        const pixfloat* STOP = pi + NPIX * AbstractBitmap::CHANNELS_PER_PIXEL[input.getPixelFormat()];
        while (pi < STOP)
            *(po++) = 1 - *(pi++);
    }
    else {
        const size_t N = NPIX * AbstractBitmap::BITS_PER_PIXEL[input.getPixelFormat()] / 8;
        // fast integer inverse
        pixint_platform
            *pi = (pixint_platform*)input.getData(0, 0),
            *po = (pixint_platform*)output.getData(0, 0);
        const pixint_platform* STOP = pi + N / sizeof(pixint_platform);
        while (pi < STOP)
            *(po++) = ~*(pi++);
        // process remaining bytes
        pixbyte
            *ri = (pixbyte*)pi,
            *ro = (pixbyte*)po;
        for (int r = 0; r < N % sizeof(pixint_platform); ++r)
            *(ro++) = ~*(ri++);
    }
 
    delete readLock;
}

scanlineSearch() [1/2]

IntPoint Beatmup::BitmapTools::scanlineSearch	(	AbstractBitmap &	source,
		pixint4	val,
		const IntPoint &	startFrom
	)

Goes through a bitmap in scanline order (left to right, top to bottom) until a pixel of a given color is met.

Parameters

[in]	source	The bitmap to scan
[in]	val	The color value to look for
[in]	startFrom	Starting pixel position

Returns

the next closest position of the searched value (in scanline order) or (-1,-1) if not found.

Definition at line 195 of file tools.cpp.

                                                                                                   {
    IntPoint result;
    AbstractBitmap::ReadLock lock(source);
    BitmapProcessing::read<Kernels::ScanlineSearch>(source, val, startFrom, result);
    return result;
}

scanlineSearch() [2/2]

IntPoint Beatmup::BitmapTools::scanlineSearch	(	AbstractBitmap &	source,
		pixfloat4	val,
		const IntPoint &	startFrom
	)

Definition at line 203 of file tools.cpp.

                                                                                                     {
    IntPoint result;
    AbstractBitmap::ReadLock lock(source);
    BitmapProcessing::read<Kernels::ScanlineSearch>(source, val, startFrom, result);
    return result;
}