/*
 * Copyright (c) 2012-2017 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifdef OPENVX_USE_ENHANCED_VISION

#include "test_engine/test.h"

#include <VX/vx_types.h>
#include <VX/vx_khr_nn.h>
#include <VX/vxu.h>

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <float.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>


#define DEBUG_TEST_TENSOR_ENABLE_PRINTF 0
#define DEBUG_TEST_TENSOR_CONTINUE_AFTER_ERROR 0
#define DEBUG_TEST_TENSOR_BEYOND_FOUR_DIMS 1

#define TEST_TENSOR_NUM_ITERATIONS              10
#define TEST_TENSOR_MIN_DIM_SZ                  1
#define TEST_TENSOR_MAX_DIM_SZ                  20

#define Q78_FIXED_POINT_POSITION 8
#define MAX_TENSOR_DIMS 3

#define MIN(a, b)   ((a) < (b) ? (a) : (b))
#define MAX(a, b)   ((a) < (b) ? (b) : (a))
#define CLAMP(v, lower, upper) MAX((lower), MIN((v), (upper)))

#define MIN_TOLERANCE  (0.95)

enum TestTensorDF
{
    TT_Q78,
    TT_U8
};

static void ownUnpackFormat(
        enum TestTensorDF fmt,
        /*OUT*/ vx_enum * data_type,
        /*OUT*/ vx_uint8 * fixed_point_position,
        /*out*/ vx_size * sizeof_data_type)
{
    switch(fmt)
    {
        case TT_Q78:
            *data_type = VX_TYPE_INT16;
            *fixed_point_position = Q78_FIXED_POINT_POSITION;
            *sizeof_data_type = sizeof(vx_int16);
            break;
        case TT_U8:
            *data_type = VX_TYPE_UINT8;
            *fixed_point_position = 0;
            *sizeof_data_type = sizeof(vx_uint8);
            break;
        default:
            assert(0);
    }
}

static void ownFillRandData(
        enum TestTensorDF fmt,
        uint64_t * rng,
        size_t count,
        /*OUT*/ void * data)
{
    switch(fmt)
    {
        case TT_Q78:
            for(size_t i = 0; i < count; ++i)
                ((vx_int16*)data)[i] = (vx_int16)CT_RNG_NEXT_INT(*rng, INT16_MIN, INT16_MAX+1);
            break;
        case TT_U8:
            for(size_t i = 0; i < count; ++i)
                ((vx_uint8*)data)[i] = (vx_uint8)CT_RNG_NEXT_INT(*rng, 0, UINT8_MAX+1);
            break;
        default:
            assert(0);
    }
}

#define  COLOR_WEIGHT_SIZE_PER_CHANNEL      256

static void getMinMax(const void* src, const vx_size* src_strides, const vx_size* dims, vx_size num_of_dims,
                      vx_int16 *max_value, vx_int16 *min_value)
{
    vx_int16 maxVal = INT16_MIN;
    vx_int16 minVal = INT16_MAX;
    if (num_of_dims == 2)
    {
        for (vx_uint32 y = 0; y < dims[1]; y++)
        {
            for (vx_uint32 x = 0; x < dims[0]; x++)
            {
                vx_uint32 offset = y * src_strides[1] + x * src_strides[0];
                vx_int16 val = *(vx_int16 *)((vx_int8 *)src + offset);
                if (val > maxVal)
                {
                    maxVal = val;
                }
                if (val < minVal)
                {
                    minVal = val;
                }
            }
        }
        *max_value = maxVal;
        *min_value = minVal;
    }
    else if (num_of_dims == 3)
    {
        for (vx_uint32 y = 0; y < dims[2]; y++)
        {
            for (vx_uint32 x = 0; x < dims[1]; x++)
            {
                for (vx_uint32 z = 0; z < dims[0]; z++)
                {
                    vx_uint32 offset = y * src_strides[2] + x * src_strides[1] + z * src_strides[0];
                    vx_int16 val = *(vx_int16 *)((vx_int8 *)src + offset);
                    if (val > maxVal)
                    {
                        maxVal = val;
                    }
                    if (val < minVal)
                    {
                        minVal = val;
                    }
                }
            }
        }
        *max_value = maxVal;
        *min_value = minVal;
    }
}

static void releaseRes(void *pData)
{
    if (NULL != pData)
    {
        ct_free_mem(pData);
    }
    return;
}

static vx_status calcColorWeight(vx_uint8 cn, vx_float64 gauss_color_coeff, vx_float32 **color_weight)
{
    vx_float32 *tmp_weight = (vx_float32 *)ct_alloc_mem(cn * COLOR_WEIGHT_SIZE_PER_CHANNEL * sizeof(vx_float32));
    if (NULL == tmp_weight)
    {
        return VX_ERROR_NO_MEMORY;
    }

    for (vx_int32 i = 0; i < (cn * COLOR_WEIGHT_SIZE_PER_CHANNEL); i++)
    {
        tmp_weight[i] = (vx_float32)exp(i * i * gauss_color_coeff);
    }

    *color_weight = tmp_weight;

    return VX_SUCCESS;
}

static vx_status calcSpaceWeight(vx_int32 diameter, vx_float64 gauss_space_coeff, vx_float32 **space_weight)
{
    vx_int32 radius = diameter / 2;
    vx_float32 *tmp_weight = (vx_float32 *)ct_alloc_mem(diameter * diameter * sizeof(vx_float32));
    if (NULL == tmp_weight)
    {
        return VX_ERROR_NO_MEMORY;
    }

    for (vx_int32 i = -radius; i <= radius; i++)
    {
        vx_int32 j = -radius;
        for (; j <= radius; j++)
        {
            vx_float64 r = sqrt((vx_float64)i * i + (vx_float64)j * j);
            if (r > radius)
            {
                continue;
            }
            tmp_weight[(i + radius) * diameter + (j + radius)] = (vx_float32)exp(r * r * gauss_space_coeff);
        }
    }

    *space_weight = tmp_weight;

    return VX_SUCCESS;
}


static void ownCheckBilateralFilterResult(
        const void * in_ptr, const vx_size * in_dims, const vx_size * in_strides,
        enum TestTensorDF fmt,
        vx_size dim_num,
        int   diameter,
        float sigmaSpace,
        float sigmaColor,
        void * out_ptr, const vx_size * out_dims, const vx_size * out_strides,
        vx_border_t border)
{
    vx_status status = VX_SUCCESS;
    vx_float32 tolerance = 0.0;
    vx_float32 total_num = 0.0;
    vx_float32 equal_num = 0.0;
    vx_int32 y = 0, x = 0;
    vx_int32 low_x, low_y, high_x, high_y;
    vx_int32 radius_y, radius_x;
    vx_float32 scale_index = 0;
    vx_int32 radius = diameter / 2;
    vx_enum border_mode = border.mode;
    vx_int16 out = 0, ref = 0;

    vx_float32 *color_weight = NULL;
    vx_float32 *space_weight = NULL;
    vx_uint8 cn = dim_num == 2 ? 1 : 3;

    vx_float64 gauss_color_coeff = -0.5/(sigmaColor*sigmaColor);
    vx_float64 gauss_space_coeff = -0.5/(sigmaSpace*sigmaSpace);

    if (border.mode == VX_BORDER_UNDEFINED)
    {
        low_x = radius;
        high_x = (in_dims[dim_num - 2] >= radius) ? in_dims[dim_num - 2] - radius : 0;
        low_y = radius;
        high_y = (in_dims[dim_num - 1] >= radius) ? in_dims[dim_num - 1] - radius : 0;
    }
    else
    {
        low_x = 0;
        high_x = in_dims[dim_num - 2];
        low_y = 0;
        high_y = in_dims[dim_num - 1];
    }

    if (fmt == TT_Q78)
    {
        vx_int16 minVal = -1;
        vx_int16 maxVal = 1;
        getMinMax(in_ptr, in_strides, in_dims, dim_num, &maxVal, &minVal);
        if ((vx_float32)(abs(maxVal - minVal)) < FLT_EPSILON)
        {
            if (dim_num == 2)
            {
                for (y = low_y; y < high_y; y++)
                {
                    for (x = low_x; x < high_x; x++)
                    {
                        out = *((vx_int16 *)((vx_uint8 *)out_ptr + y * in_strides[1] + x * in_strides[0]));
                        ref = *((vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[1] + x * in_strides[0]));
                        if (out == ref)
                        {
                            equal_num += 1;
                        }
                        total_num += 1;
                    }
                }
                tolerance = (equal_num / total_num);
                ASSERT(tolerance >= MIN_TOLERANCE);
                return;
            }
            else if (dim_num == 3)
            {
                for (y = low_y; y < high_y; y++)
                {
                    for (x = low_x; x < high_x; x++)
                    {
                        out = *(vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 0 * out_strides[0]);
                        ref = *(vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 0 * in_strides[0]);
                        if (out == ref)
                        {
                            equal_num += 1;
                        }
                        out = *(vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 1 * out_strides[0]);
                        ref = *(vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 1 * in_strides[0]);
                        if (out == ref)
                        {
                            equal_num += 1;
                        }
                        out = *(vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 2 * out_strides[0]);
                        ref = *(vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 2 * in_strides[0]);
                        if (out == ref)
                        {
                            equal_num += 1;
                        }
                        total_num += 3;
                    }
                }
                tolerance = (equal_num / total_num);
                ASSERT(tolerance >= MIN_TOLERANCE);
                return;
            }

            ASSERT(tolerance >= MIN_TOLERANCE);
            return;
        }

        //calculation color weight
        vx_int32 kExpNumBinsPerChannel = 1 << 12;
        vx_float32 lastExpVal = 1.f;
        vx_float32 len;
        vx_int32 kExpNumBins;
        len = (vx_float32)(maxVal - minVal) * cn;
        kExpNumBins = kExpNumBinsPerChannel * cn;
        color_weight = (vx_float32 *)ct_alloc_mem((kExpNumBins + 2) * sizeof(vx_float32));
        if (NULL == color_weight)
        {
            ASSERT(tolerance >= MIN_TOLERANCE);
            return;
        }
        scale_index = kExpNumBins / len;
        for (vx_uint32 i = 0; i < (kExpNumBins + 2); i++)
        {
            if (lastExpVal > 0.f)
            {
                vx_float64 val = i / scale_index;
                color_weight[i] = (vx_float32)exp(val * val * gauss_color_coeff);
                lastExpVal = color_weight[i];
            }
            else
            {
                color_weight[i] = 0.f;
            }
        }
    }
    else if (fmt == TT_U8)
    {
        (void)calcColorWeight(cn, gauss_color_coeff, &color_weight);
    }
    status = calcSpaceWeight(diameter, gauss_space_coeff, &space_weight);
    if (status != VX_SUCCESS)
    {
        releaseRes(color_weight);
        releaseRes(space_weight);
    }

    if (dim_num == 2)
    {
        for (y = low_y; y < high_y; y++)
        {
            for (x = low_x; x < high_x; x++)
            {
                vx_int16 value = 0;
                if (fmt == TT_U8)
                {
                    out = *((vx_uint8 *)out_ptr + y * out_strides[1] + x * out_strides[0]);
                    value = *((vx_uint8 *)in_ptr + y * in_strides[1] + x * in_strides[0]);
                }
                else if (fmt == TT_Q78)
                {
                    out = *((vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[1] + x * out_strides[0]));
                    value = *((vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[1] + x * in_strides[0]));
                }

                vx_float32 sum = 0, wsum = 0;
                //kernel filter
                for (radius_y = -radius; radius_y <= radius; radius_y++)
                {
                    for (radius_x = -radius; radius_x <= radius; radius_x++)
                    {
                        vx_float64 r = sqrt((vx_float64)radius_y * radius_y + (vx_float64)radius_x * radius_x);
                        if (r > radius)
                        {
                            continue;
                        }
                        vx_int32 neighbor_x = x + radius_x;
                        vx_int32 neighbor_y = y + radius_y;
                        vx_int16 neighborVal = 0;
                        if (border_mode == VX_BORDER_REPLICATE)
                        {
                            vx_int32 tmpx = neighbor_x < 0 ? 0 : (neighbor_x >((vx_int32)in_dims[0] - 1) ? ((vx_int32)in_dims[0] - 1) : neighbor_x);
                            vx_int32 tmpy = neighbor_y < 0 ? 0 : (neighbor_y >((vx_int32)in_dims[1] - 1) ? ((vx_int32)in_dims[1] - 1) : neighbor_y);
                            if (fmt == TT_U8)
                            {
                                neighborVal = *((vx_uint8 *)in_ptr + tmpy * in_strides[1] + tmpx * in_strides[0]);
                            }
                            else if (fmt == TT_Q78)
                            {
                                neighborVal = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[1] + tmpx * in_strides[0]));
                            }
                        }
                        else if (border_mode == VX_BORDER_CONSTANT)
                        {
                            vx_int32 tmpx = neighbor_x < 0 ? 0 : (neighbor_x >((vx_int32)in_dims[0] - 1) ? ((vx_int32)in_dims[0] - 1) : neighbor_x);
                            vx_int32 tmpy = neighbor_y < 0 ? 0 : (neighbor_y >((vx_int32)in_dims[1] - 1) ? ((vx_int32)in_dims[1] - 1) : neighbor_y);
                            if (neighbor_x < 0 || neighbor_y < 0)
                            {
                                if (fmt == TT_U8)
                                {
                                    neighborVal = border.constant_value.U8;
                                }
                                else if (fmt == TT_Q78)
                                {
                                    neighborVal = border.constant_value.S16;
                                }
                            }
                            else
                            {
                                if (fmt == TT_U8)
                                {
                                    neighborVal = *((vx_uint8 *)in_ptr + tmpy * in_strides[1] + tmpx * in_strides[0]);
                                }
                                else if (fmt == TT_Q78)
                                {
                                    neighborVal = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[1] + tmpx * in_strides[0]));
                                }
                            }
                        }

                        vx_float32 w = 0;
                        if (fmt == TT_U8)
                        {
                            w = space_weight[(radius_y + radius) * diameter + (radius_x + radius)] *
                                       color_weight[abs(neighborVal - value)];
                        }
                        else if (fmt == TT_Q78)
                        {
                            vx_float32 alpha = abs(neighborVal - value) * scale_index;
                            vx_int32 idx = (vx_int32)floorf(alpha);
                            alpha -= idx;
                            w = space_weight[(radius_y + radius) * diameter + (radius_x + radius)] *
                                (color_weight[idx] + alpha * (color_weight[idx + 1] - color_weight[idx]));
                        }
                        sum += neighborVal * w;
                        wsum += w;
                    }
                }

                if (fmt == TT_U8)
                {
                    ref = (vx_uint8)roundf(sum / wsum);
                }
                else if (fmt == TT_Q78)
                {
                    ref = (vx_int16)roundf(sum / wsum);
                }

                total_num += 1;

                if (ref == out)
                {
                    equal_num += 1;
                }
            }
        }
    }
    else if (dim_num == 3)
    {
        for (y = low_y; y < high_y; y++)
        {
            for (x = low_x; x < high_x; x++)
            {
                vx_int16 b0 = 0, g0 = 0, r0 = 0;
                vx_int16 outb = 0, outg = 0, outr = 0;
                if (fmt == TT_U8)
                {
                    outb = *((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 0 * out_strides[0]);
                    outg = *((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 1 * out_strides[0]);
                    outr = *((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 2 * out_strides[0]);
                    b0 = *((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 0 * in_strides[0]);
                    g0 = *((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 1 * in_strides[0]);
                    r0 = *((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 2 * in_strides[0]);
                }
                else if (fmt == TT_Q78)
                {
                    outb = *((vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 0 * out_strides[0]));
                    outg = *((vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 1 * out_strides[0]));
                    outr = *((vx_int16 *)((vx_uint8 *)out_ptr + y * out_strides[2] + x * out_strides[1] + 2 * out_strides[0]));
                    b0 = *((vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 0 * in_strides[0]));
                    g0 = *((vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 1 * in_strides[0]));
                    r0 = *((vx_int16 *)((vx_uint8 *)in_ptr + y * in_strides[2] + x * in_strides[1] + 2 * in_strides[0]));
                }
                vx_float32 sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;
                //kernel filter
                for (radius_y = -radius; radius_y <= radius; radius_y++)
                {
                    for (radius_x = -radius; radius_x <= radius; radius_x++)
                    {
                        vx_float64 dist = sqrt((vx_float64)radius_y * radius_y + (vx_float64)radius_x * radius_x);
                        if (dist > radius)
                        {
                            continue;
                        }
                        vx_int32 neighbor_x = x + radius_x;
                        vx_int32 neighbor_y = y + radius_y;
                        vx_int16 b = 0, g = 0, r = 0;
                        if (border_mode == VX_BORDER_REPLICATE)
                        {
                            vx_int32 tmpx = neighbor_x < 0 ? 0 : (neighbor_x >((vx_int32)in_dims[1] - 1) ? ((vx_int32)in_dims[1] - 1) : neighbor_x);
                            vx_int32 tmpy = neighbor_y < 0 ? 0 : (neighbor_y >((vx_int32)in_dims[2] - 1) ? ((vx_int32)in_dims[2] - 1) : neighbor_y);
                            if (fmt == TT_U8)
                            {
                                b = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 0 * in_strides[0]);
                                g = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 1 * in_strides[0]);
                                r = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 2 * in_strides[0]);
                            }
                            else if (fmt == TT_Q78)
                            {
                                b = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 0 * in_strides[0]));
                                g = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 1 * in_strides[0]));
                                r = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 2 * in_strides[0]));
                            }
                        }
                        else if (border_mode == VX_BORDER_CONSTANT)
                        {
                            vx_int32 tmpx = neighbor_x < 0 ? 0 : (neighbor_x >((vx_int32)in_dims[1] - 1) ? ((vx_int32)in_dims[1] - 1) : neighbor_x);
                            vx_int32 tmpy = neighbor_y < 0 ? 0 : (neighbor_y >((vx_int32)in_dims[2] - 1) ? ((vx_int32)in_dims[2] - 1) : neighbor_y);
                            if (neighbor_x < 0 || neighbor_y < 0)
                            {
                                if (fmt == TT_U8)
                                {
                                    b = g = r = border.constant_value.U8;
                                }
                                else if (fmt == TT_Q78)
                                {
                                    b = g = r  = border.constant_value.S16;
                                }
                            }
                            else
                            {
                                if (fmt == TT_U8)
                                {
                                    b = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 0 * in_strides[0]);
                                    g = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 1 * in_strides[0]);
                                    r = *((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 2 * in_strides[0]);
                                }
                                else if (fmt == TT_Q78)
                                {
                                    b = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 0 * in_strides[0]));
                                    g = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 1 * in_strides[0]));
                                    r = *((vx_int16 *)((vx_uint8 *)in_ptr + tmpy * in_strides[2] + tmpx * in_strides[1] + 2 * in_strides[0]));
                                }
                            }
                        }

                        vx_float32 w = 0;
                        if (fmt == TT_U8)
                        {
                            w = space_weight[(radius_y + radius) * diameter + (radius_x + radius)] *
                                       color_weight[abs(b - b0) + abs(g - g0) + abs(r - r0)];
                        }
                        else if (fmt == TT_Q78)
                        {
                            vx_float32 alpha = (abs(b- b0) + abs(g - g0) + abs(r - r0)) * scale_index;
                            vx_int32 idx = (vx_int32)floorf(alpha);
                            alpha -= idx;
                            w = space_weight[(radius_y + radius) * diameter + (radius_x + radius)] *
                                (color_weight[idx] + alpha * (color_weight[idx + 1] - color_weight[idx]));
                        }
                        sum_b += b * w;
                        sum_g += g * w;
                        sum_r += r * w;
                        wsum += w;
                    }
                }

                vx_int16 refb = 0, refg = 0, refr = 0;
                if (fmt == TT_U8)
                {
                    refb = (vx_uint8)roundf(sum_b / wsum);
                    refg = (vx_uint8)roundf(sum_g / wsum);
                    refr = (vx_uint8)roundf(sum_r / wsum);
                }
                else if (fmt == TT_Q78)
                {
                    refb = (vx_int16)roundf(sum_b / wsum);
                    refg = (vx_int16)roundf(sum_g / wsum);
                    refr = (vx_int16)roundf(sum_r / wsum);
                }

                total_num += 3;

                if (refb == outb)
                {
                    equal_num += 1;
                }
                if (refg == outg)
                {
                    equal_num += 1;
                }
                if (refr == outr)
                {
                    equal_num += 1;
                }
            }
        }
    }

    tolerance = (equal_num / total_num);

    ASSERT(tolerance >= MIN_TOLERANCE);

    releaseRes(color_weight);
    releaseRes(space_weight);
}

/****************************************************************************
 *                                                                          *
 *                          Test vxBilateralFilterNode                      *
 *                                                                          *
 ***************************************************************************/

TESTCASE(BilateralFilter, CT_VXContext, ct_setup_vx_context, 0)

static void* bilateral_generate_random(int width, int height, int cn, enum TestTensorDF tensor_fmt)
{
    vx_enum data_type = VX_TYPE_UINT8;
    vx_uint8 fixed_point_position = 0;
    vx_size sizeof_data_type = sizeof(vx_uint8);
    size_t count = 0;
    uint64_t rng;
    {
        uint64_t * seed = &CT()->seed_;
        //ASSERT(!!seed);
        CT_RNG_INIT(rng, *seed);
    }

    ownUnpackFormat(tensor_fmt, &data_type, &fixed_point_position, &sizeof_data_type);

    count = width * height * cn;
    void *data = ct_alloc_mem(count * sizeof_data_type);
    if (data != NULL)
    {
        ownFillRandData(tensor_fmt, &rng, count, data);
    }

    return data;
}

typedef struct {
    const char* testName;
    void* (*generator)(int width, int height, int cn, enum TestTensorDF tensor_fmt);
    const char* fileName;
    vx_border_t border;
    int width, height;
    int cn;
    int diameter;
    float sigmaSpace;
    float sigmaColor;
    enum TestTensorDF tensor_fmt;
} bilateral_arg;

#define BILATERAL_FILTER_BORDERS(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/VX_BORDER_REPLICATE", __VA_ARGS__, { VX_BORDER_REPLICATE, {{ 0 }} })), \
    CT_EXPAND(nextmacro(testArgName "/VX_BORDER_CONSTANT=0", __VA_ARGS__, { VX_BORDER_CONSTANT, {{ 0 }} })), \
    CT_EXPAND(nextmacro(testArgName "/VX_BORDER_CONSTANT=1", __VA_ARGS__, { VX_BORDER_CONSTANT, {{ 1 }} })), \
    CT_EXPAND(nextmacro(testArgName "/VX_BORDER_CONSTANT=127", __VA_ARGS__, { VX_BORDER_CONSTANT, {{ 127 }} })), \
    CT_EXPAND(nextmacro(testArgName "/VX_BORDER_CONSTANT=255", __VA_ARGS__, { VX_BORDER_CONSTANT, {{ 255 }} }))

#define BILATERAL_CHANNEL(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/channel=1", __VA_ARGS__, 1)), \
    CT_EXPAND(nextmacro(testArgName "/channel=3", __VA_ARGS__, 3))

#define BILATERAL_DIAMETER(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/diameter=5", __VA_ARGS__, 5)), \
    CT_EXPAND(nextmacro(testArgName "/diameter=7", __VA_ARGS__, 7)), \
    CT_EXPAND(nextmacro(testArgName "/diameter=9", __VA_ARGS__, 9)) \

#define BILATERAL_SPACE_WEIGHT(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sigmaSpace=10", __VA_ARGS__, 10))

#define BILATERAL_COLOR_WEIGHT(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sigmaColor=5", __VA_ARGS__, 5))

#define BILATERAL_FORMAT(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/TT_U8", __VA_ARGS__, TT_U8)), \
    CT_EXPAND(nextmacro(testArgName "/TT_Q78", __VA_ARGS__, TT_Q78))

#define BILATERAL_PARAMETERS \
    CT_GENERATE_PARAMETERS("randam", BILATERAL_FILTER_BORDERS, ADD_SIZE_SMALL_SET, BILATERAL_CHANNEL, BILATERAL_DIAMETER, BILATERAL_SPACE_WEIGHT, BILATERAL_COLOR_WEIGHT, BILATERAL_FORMAT, ARG, bilateral_generate_random, NULL)

TEST_WITH_ARG(BilateralFilter, testGraphProcessing, bilateral_arg,
        BILATERAL_PARAMETERS
)
{
    vx_context context = context_->vx_context_;
    const enum TestTensorDF src_fmt = arg_->tensor_fmt;
    const enum TestTensorDF dst_fmt = arg_->tensor_fmt;
    assert(src_fmt == TT_Q78 || src_fmt == TT_U8);
    assert(dst_fmt == TT_Q78 || dst_fmt == TT_U8);
    const vx_border_t border = arg_->border;
    const int diameter = arg_->diameter;
    const float sigmaSpace = arg_->sigmaSpace;
    const float sigmaColor = arg_->sigmaColor;
    const int cn = arg_->cn;
    const int width = arg_->width;
    const int height = arg_->height;
    vx_size num_of_dims = 2;

    vx_enum src_data_type = 0;
    vx_enum dst_data_type = 0;
    vx_uint8 src_fixed_point_position = 0;
    vx_uint8 dst_fixed_point_position= 0;
    vx_size src_sizeof_data_type = 1;
    vx_size dst_sizeof_data_type = 1;
    ownUnpackFormat(src_fmt, &src_data_type, &src_fixed_point_position, &src_sizeof_data_type);
    ownUnpackFormat(dst_fmt, &dst_data_type, &dst_fixed_point_position, &dst_sizeof_data_type);

    if (cn == 3)
    {
        num_of_dims = 3;
    }

    size_t * const tensor_dims = ct_alloc_mem(sizeof(*tensor_dims) * num_of_dims);
    size_t * const src_tensor_strides = ct_alloc_mem(sizeof(*src_tensor_strides) * num_of_dims);
    size_t * const dst_tensor_strides = ct_alloc_mem(sizeof(*dst_tensor_strides) * num_of_dims);
    ASSERT(tensor_dims && src_tensor_strides && dst_tensor_strides);

    if (num_of_dims == 3)
    {
        tensor_dims[0] = 3;
        tensor_dims[1] = width;
        tensor_dims[2] = height;

        src_tensor_strides[0] = src_sizeof_data_type;
        src_tensor_strides[1] = tensor_dims[0] * src_tensor_strides[0];
        src_tensor_strides[2] = tensor_dims[1] * src_tensor_strides[1];

        dst_tensor_strides[0] = src_tensor_strides[0];
        dst_tensor_strides[1] = src_tensor_strides[1];
        dst_tensor_strides[2] = src_tensor_strides[2];
    }
    else
    {
        tensor_dims[0] = width;
        tensor_dims[1] = height;

        src_tensor_strides[0] = src_sizeof_data_type;
        src_tensor_strides[1] = tensor_dims[0] * src_tensor_strides[0];

        dst_tensor_strides[0] = src_tensor_strides[0];
        dst_tensor_strides[1] = src_tensor_strides[1];
    }

    const size_t dst_tensor_bytes = tensor_dims[num_of_dims-1] * dst_tensor_strides[num_of_dims-1];

    vx_tensor src_tensor = vxCreateTensor(context, num_of_dims, tensor_dims, src_data_type, src_fixed_point_position);
    vx_tensor dst_tensor = vxCreateTensor(context, num_of_dims, tensor_dims, dst_data_type, dst_fixed_point_position);

    void * const dst_data = ct_alloc_mem(dst_tensor_bytes);
    vx_size *view_start = (vx_size *)ct_alloc_mem(num_of_dims * sizeof(vx_size));
    memset(view_start, 0, num_of_dims * sizeof(vx_size));

    void *src_data = NULL;
    src_data = arg_->generator(arg_->width, arg_->height, arg_->cn, arg_->tensor_fmt);
    VX_CALL(vxCopyTensorPatch(src_tensor, num_of_dims, view_start, tensor_dims, src_tensor_strides, src_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
    vx_graph graph = vxCreateGraph(context);
    ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

    vx_node node = vxBilateralFilterNode(graph, src_tensor, diameter,  sigmaSpace, sigmaColor, dst_tensor);

    ASSERT_VX_OBJECT(node, VX_TYPE_NODE);
    VX_CALL(vxSetNodeAttribute(node, VX_NODE_BORDER, &border, sizeof(border)));
    VX_CALL(vxReleaseNode(&node));
    EXPECT_EQ_PTR(NULL, node);

    VX_CALL(vxVerifyGraph(graph));
    VX_CALL(vxProcessGraph(graph));

    VX_CALL(vxReleaseGraph(&graph));
    EXPECT_EQ_PTR(NULL, graph);

    VX_CALL(vxCopyTensorPatch(dst_tensor, num_of_dims, view_start, tensor_dims, dst_tensor_strides, dst_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));

    ownCheckBilateralFilterResult(
                    src_data, tensor_dims, src_tensor_strides,
                    dst_fmt,
                    num_of_dims,
                    diameter,
                    sigmaSpace,
                    sigmaColor,
                    dst_data, tensor_dims, dst_tensor_strides,
                    border);

    VX_CALL(vxReleaseTensor(&src_tensor));
    VX_CALL(vxReleaseTensor(&dst_tensor));
    EXPECT_EQ_PTR(NULL, src_tensor);
    EXPECT_EQ_PTR(NULL, dst_tensor);

    ct_free_mem(src_data);
    ct_free_mem(dst_data);
    ct_free_mem(view_start);
    ct_free_mem(tensor_dims);
    ct_free_mem(src_tensor_strides);
    ct_free_mem(dst_tensor_strides);
}

TEST_WITH_ARG(BilateralFilter, testImmediateProcessing, bilateral_arg,
        BILATERAL_PARAMETERS
)
{
    vx_context context = context_->vx_context_;
    const enum TestTensorDF src_fmt = arg_->tensor_fmt;
    const enum TestTensorDF dst_fmt = arg_->tensor_fmt;
    assert(src_fmt == TT_Q78 || src_fmt == TT_U8);
    assert(dst_fmt == TT_Q78 || dst_fmt == TT_U8);
    const vx_border_t border = arg_->border;
    const int diameter = arg_->diameter;
    const float sigmaSpace = arg_->sigmaSpace;
    const float sigmaColor = arg_->sigmaColor;
    const int cn = arg_->cn;
    const int width = arg_->width;
    const int height = arg_->height;
    vx_size num_of_dims = 2;

    vx_enum src_data_type = 0;
    vx_enum dst_data_type = 0;
    vx_uint8 src_fixed_point_position = 0;
    vx_uint8 dst_fixed_point_position = 0;
    vx_size src_sizeof_data_type = 1;
    vx_size dst_sizeof_data_type = 1;
    ownUnpackFormat(src_fmt, &src_data_type, &src_fixed_point_position, &src_sizeof_data_type);
    ownUnpackFormat(dst_fmt, &dst_data_type, &dst_fixed_point_position, &dst_sizeof_data_type);

    if (cn == 3)
    {
        num_of_dims = 3;
    }

    size_t * const tensor_dims = ct_alloc_mem(sizeof(*tensor_dims) * num_of_dims);
    size_t * const src_tensor_strides = ct_alloc_mem(sizeof(*src_tensor_strides) * num_of_dims);
    size_t * const dst_tensor_strides = ct_alloc_mem(sizeof(*dst_tensor_strides) * num_of_dims);
    ASSERT(tensor_dims && src_tensor_strides && dst_tensor_strides);

    if (num_of_dims == 3)
    {
        tensor_dims[0] = 3;
        tensor_dims[1] = width;
        tensor_dims[2] = height;

        src_tensor_strides[0] = src_sizeof_data_type;
        src_tensor_strides[1] = tensor_dims[0] * src_tensor_strides[0];
        src_tensor_strides[2] = tensor_dims[1] * src_tensor_strides[1];

        dst_tensor_strides[0] = src_tensor_strides[0];
        dst_tensor_strides[1] = src_tensor_strides[1];
        dst_tensor_strides[2] = src_tensor_strides[2];
    }
    else
    {
        tensor_dims[0] = width;
        tensor_dims[1] = height;

        src_tensor_strides[0] = src_sizeof_data_type;
        src_tensor_strides[1] = tensor_dims[0] * src_tensor_strides[0];

        dst_tensor_strides[0] = src_tensor_strides[0];
        dst_tensor_strides[1] = src_tensor_strides[1];
    }

    const size_t dst_tensor_bytes = tensor_dims[num_of_dims-1] * dst_tensor_strides[num_of_dims-1];

    vx_tensor src_tensor = vxCreateTensor(context, num_of_dims, tensor_dims, src_data_type, src_fixed_point_position);
    vx_tensor dst_tensor = vxCreateTensor(context, num_of_dims, tensor_dims, dst_data_type, dst_fixed_point_position);

    void * const dst_data = ct_alloc_mem(dst_tensor_bytes);
    vx_size *view_start = (vx_size *)ct_alloc_mem(num_of_dims * sizeof(vx_size));
    memset(view_start, 0, num_of_dims * sizeof(vx_size));

    void *src_data = NULL;
    src_data = arg_->generator(arg_->width, arg_->height, arg_->cn, arg_->tensor_fmt);
    VX_CALL(vxCopyTensorPatch(src_tensor, num_of_dims, view_start, tensor_dims, src_tensor_strides, src_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));

    VX_CALL(vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border)));
    VX_CALL(vxuBilateralFilter(context, src_tensor, diameter, sigmaSpace, sigmaColor, dst_tensor));

    VX_CALL(vxCopyTensorPatch(dst_tensor, num_of_dims, view_start, tensor_dims, dst_tensor_strides, dst_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));

    ownCheckBilateralFilterResult(
                    src_data, tensor_dims, src_tensor_strides,
                    dst_fmt,
                    num_of_dims,
                    diameter,
                    sigmaSpace,
                    sigmaColor,
                    dst_data, tensor_dims, dst_tensor_strides,
                    border);

    VX_CALL(vxReleaseTensor(&src_tensor));
    VX_CALL(vxReleaseTensor(&dst_tensor));
    EXPECT_EQ_PTR(NULL, src_tensor);
    EXPECT_EQ_PTR(NULL, dst_tensor);

    ct_free_mem(src_data);
    ct_free_mem(dst_data);
    ct_free_mem(view_start);
    ct_free_mem(tensor_dims);
    ct_free_mem(src_tensor_strides);
    ct_free_mem(dst_tensor_strides);
}


TEST(BilateralFilter, testNodeCreation)
{
    const vx_context context = context_->vx_context_;

    const enum TestTensorDF src_fmt = TT_Q78;
    const enum TestTensorDF dst_fmt = TT_Q78;

    const int diameter = 5;
    const float sigmaSpace = 1;
    const float sigmaValues = 1;

    vx_size max_dims = 0;
    {
        VX_CALL(vxQueryContext(context, VX_CONTEXT_MAX_TENSOR_DIMS, &max_dims, sizeof(max_dims)));
        ASSERT(max_dims > 3);
        if(!DEBUG_TEST_TENSOR_BEYOND_FOUR_DIMS) max_dims = 4; else max_dims = MIN(max_dims, MAX_TENSOR_DIMS);
    }

    uint64_t rng;
    {
        uint64_t * seed = &CT()->seed_;
        ASSERT(!!seed);
        CT_RNG_INIT(rng, *seed);
    }

    vx_enum src_data_type;
    vx_enum dst_data_type;
    vx_uint8 src_fixed_point_position;
    vx_uint8 dst_fixed_point_position;
    vx_size src_sizeof_data_type;
    vx_size dst_sizeof_data_type;
    ownUnpackFormat(src_fmt, &src_data_type, &src_fixed_point_position, &src_sizeof_data_type);
    ownUnpackFormat(dst_fmt, &dst_data_type, &dst_fixed_point_position, &dst_sizeof_data_type);

    size_t * const tensor_dims = ct_alloc_mem(sizeof(*tensor_dims) * max_dims);
    size_t * const src_tensor_strides = ct_alloc_mem(sizeof(*src_tensor_strides) * max_dims);
    size_t * const dst_tensor_strides = ct_alloc_mem(sizeof(*dst_tensor_strides) * max_dims);
    ASSERT(tensor_dims && src_tensor_strides && dst_tensor_strides);

    // The input data a vx_tensor. maximum 3 dimension and minimum 2.
    for (vx_size dims = 2; dims <= max_dims; ++dims)
    for (int iter = 0; iter < TEST_TENSOR_NUM_ITERATIONS; ++iter)
    {
        if (DEBUG_TEST_TENSOR_ENABLE_PRINTF)
        {
            printf("dims #: %zu,\titer #: %d\n", dims, iter);
            fflush(stdout);
        }

        for (vx_size i = 0; i < dims; ++i)
        {
            tensor_dims[i] = (size_t)CT_RNG_NEXT_INT(rng, TEST_TENSOR_MIN_DIM_SZ, TEST_TENSOR_MAX_DIM_SZ+1);

            src_tensor_strides[i] = i ? src_tensor_strides[i-1] * tensor_dims[i-1] : src_sizeof_data_type;
            dst_tensor_strides[i] = i ? dst_tensor_strides[i-1] * tensor_dims[i-1] : dst_sizeof_data_type;
        }

        vx_tensor src_tensor = vxCreateTensor(context, dims, tensor_dims, src_data_type, src_fixed_point_position);
        vx_tensor dst_tensor = vxCreateTensor(context, dims, tensor_dims, dst_data_type, dst_fixed_point_position);
        ASSERT_VX_OBJECT(src_tensor, VX_TYPE_TENSOR);
        ASSERT_VX_OBJECT(dst_tensor, VX_TYPE_TENSOR);

        const size_t src_tensor_bytes = tensor_dims[dims-1] * src_tensor_strides[dims-1];
        const size_t dst_tensor_bytes = tensor_dims[dims-1] * dst_tensor_strides[dims-1];
        const size_t count = src_tensor_bytes / src_sizeof_data_type;

        if (DEBUG_TEST_TENSOR_ENABLE_PRINTF)
        {
            printf("\tconfig: {\n");
            printf("\t          tensor_dims: { "); for (size_t i = 0; i < dims; ++i) { printf("%zu, ", tensor_dims[i]); } printf(" }, \n");
            printf("\t        }\n");
        }

        void * const src_data = ct_alloc_mem(src_tensor_bytes);
        void * const dst_data = ct_alloc_mem(dst_tensor_bytes);
        ASSERT(src_data && dst_data);

        {
            ownFillRandData(src_fmt, &rng, count, src_data);

            vx_size view_start[MAX_TENSOR_DIMS] = { 0 };
            VX_CALL(vxCopyTensorPatch(src_tensor, dims, view_start, tensor_dims, src_tensor_strides, src_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
        }

        {
            vx_graph graph = vxCreateGraph(context);
            ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

            vx_node node = vxBilateralFilterNode(graph, src_tensor, diameter,  sigmaSpace, sigmaValues, dst_tensor);

            ASSERT_VX_OBJECT(node, VX_TYPE_NODE);
            VX_CALL(vxReleaseNode(&node));
            EXPECT_EQ_PTR(NULL, node);

            VX_CALL(vxVerifyGraph(graph));

            VX_CALL(vxReleaseGraph(&graph));
            EXPECT_EQ_PTR(NULL, graph);
        }

        VX_CALL(vxReleaseTensor(&src_tensor));
        VX_CALL(vxReleaseTensor(&dst_tensor));
        EXPECT_EQ_PTR(NULL, src_tensor);
        EXPECT_EQ_PTR(NULL, dst_tensor);

        ct_free_mem(src_data);
        ct_free_mem(dst_data);
    }

    ct_free_mem(tensor_dims);
    ct_free_mem(src_tensor_strides);
    ct_free_mem(dst_tensor_strides);
}

TESTCASE_TESTS(BilateralFilter,
    testNodeCreation,
    testGraphProcessing,
    testImmediateProcessing
);

#endif //OPENVX_USE_ENHANCED_VISION