vx_helper.c

/*
 * Copyright (c) 2012-2014 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Materials, and to
 * permit persons to whom the Materials are furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

#include <stdlib.h>
#include <VX/vx.h>
#include <VX/vx_helper.h>
#include <math.h>

#if defined(EXPERIMENTAL_USE_TARGET)
#include <VX/vx_ext_target.h>
#endif

/*! \file vx_helper.c
 * \brief The OpenVX Helper Implementation.
 * \author Erik Rainey <erik.rainey@gmail.com>
 * \example vx_helper.c
 */


// no clue if this belongs here, but i don't know where better to put it. needed by c_scale.c and vx_scale.c
uint32_t math_gcd(uint32_t a, uint32_t b)
{
    uint32_t gcd = (a < b ? a : b);
    while (gcd > 0) {
        if ((a % gcd) == 0 && (b % gcd) == 0)
            return gcd;
        gcd -= 1;
    }
    return 0;
}


static vx_log_t helper_log;

static void vxInitLog(vx_log_t *log)
{
    log->first = -1;
    log->last = 0;
    log->count = VX_MAX_LOG_NUM_ENTRIES;
}

vx_status vxGetLogEntry(vx_reference r, char message[VX_MAX_LOG_MESSAGE_LEN])
{
    vx_status status = VX_SUCCESS;
    vx_int32  cur = 0;
    vx_bool isContext = (vxGetContext(r) == 0 ? vx_true_e : vx_false_e);

    // if there's nothing in the helper_log return success
    if (helper_log.first == -1)
    {
        return VX_SUCCESS;
    }

    // first, match the reference to the parameter r
    // if active mark not active and copy and return.
    // if not active move on.

    for (cur = helper_log.first; cur != helper_log.last; cur = (cur + 1)%helper_log.count)
    {
        // if reference match or context was given
        if (((isContext == vx_true_e) || (r == helper_log.entries[cur].reference)) &&
            (helper_log.entries[cur].active == vx_true_e))
        {
            status = helper_log.entries[cur].status;
            strncpy(message, helper_log.entries[cur].message, VX_MAX_LOG_MESSAGE_LEN);
            helper_log.entries[cur].active = vx_false_e;
            if (cur == helper_log.first)
            {
                //printf("Aged out first entry!\n");
                helper_log.first = (helper_log.first + 1)%helper_log.count;
                if (helper_log.first == helper_log.last)
                {
                    helper_log.first = -1;
                    //printf("Log is now empty!\n");
                }
            }
            break;
        }
    }
    return status;
}

static void VX_CALLBACK vxHelperLogCallback(vx_context context,
                                vx_reference ref,
                                vx_status status,
                                vx_char string[])
{
    helper_log.entries[helper_log.last].reference = ref;
    helper_log.entries[helper_log.last].status = status;
    helper_log.entries[helper_log.last].active = vx_true_e;
    strncpy(helper_log.entries[helper_log.last].message, string, VX_MAX_LOG_MESSAGE_LEN);

    if (helper_log.first == -1)
        helper_log.first = helper_log.last;
    else if (helper_log.first == helper_log.last)
        helper_log.first = (helper_log.first + 1)%helper_log.count;
    helper_log.last = (helper_log.last + 1)%helper_log.count;
}

void vxRegisterHelperAsLogReader(vx_context context)
{
    vxInitLog(&helper_log);
    vxRegisterLogCallback(context, &vxHelperLogCallback, vx_false_e);
}

vx_bool vxFindOverlapRectangle(vx_rectangle_t *rect_a, vx_rectangle_t *rect_b, vx_rectangle_t *rect_res)
{
    vx_bool res = vx_false_e;
    if ((rect_a) && (rect_b) && (rect_res))
    {
        enum {sx = 0, sy = 1, ex = 2, ey = 3};
        vx_uint32 a[4] = {rect_a->start_x, rect_a->start_y, rect_a->end_x, rect_a->end_y};
        vx_uint32 b[4] = {rect_b->start_x, rect_b->start_y, rect_b->end_x, rect_b->end_y};
        vx_uint32 c[4] = {0};
        c[sx] = (a[sx] > b[sx] ? a[sx] : b[sx]);
        c[sy] = (a[sy] > b[sy] ? a[sy] : b[sy]);
        c[ex] = (a[ex] < b[ex] ? a[ex] : b[ex]);
        c[ey] = (a[ey] < b[ey] ? a[ey] : b[ey]);
        if (c[sx] < c[ex] && c[sy] < c[ey])
        {
            rect_res->start_x = c[sx];
            rect_res->start_y = c[sy];
            rect_res->end_x = c[ex];
            rect_res->end_y = c[ey];
            res = vx_true_e;
        }
    }
    return res;
}

#if defined(EXPERIMENTAL_USE_TARGET)
vx_bool vxFindAllTargetsOfKernelsByName(vx_context context, vx_char kname[VX_MAX_KERNEL_NAME], vx_char *targets[VX_MAX_TARGET_NAME])
{
    vx_bool ret = vx_false_e;
    vx_uint32 k = 0u, t = 0u, num_targets = 0u;
    vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, &num_targets, sizeof(num_targets));
    for (t = 0u; t < num_targets; t++)
    {
        vx_target target = vxGetTargetByIndex(context, t);
        vx_uint32 num_kernels = 0;
        /* clear out the name */
        memset(targets[t], 0, VX_MAX_TARGET_NAME);
        if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NUMKERNELS, &num_kernels, sizeof(num_kernels)) == VX_SUCCESS)
        {
            vx_size size = num_kernels * sizeof(vx_kernel_info_t);
            vx_kernel_info_t *kernels = malloc(size);
            if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_KERNELTABLE, kernels, size) == VX_SUCCESS)
            {
                for (k = 0u; k < num_kernels; k++)
                {
                    /* target kernel names are allowed to have variant strings */
                    vx_char string[VX_MAX_KERNEL_NAME], *ker;
                    strncpy(string, kernels[k].name, VX_MAX_KERNEL_NAME);
                    ker = strtok(string, ":");
                    /* if it has any variants of this kernel it is ok */
                    if (strncmp(kname, ker, VX_MAX_KERNEL_NAME) == 0)
                    {
                        /* fill in the name if it has this kernel */
                        if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NAME, targets[t], VX_MAX_TARGET_NAME) == VX_SUCCESS)
                        {
                            ret = vx_true_e;
                        }
                        break;
                    }
                }
            }
            free(kernels);
        }
    }
    return ret;
}

vx_bool vxCreateListOfAllTargets(vx_context context, vx_char **targets[], vx_uint32 *num_targets)
{
    vx_bool ret = vx_false_e;
    vx_uint32 t = 0u;
    if (vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, num_targets, sizeof(*num_targets)) == VX_SUCCESS)
    {
        *targets = (vx_char **)calloc(*num_targets, sizeof(vx_char *));
        if (*targets)
        {
            for (t = 0u; t < *num_targets; t++)
            {
                vx_target target = vxGetTargetByIndex(context, t);
                (*targets)[t] = (vx_char *)calloc(VX_MAX_TARGET_NAME, sizeof(vx_char));
                if ((*targets)[t])
                {
                    if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NAME, (*targets)[t], VX_MAX_TARGET_NAME) == VX_SUCCESS)
                    {
                        ret = vx_true_e;
                    }
                    else
                    {
                        ret = vx_false_e;
                        break;
                    }
                }
            }
            if (ret == vx_false_e)
            {
                do {
                    if (t > 0)
                        free((*targets)[--t]);
                } while (t != 0);
            }
        }
    }
    return ret;
}

void vxDestroyListOfAllTargets(vx_char **targets[], vx_uint32 num_targets)
{
    vx_uint32 t = 0u;
    for (t = 0u; t < num_targets; t++)
    {
        free((*targets)[t]);
    }
    free((*targets));
    *targets = NULL;
}
#endif

vx_node vxCreateNodeByStructure(vx_graph graph,
                                vx_enum kernelenum,
                                vx_reference params[],
                                vx_uint32 num)
{
    vx_status status = VX_SUCCESS;
    vx_node node = 0;
    vx_context context = vxGetContext((vx_reference)graph);
    vx_kernel kernel = vxGetKernelByEnum(context, kernelenum);
    if (kernel)
    {
        node = vxCreateGenericNode(graph, kernel);
        if (node)
        {
            vx_uint32 p = 0;
            for (p = 0; p < num; p++)
            {
                status = vxSetParameterByIndex(node,
                                               p,
                                               params[p]);
                if (status != VX_SUCCESS)
                {
                    vxAddLogEntry((vx_reference)graph, status, "Kernel %d Parameter %u is invalid.\n", kernelenum, p);
                    vxReleaseNode(&node);
                    node = 0;
                    break;
                }
            }
        }
        else
        {
            vxAddLogEntry((vx_reference)graph, VX_ERROR_INVALID_PARAMETERS, "Failed to create node with kernel enum %d\n", kernelenum);
            status = VX_ERROR_NO_MEMORY;
        }
        vxReleaseKernel(&kernel);
    }
    else
    {
        vxAddLogEntry((vx_reference)graph, VX_ERROR_INVALID_PARAMETERS, "failed to retrieve kernel enum %d\n", kernelenum);
        status = VX_ERROR_NOT_SUPPORTED;
    }
    return node;
}


void vxClearLog(vx_reference ref)
{
    char message[VX_MAX_LOG_MESSAGE_LEN];
    vx_status status = VX_SUCCESS;
    do {
        status = vxGetLogEntry(ref, message);
    } while (status != VX_SUCCESS);
}

vx_status vxLinkParametersByIndex(vx_node node_a, vx_uint32 index_a, vx_node node_b, vx_uint32 index_b) {
    vx_parameter param_a = vxGetParameterByIndex(node_a, index_a);
    vx_parameter param_b = vxGetParameterByIndex(node_b, index_b);
    vx_status status = vxLinkParametersByReference(param_a, param_b);
    vxReleaseParameter(&param_a);
    vxReleaseParameter(&param_b);
    return status;
}

vx_status vxLinkParametersByReference(vx_parameter a, vx_parameter b) {
    vx_status status = VX_SUCCESS;
    vx_enum dirs[2] = {0,0};
    vx_enum types[2] = {0,0};
    vx_reference ref = 0;

    status = vxQueryParameter(a, VX_PARAMETER_ATTRIBUTE_DIRECTION, &dirs[0], sizeof(dirs[0]));
    if (status != VX_SUCCESS)
        return status;

    status = vxQueryParameter(b, VX_PARAMETER_ATTRIBUTE_DIRECTION, &dirs[1], sizeof(dirs[1]));
    if (status != VX_SUCCESS)
        return status;

    status = vxQueryParameter(a, VX_PARAMETER_ATTRIBUTE_TYPE, &types[0], sizeof(types[0]));
    if (status != VX_SUCCESS)
        return status;

    status = vxQueryParameter(b, VX_PARAMETER_ATTRIBUTE_TYPE, &types[1], sizeof(types[1]));
    if (status != VX_SUCCESS)
        return status;

    if (types[0] == types[1])
    {
        if ((dirs[0] == VX_OUTPUT || dirs[0] == VX_BIDIRECTIONAL) && dirs[1] == VX_INPUT)
        {
            status = vxQueryParameter(a, VX_PARAMETER_ATTRIBUTE_REF, &ref, sizeof(ref));
            if (status != VX_SUCCESS)
                return status;
            status = vxSetParameterByReference(b, ref);
        }
        else if ((dirs[1] == VX_OUTPUT || dirs[1] == VX_BIDIRECTIONAL) && dirs[0] == VX_INPUT)
        {
            status = vxQueryParameter(b, VX_PARAMETER_ATTRIBUTE_REF, &ref, sizeof(ref));
            if (status != VX_SUCCESS)
                return status;
            status = vxSetParameterByReference(a, ref);
        }
        else
            status = VX_ERROR_INVALID_LINK;
    }
    return status;
}


vx_status vxSetAffineRotationMatrix(vx_matrix matrix,
                                    vx_float32 angle,
                                    vx_float32 scale,
                                    vx_float32 center_x,
                                    vx_float32 center_y)
{
    vx_status status = VX_FAILURE;
    vx_float32 mat[3][2];
    vx_size columns = 0ul, rows = 0ul;
    vx_enum type = 0;
    vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
    vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
    vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &type, sizeof(type));
    if ((columns == 2) && (rows == 3) && (type == VX_TYPE_FLOAT32))
    {
        status = vxAccessMatrix(matrix, mat);
        if (status == VX_SUCCESS)
        {
            vx_float32 radians = (angle / 360.0f) * (vx_float32)VX_TAU;
            vx_float32 a = scale * (vx_float32)cos(radians);
            vx_float32 b = scale * (vx_float32)sin(radians);
            mat[0][0] = a;
            mat[1][0] = b;
            mat[2][0] = ((1.0f - a) * center_x) - (b * center_y);
            mat[0][1] = -b;
            mat[1][1] = a;
            mat[2][1] = (b * center_x) + ((1.0f - a) * center_y);
            status = vxCommitMatrix(matrix, mat);
        }
    }
    else
    {
        vxAddLogEntry((vx_reference)matrix, status, "Failed to set affine matrix due to type or dimension mismatch!\n");
    }
    return status;
}

vx_status vxAlterRectangle(vx_rectangle_t *rect,
                           vx_int32 dsx,
                           vx_int32 dsy,
                           vx_int32 dex,
                           vx_int32 dey)
{
    if (rect)
    {
        rect->start_x += dsx;
        rect->start_y += dsy;
        rect->end_x += dex;
        rect->end_y += dey;
        return VX_SUCCESS;
    }
    return VX_ERROR_INVALID_REFERENCE;
}

vx_status vxAddParameterToGraphByIndex(vx_graph g, vx_node n, vx_uint32 index)
{
    vx_parameter p = vxGetParameterByIndex(n, index);
    vx_status status = vxAddParameterToGraph(g, p);
    vxReleaseParameter(&p);
    return status;
}

void vxReadRectangle(const void *base,
                     const vx_imagepatch_addressing_t *addr,
                     const vx_border_mode_t *borders,
                     vx_df_image type,
                     vx_uint32 center_x,
                     vx_uint32 center_y,
                     vx_uint32 radius_x,
                     vx_uint32 radius_y,
                     void *destination)
{
#if 0
    /* strides are not modified by scaled planes, they are byte distances from allocators */
    vx_int32 stride_y = addr->stride_y;
    vx_int32 stride_x = addr->stride_x;
    const vx_uint8 *ptr = (const vx_uint8 *)base;
    vx_uint32 center_offset = (center_y * stride_y) + (center_x * stride_x);
    vx_uint32 ky, kx;
    // kx, kx - kernel x and y
    for (ky = 0; ky <= 2 * radius_y; ++ky)
    {
        for (kx = 0; kx <= 2 * radius_x; ++kx)
        {
            vx_uint32 ckx = kx, cky = ky; // kernel x and y, clamped to image bounds
            vx_size dest_index = 0ul;

            if (kx < radius_x && center_x < radius_x - kx)
                ckx = radius_x - center_x;
            else if (kx > radius_x && addr->dim_x - center_x <= kx - radius_x)
                ckx = radius_x + (addr->dim_x - center_x - 1);

            if (ky < radius_y && center_y < radius_y - ky)
                cky = radius_y - center_y;
            else if (ky > radius_y && addr->dim_y - center_y <= ky - radius_y)
                cky = radius_y + (addr->dim_y - center_y - 1);

            dest_index = ky * (2 * radius_x + 1) + kx;

            if (borders->mode == VX_BORDER_MODE_CONSTANT && (kx != ckx || ky != cky))
            {
                switch (type) {
                case VX_DF_IMAGE_U8:
                    ((vx_uint8*)destination)[dest_index] = borders->constant_value; break;
                case VX_DF_IMAGE_U16:
                case VX_DF_IMAGE_S16:
                    ((vx_uint16*)destination)[dest_index] = borders->constant_value; break;
                default:
                    abort(); // add other types as needed
                }
            }
            else
            {
                vx_uint32 offset = center_offset
                        + (stride_y * cky) - (radius_y * stride_y)
                        + (stride_x * ckx) - (radius_x * stride_x);
                switch (type) {
                case VX_DF_IMAGE_U8:
                    ((vx_uint8*)destination)[dest_index] = *(vx_uint8*)(ptr + offset); break;
                case VX_DF_IMAGE_U16:
                case VX_DF_IMAGE_S16:
                    ((vx_uint16*)destination)[dest_index] = *(vx_uint16*)(ptr + offset); break;
                default:
                    abort(); // add other types as needed
                }
            }
        }
    }
#else
    vx_int32 width = (vx_int32)addr->dim_x, height = (vx_int32)addr->dim_y;
    vx_int32 stride_y = addr->stride_y;
    vx_int32 stride_x = addr->stride_x;
    const vx_uint8 *ptr = (const vx_uint8 *)base;
    vx_int32 ky, kx;
    vx_uint32 dest_index = 0;
    // kx, kx - kernel x and y
    if( borders->mode == VX_BORDER_MODE_REPLICATE || borders->mode == VX_BORDER_MODE_UNDEFINED )
    {
        for (ky = -(int32_t)radius_y; ky <= (int32_t)radius_y; ++ky)
        {
            vx_int32 y = (vx_int32)(center_y + ky);
            y = y < 0 ? 0 : y >= height ? height - 1 : y;

            for (kx = -(int32_t)radius_x; kx <= (int32_t)radius_x; ++kx, ++dest_index)
            {
                vx_int32 x = (int32_t)(center_x + kx);
                x = x < 0 ? 0 : x >= width ? width - 1 : x;

                switch(type)
                {
                case VX_DF_IMAGE_U8:
                    ((vx_uint8*)destination)[dest_index] = *(vx_uint8*)(ptr + y*stride_y + x*stride_x);
                    break;
                case VX_DF_IMAGE_S16:
                case VX_DF_IMAGE_U16:
                    ((vx_uint16*)destination)[dest_index] = *(vx_uint16*)(ptr + y*stride_y + x*stride_x);
                    break;
                case VX_DF_IMAGE_S32:
                case VX_DF_IMAGE_U32:
                    ((vx_uint32*)destination)[dest_index] = *(vx_uint32*)(ptr + y*stride_y + x*stride_x);
                    break;
                default:
                    abort();
                }
            }
        }
    }
    else if( borders->mode == VX_BORDER_MODE_CONSTANT )
    {
        vx_uint32 cval = borders->constant_value;
        for (ky = -(int32_t)radius_y; ky <= (int32_t)radius_y; ++ky)
        {
            vx_int32 y = (vx_int32)(center_y + ky);
            int ccase_y = y < 0 || y >= height;

            for (kx = -(int32_t)radius_x; kx <= (int32_t)radius_x; ++kx, ++dest_index)
            {
                vx_int32 x = (int32_t)(center_x + kx);
                int ccase = ccase_y || x < 0 || x >= width;

                switch(type)
                {
                    case VX_DF_IMAGE_U8:
                        if( !ccase )
                            ((vx_uint8*)destination)[dest_index] = *(vx_uint8*)(ptr + y*stride_y + x*stride_x);
                        else
                            ((vx_uint8*)destination)[dest_index] = (vx_uint8)cval;
                        break;
                    case VX_DF_IMAGE_S16:
                    case VX_DF_IMAGE_U16:
                        if( !ccase )
                            ((vx_uint16*)destination)[dest_index] = *(vx_uint16*)(ptr + y*stride_y + x*stride_x);
                        else
                            ((vx_uint16*)destination)[dest_index] = (vx_uint16)cval;
                        break;
                    case VX_DF_IMAGE_S32:
                    case VX_DF_IMAGE_U32:
                        if( !ccase )
                            ((vx_uint32*)destination)[dest_index] = *(vx_uint32*)(ptr + y*stride_y + x*stride_x);
                        else
                            ((vx_uint32*)destination)[dest_index] = (vx_uint32)cval;
                        break;
                    default:
                        abort();
                }
            }
        }
    }
    else
        abort();
#endif
}

#if __STDC_VERSION__ == 199901L // C99

static vx_float32 vxh_matrix_trace_f32(vx_size columns, vx_size rows, vx_float32 matrix[rows][columns]) {
    vx_float32 trace = 0.0f;
    vx_size i = 0ul;
    for (i = 0ul; i < columns && i < rows; i++) {
        trace += matrix[i][i];
    }
    return trace;
}


static vx_int32 vxh_matrix_trace_i32(vx_size columns, vx_size rows, vx_int32 matrix[rows][columns]) {
    vx_int32 trace = 0;
    vx_size i = 0ul;
    for (i = 0ul; i < columns && i < rows; i++) {
        trace += matrix[i][i];
    }
    return trace;
}

vx_status vxMatrixTrace(vx_matrix matrix, vx_scalar trace) {
    vx_size columns = 0u;
    vx_size rows = 0u;
    vx_status status = VX_SUCCESS;
    vx_enum mtype = VX_TYPE_INVALID, stype = VX_TYPE_INVALID;

    status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
    status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
    status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &mtype, sizeof(mtype));
    status |= vxQueryScalar(trace, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));

    if (status != VX_SUCCESS)
        return VX_ERROR_INVALID_REFERENCE;
    if (mtype == VX_TYPE_INVALID || mtype != stype)
        return VX_ERROR_INVALID_TYPE;
    if (columns == 0 || columns != rows)
        return VX_ERROR_INVALID_DIMENSION;

    if (stype == VX_TYPE_INT32) {
        vx_int32 mat[rows][columns];
        vx_int32 t = 0;
        status |= vxAccessScalarValue(trace, NULL);
        status |= vxAccessMatrix(matrix, mat);
        t = vxh_matrix_trace_i32(columns, rows, mat);
        status |= vxCommitMatrix(matrix, NULL);
        status |= vxCommitScalarValue(trace, &t);
    } else if (stype == VX_TYPE_FLOAT32) {
        vx_float32 mat[rows][columns];
        vx_float32 t = 0.0f;
        status |= vxAccessScalarValue(trace, NULL);
        status |= vxAccessMatrix(matrix, mat);
        t = vxh_matrix_trace_f32(columns, rows, mat);
        status |= vxCommitMatrix(matrix, NULL);
        status |= vxCommitScalarValue(trace, &t);
    }
    return status;
}

static vx_float32 vxh_matrix_determinant_f32(vx_size columns, vx_size rows, vx_float32 matrix[rows][columns]) {
    vx_float32 det = 0.0f;
    if (rows == 2 && columns == 2) {
        det = (matrix[0][0] * matrix[1][1]) - (matrix[1][0] * matrix[0][1]);
    } else if (rows == 3 && columns == 3) {
        det = ((matrix[0][0]*matrix[1][1]*matrix[2][2]) +
               (matrix[0][1]*matrix[1][2]*matrix[2][0]) +
               (matrix[0][2]*matrix[1][0]*matrix[2][1]) -
               (matrix[0][2]*matrix[1][1]*matrix[2][0]) -
               (matrix[0][1]*matrix[1][0]*matrix[2][2]) -
               (matrix[0][0]*matrix[1][2]*matrix[2][1]));
    }
    return det;
}

static void vxh_matrix_inverse_f32(vx_uint32 columns, vx_uint32 rows, vx_float32 out[rows][columns], vx_float32 in[rows][columns]) {
    if (rows == 2 && columns == 2) {
        vx_float32 detinv = 1.0f / vxh_matrix_determinant_f32(columns,rows,in);
        out[0][0] = detinv *  in[1][1];
        out[0][1] = detinv * -in[0][1];
        out[1][0] = detinv * -in[1][0];
        out[1][1] = detinv *  in[0][0];
    }
    /*! \bug implement 3x3 */
}

vx_status vxMatrixInverse(vx_matrix input, vx_matrix output) {
    vx_size ci, co;
    vx_size ri, ro;
    vx_enum ti, to;
    vx_status status = VX_SUCCESS;
    status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_COLUMNS, &ci, sizeof(ci));
    status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_ROWS, &ri, sizeof(ri));
    status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_TYPE, &ti, sizeof(ti));
    status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_COLUMNS, &co, sizeof(co));
    status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_ROWS, &ro, sizeof(ro));
    status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_TYPE, &to, sizeof(to));
    if (status != VX_SUCCESS)
        return status;
    if (ci != co || ri != ro || ci != ri)
        return VX_ERROR_INVALID_DIMENSION;
    if (ti != to)
        return VX_ERROR_INVALID_TYPE;
    if (ti == VX_TYPE_FLOAT32) {
        vx_float32 in[ri][ci];
        vx_float32 ou[ro][co];
        vxAccessMatrix(input, in);
        vxAccessMatrix(output, NULL);
        vxh_matrix_inverse_f32(ci, ri, ou, in);
        vxCommitMatrix(output, ou);
        vxCommitMatrix(input, NULL);
    }
    /*! \bug implement integer */
    return status;
}

#endif