kaleidoscope.c File Reference

#include "kaleidoscope.h"
#include "kaleidoscope-config.h"
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for kaleidoscope.c:

Go to the source code of this file.

Functions
void	getKaleidoscopeVersion (int *major, int *minor, int *patch)
	Get the Kaleidoscope Library version as integer.
char *	getKaleidoscopeVersionString ()
	Get the Kaleidoscope Library version as string.
char *	getKaleidoscopeLibraryInfo ()
	Get the Kaleidoscope Library info as string.
static int	compare (const void *lhsPtr, const void *rhsPtr)
void	interpolate (TransformationInfo *dataOut, const TransformationInfo *dataIn, int width, int height)
	A simple interpolation function. Internal use only.
void	rotatePoints (TransformationInfo *outData, const TransformationInfo *orgData, int width, int height, double angle)
	Rotates the coordinates of sliced triangle. Internal use only.
void	sliceTriangle (TransformationInfo *transformPtr, int width, int height, int n, double scaleDown)
	Slices a suitable triangle from image.
int	initKaleidoscope (KaleidoscopeHandle *handler, int n, int width, int height, int nComponents, double scaleDown)
	Initializes kaleidoscope handler.
void	processKaleidoscope (const KaleidoscopeHandle *handler, double k, const unsigned char *imgIn, unsigned char *imgOut)
	Applies kaleidoscope effect to image.
void	deInitKaleidoscope (KaleidoscopeHandle *handler)
	Deinitializes kaleidoscope handler.

Function Documentation

compare()

static int compare ( const void * lhsPtr, const void * rhsPtr )

static

Definition at line 55 of file kaleidoscope.c.

{
    const TransformationInfo *lhs = (const TransformationInfo *)lhsPtr;
    const TransformationInfo *rhs = (const TransformationInfo *)rhsPtr;
    return (int)(lhs->dstOffset - rhs->dstOffset);
}

Here is the caller graph for this function:

deInitKaleidoscope()

void deInitKaleidoscope

(

KaleidoscopeHandle *

handler

)

Deinitializes kaleidoscope handler.

Parameters

[in]

handler

Kaleidoscope effect handler

Definition at line 319 of file kaleidoscope.c.

{
    if (handler)
        free(handler->pTransferFunc);
}

Here is the caller graph for this function:

getKaleidoscopeLibraryInfo()

char * getKaleidoscopeLibraryInfo

(

)

Get the Kaleidoscope Library info as string.

Returns

char* Library information

Definition at line 30 of file kaleidoscope.c.

{
    int offset = 0;
    static char info[125];
 
    strncpy(info, PROJECT_VERSION, sizeof(PROJECT_VERSION));
    offset += sizeof(PROJECT_VERSION);
    memset(&info[offset - 1], 32, 1);
    strncpy(&info[offset], COMPILER_NAME, sizeof(COMPILER_NAME));
    offset += sizeof(COMPILER_NAME);
    memset(&info[offset - 1], 32, 1);
    strncpy(&info[offset], COMPILER_VERSION, sizeof(COMPILER_VERSION));
    offset += sizeof(COMPILER_VERSION);
    memset(&info[offset - 1], 32, 1);
    strncpy(&info[offset], BUILD_TYPE, sizeof(BUILD_TYPE));
    offset += sizeof(BUILD_TYPE);
    memset(&info[offset - 1], 32, 1);
    strncpy(&info[offset], PROJECT_BUILD_DATE, sizeof(PROJECT_BUILD_DATE));
    offset += sizeof(PROJECT_BUILD_DATE);
    memset(&info[offset - 1], 32, 1);
    strncpy(&info[offset], PROJECT_BUILD_TIME, sizeof(PROJECT_BUILD_TIME));
 
    return info;
}

Here is the caller graph for this function:

getKaleidoscopeVersion()

void getKaleidoscopeVersion	(	int *	major,
		int *	minor,
		int *	patch )

Get the Kaleidoscope Library version as integer.

Parameters

[in,out]	major	Major number
[in,out]	minor	Minor number
[in,out]	patch	Patch number

Definition at line 13 of file kaleidoscope.c.

{
    if (major && minor && patch)
    {
        *major = PROJECT_MAJOR_VERSION;
        *minor = PROJECT_MINOR_VERSION;
        *patch = PROJECT_PATCH_VERSION;
    }
}

getKaleidoscopeVersionString()

char * getKaleidoscopeVersionString

(

)

Get the Kaleidoscope Library version as string.

Returns

char* Library version

Definition at line 23 of file kaleidoscope.c.

{
    static char info[sizeof(PROJECT_VERSION)];
    strncpy(info, PROJECT_VERSION, sizeof(PROJECT_VERSION));
    return info;
}

initKaleidoscope()

int initKaleidoscope	(	KaleidoscopeHandle *	handler,
		int	n,
		int	width,
		int	height,
		int	nComponents,
		double	scaleDown )

Initializes kaleidoscope handler.

Parameters

[in,out]	handler	Kaleidoscope effect handler
[in]	n	Number of images for effect. Should be greater than 2
[in]	width	Image width
[in]	height	Image height
[in]	nComponents	Number of image components (eg 3 for RGB)
[in]	scaleDown	Scale down ratio to shrink image. Must be between 0.0 and 1.0

Returns

int 0 on success, negative otherwise

Definition at line 197 of file kaleidoscope.c.

{
    int jdx;
 
    int retval = EXIT_FAILURE;
    const int nPixels = width * height;
    TransformationInfo *buffPtr1 = NULL;
    TransformationInfo *buffPtr2 = NULL;
 
    // Check parameters
    if (handler == NULL || n <= 2 || width <= 0 || height <= 0 || nComponents <= 0 || scaleDown <= 0.0 ||
        scaleDown >= 1.0)
    {
        return EXIT_FAILURE;
    }
 
    assert(handler);
    assert(n > 2);
    assert(width > 0);
    assert(height > 0);
    assert(nComponents > 0);
    assert(scaleDown > 0.0);
    assert(scaleDown < 1.0);
 
    handler->width = width;
    handler->height = height;
    handler->nComponents = (unsigned char)nComponents;
 
    buffPtr1 = (TransformationInfo *)calloc(nPixels, sizeof(TransformationInfo));
    buffPtr2 = (TransformationInfo *)calloc(nPixels, sizeof(TransformationInfo));
    if (!buffPtr1 || !buffPtr2)
    {
        goto cleanup;
    }
 
    sliceTriangle(buffPtr1, width, height, n, scaleDown);
 
    // Rotate all points and fix origin to left top
    for (int idx = 0; idx < n; ++idx)
    {
        double rotationAngle = idx * (360.0 / n);
        rotatePoints(buffPtr2, buffPtr1, width, height, rotationAngle);
    }
 
    // Fill rotation artifacts
    memset(buffPtr1, 0, sizeof(TransformationInfo) * width * height);
    interpolate(buffPtr1, buffPtr2, width, height);
 
    // Remove zeros and set to points for handler
    handler->nPoints = 0;
    for (int idx = 0; idx < nPixels; ++idx)
    {
        const TransformationInfo *ptr = &buffPtr1[idx];
        if (!(ptr->srcLocation.x) || !(ptr->srcLocation.y))
        {
            continue;
        }
 
        buffPtr1[handler->nPoints] = *ptr;
        buffPtr1[handler->nPoints].srcOffset =
            ptr->srcLocation.x * nComponents + ptr->srcLocation.y * width * nComponents;
        buffPtr1[handler->nPoints].dstOffset =
            ptr->dstLocation.x * nComponents + ptr->dstLocation.y * width * nComponents;
        ++(handler->nPoints);
    }
 
    // Sort
    qsort(buffPtr1, handler->nPoints, sizeof(TransformationInfo), compare);
 
    // Deduplicate
    jdx = 0;
    for (int idx = 1; idx < handler->nPoints; ++idx)
    {
        if (compare(&buffPtr1[jdx], &buffPtr1[idx]))
        {
            buffPtr1[jdx] = buffPtr1[idx];
            ++jdx;
        }
    }
    handler->nPoints = jdx;
 
    if (handler->nPoints <= 0) // Prevent allocation of zero points
    {
        goto cleanup;
    }
 
    handler->pTransferFunc = (TransformationInfo *)malloc(handler->nPoints * sizeof(TransformationInfo));
    memcpy(handler->pTransferFunc, buffPtr1, handler->nPoints * sizeof(TransformationInfo));
    retval = EXIT_SUCCESS;
 
cleanup:
    free(buffPtr1);
    free(buffPtr2);
 
    if (retval == EXIT_FAILURE)
    {
        free(handler->pTransferFunc);
    }
 
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate()

void interpolate	(	TransformationInfo *	dataOut,
		const TransformationInfo *	dataIn,
		int	width,
		int	height )

A simple interpolation function. Internal use only.

Parameters

[out]	dataOut	Output (interpolated) binary image
[in]	dataIn	Input binary image
[in]	width	Width of input image
[in]	height	Height of input image

Definition at line 62 of file kaleidoscope.c.

{
    // Very simple implementation of nearest neighbour interpolation
    for (int idx = 1; idx < height - 1; ++idx)
    {
        int heightOffset = idx * width;
        for (int jdx = 1; jdx < width - 1; ++jdx)
        {
            const TransformationInfo *ptrIn = &dataIn[heightOffset + jdx];
            TransformationInfo *ptrOut = &dataOut[heightOffset + jdx];
            if (!(ptrIn->dstLocation.x) && !(ptrIn->dstLocation.y))
            {
                ptrOut->dstLocation.x = jdx;
                ptrOut->dstLocation.y = idx;
                if (((ptrIn - 1)->dstLocation.x) || ((ptrIn - 1)->dstLocation.y)) // Left
                {
                    ptrOut->srcLocation.x = (ptrIn - 1)->srcLocation.x + 1;
                    ptrOut->srcLocation.y = (ptrIn - 1)->srcLocation.y;
                }
                else if (((ptrIn + 1)->dstLocation.x) || ((ptrIn + 1)->dstLocation.y)) // Right
                {
                    ptrOut->srcLocation.x = (ptrIn + 1)->srcLocation.x - 1;
                    ptrOut->srcLocation.y = (ptrIn + 1)->srcLocation.y;
                }
                else if (((ptrIn - width)->dstLocation.x) || ((ptrIn - width)->dstLocation.y)) // Top
                {
                    ptrOut->srcLocation.x = (ptrIn - width)->srcLocation.x;
                    ptrOut->srcLocation.y = (ptrIn - width)->srcLocation.y - 1;
                }
                else if (((ptrIn + width)->dstLocation.x) || ((ptrIn + width)->dstLocation.y)) // Bottom
                {
                    ptrOut->srcLocation.x = (ptrIn + width)->srcLocation.x;
                    ptrOut->srcLocation.y = (ptrIn + width)->srcLocation.y + 1;
                }
                else if (((ptrIn - width - 1)->dstLocation.x) || ((ptrIn - width - 1)->dstLocation.y)) // Top-Left
                {
                    ptrOut->srcLocation.x = (ptrIn - width - 1)->srcLocation.x - 1;
                    ptrOut->srcLocation.y = (ptrIn - width - 1)->srcLocation.y - 1;
                }
                else if (((ptrIn - width + 1)->dstLocation.x) || ((ptrIn - width + 1)->dstLocation.y)) // Top-Right
                {
                    ptrOut->srcLocation.x = (ptrIn - width + 1)->srcLocation.x + 1;
                    ptrOut->srcLocation.y = (ptrIn - width + 1)->srcLocation.y - 1;
                }
                else if (((ptrIn + width - 1)->dstLocation.x) || ((ptrIn + width - 1)->dstLocation.y)) // Bottom-Left
                {
                    ptrOut->srcLocation.x = (ptrIn + width - 1)->srcLocation.x - 1;
                    ptrOut->srcLocation.y = (ptrIn + width - 1)->srcLocation.y - 1;
                }
                else if (((ptrIn + width + 1)->dstLocation.x) || ((ptrIn + width + 1)->dstLocation.y)) // Bottom-Right
                {
                    ptrOut->srcLocation.x = (ptrIn + width + 1)->srcLocation.x + 1;
                    ptrOut->srcLocation.y = (ptrIn + width + 1)->srcLocation.y + 1;
                }
                else
                {
                    memset(ptrOut, 0, sizeof(TransformationInfo));
                }
            }
            else
            {
                *ptrOut = *ptrIn;
            }
        }
    }
}

Here is the caller graph for this function:

processKaleidoscope()

void processKaleidoscope	(	const KaleidoscopeHandle *	handler,
		double	k,
		const unsigned char *	imgIn,
		unsigned char *	imgOut )

Applies kaleidoscope effect to image.

Parameters

[in]	handler	Kaleidoscope effect handler
[in]	k	Variable to dim background. Should be between 0.0 and 1.0
[in]	imgIn	Input image
[out]	imgOut	Output image

Definition at line 299 of file kaleidoscope.c.

{
    long long idx;
    const long long nComponents = handler->nComponents;
    const long long nPixels = (long long)handler->width * handler->height * handler->nComponents;
 
    const unsigned char *srcPtr = imgIn;
    unsigned char *destPtr = imgOut;
    const TransformationInfo *ptrTransform = &(handler->pTransferFunc[0]);
 
    for (idx = 0; idx < nPixels; ++idx, ++destPtr, ++srcPtr) // Dim image
    {
        *destPtr = (unsigned char)((*srcPtr) * k);
    }
    for (idx = 0; idx < handler->nPoints; ++idx, ++ptrTransform) // Merge
    {
        memcpy(&(imgOut[ptrTransform->dstOffset]), &(imgIn[ptrTransform->srcOffset]), nComponents);
    }
}

Here is the caller graph for this function:

rotatePoints()

void rotatePoints	(	TransformationInfo *	outData,
		const TransformationInfo *	orgData,
		int	width,
		int	height,
		double	angle )

Rotates the coordinates of sliced triangle. Internal use only.

Parameters

[out]	outData	Rotated data
[in]	orgData	Sliced data coordinates
[in]	width	Width of input image
[in]	height	Height of input image
[in]	angle	Top angle of sliced triangle

Definition at line 129 of file kaleidoscope.c.

{
    double cosVal = cos(angle * M_PI / 180);
    double sinVal = sin(angle * M_PI / 180);
 
    for (int idx = 0; idx < width * height; ++idx)
    {
        if (orgData[idx].dstLocation.x || orgData[idx].dstLocation.y)
        {
            int newX = (int)round(orgData[idx].dstLocation.x * cosVal + orgData[idx].dstLocation.y * sinVal);
            int newY = (int)round(orgData[idx].dstLocation.y * cosVal - orgData[idx].dstLocation.x * sinVal);
 
            // Fix origin to top left again
            newX += (width / 2);
            newY += (height / 2);
 
            if (newX <= width && newX >= 0 && newY <= height && newY >= 0)
            {
                outData[newY * width + newX].srcLocation = orgData[idx].srcLocation;
                outData[newY * width + newX].dstLocation.x = newX;
                outData[newY * width + newX].dstLocation.y = newY;
            }
        }
    }
}

Here is the caller graph for this function:

sliceTriangle()

void sliceTriangle	(	TransformationInfo *	transformPtr,
		int	width,
		int	height,
		int	n,
		double	scaleDown )

Slices a suitable triangle from image.

Parameters

[out]	transformPtr	Sliced triangle coordinates
[in]	width	Width of input image
[in]	height	Height of input image
[in]	n	Number of images for effect
[in]	scaleDown	Scale down ratio to shrink image

Definition at line 155 of file kaleidoscope.c.

{
    // Variables
    const double topAngle = 360.0 / n;
    const double tanVal = tan(topAngle / 2.0 * M_PI / 180.0); // tan(topAngle / 2) in radians
    const int triangleHeight = (int)fmin(round(width / (2.0 * tanVal)), height - 1);
    const int heightStart = (height - triangleHeight) / 2;
    const int heightEnd = (height + triangleHeight) / 2;
    const int scaleDownOffset = (int)(height * scaleDown / 2);
 
    // Ensure limits within image
    assert(heightStart >= 0);
    assert(heightStart <= height);
    assert(heightEnd >= 0);
    assert(heightEnd <= height);
 
    for (int idx = heightStart; idx < heightEnd; ++idx)
    {
        const int currentBaseLength = (int)((idx - heightStart) * tanVal);
 
        const int widthStart = (width / 2 - currentBaseLength);
        const int widthEnd = (width / 2 + currentBaseLength);
 
        // Ensure limits within image
        if (widthStart < 0 || widthStart > width || widthEnd < 0 || widthEnd > width)
        {
            continue;
        }
 
        TransformationInfo *ptr = &transformPtr[idx * width];
        for (int jdx = widthStart; jdx <= widthEnd; ++jdx)
        {
            ptr[jdx].srcLocation.x = jdx;
            ptr[jdx].srcLocation.y = idx;
 
            // Calculate coordinates respect to center to prepare rotating
            ptr[jdx].dstLocation.x = (int)((jdx - width / 2) * scaleDown);
            ptr[jdx].dstLocation.y = (int)((idx - heightStart - height / 2) * scaleDown + scaleDownOffset);
        }
    }
}

Here is the caller graph for this function: