/*

 * 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.
 */

#include <math.h>
#include <string.h>
#include <VX/vx.h>
#include <VX/vxu.h>

#include "test_engine/test.h"
#include "shared_functions.h"

#define VX_GAUSSIAN_PYRAMID_TOLERANCE 1

TESTCASE(LaplacianPyramid, CT_VXContext, ct_setup_vx_context, 0)


TEST(LaplacianPyramid, testNodeCreation)
{
    vx_context context = context_->vx_context_;
    vx_image   input = 0;
    vx_pyramid laplacian = 0;
    vx_image   output = 0;
    vx_graph   graph = 0;
    vx_node    node = 0;
    const vx_size levels = 4;
    const vx_float32 scale = VX_SCALE_PYRAMID_HALF;
    const vx_uint32 width = 640;
    const vx_uint32 height = 480;
    const vx_df_image format = VX_DF_IMAGE_S16;
    vx_uint32 w = width;
    vx_uint32 h = height;
    vx_size L = levels - 1;

    ASSERT_VX_OBJECT(input = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(laplacian = vxCreatePyramid(context, levels, scale, width, height, format), VX_TYPE_PYRAMID);

    while (L--)
    {
        w = (vx_uint32)(w * scale);
        h = (vx_uint32)(h * scale);
    }

    ASSERT_VX_OBJECT(output = vxCreateImage(context, w * scale, h * scale, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);

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

    ASSERT_VX_OBJECT(node = vxLaplacianPyramidNode(graph, input, laplacian, output), VX_TYPE_NODE);

    VX_CALL(vxVerifyGraph(graph));

    VX_CALL(vxReleaseImage(&input));
    VX_CALL(vxReleasePyramid(&laplacian));
    VX_CALL(vxReleaseImage(&output));
    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseGraph(&graph));

    ASSERT(input == 0);
    ASSERT(laplacian == 0);
    ASSERT(output == 0);
    ASSERT(node == 0);
    ASSERT(graph == 0);
}

#define LEVELS_COUNT_MAX    7

static CT_Image own_generate_random(const char* fileName, int width, int height)
{
    CT_Image image;

    ASSERT_NO_FAILURE_(return 0,
        image = ct_allocate_ct_image_random(width, height, VX_DF_IMAGE_U8, &CT()->seed_, 0, 256));

    return image;
}

static CT_Image own_read_image(const char* fileName, int width, int height)
{
    CT_Image image = NULL;
    ASSERT_(return 0, width == 0 && height == 0);
    image = ct_read_image(fileName, 1);
    ASSERT_(return 0, image);
    ASSERT_(return 0, image->format == VX_DF_IMAGE_U8);
    return image;
}

static vx_size own_pyramid_calc_max_levels_count(int width, int height, vx_float32 scale)
{
    vx_size level = 1;

    while ((16 <= width) && (16 <= height) && level < LEVELS_COUNT_MAX)
    {
        level++;
        width = (int)ceil((vx_float64)width * scale);
        height = (int)ceil((vx_float64)height * scale);
    }

    return level;
}

static vx_status ownCopyImage(vx_image input, vx_image output)
{
    vx_status status = VX_SUCCESS; // assume success until an error occurs.
    vx_uint32 p = 0;
    vx_uint32 y = 0, x = 0;
    vx_size planes = 0;

    void* src;
    void* dst;
    vx_imagepatch_addressing_t src_addr;
    vx_imagepatch_addressing_t dst_addr;
    vx_rectangle_t src_rect, dst_rect;
    vx_map_id map_id1;
    vx_map_id map_id2;
    vx_df_image src_format = 0;
    vx_df_image out_format = 0;

    status |= vxQueryImage(input, VX_IMAGE_PLANES, &planes, sizeof(planes));
    vxQueryImage(output, VX_IMAGE_FORMAT, &out_format, sizeof(out_format));
    vxQueryImage(input, VX_IMAGE_FORMAT, &src_format, sizeof(src_format));
    status |= vxGetValidRegionImage(input, &src_rect);
    status |= vxGetValidRegionImage(output, &dst_rect);
    for (p = 0; p < planes && status == VX_SUCCESS; p++)
    {
        status = VX_SUCCESS;
        src = NULL;
        dst = NULL;

        status |= vxMapImagePatch(input, &src_rect, p, &map_id1, &src_addr, &src, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
        status |= vxMapImagePatch(output, &dst_rect, p, &map_id2, &dst_addr, &dst, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0);

        for (y = 0; y < src_addr.dim_y && status == VX_SUCCESS; y += src_addr.step_y)
        {
            for (x = 0; x < src_addr.dim_x && status == VX_SUCCESS; x += src_addr.step_x)
            {
                void* srcp = vxFormatImagePatchAddress2d(src, x, y, &src_addr);
                void* dstp = vxFormatImagePatchAddress2d(dst, x, y, &dst_addr);
                vx_int32 out0 = (src_format == VX_DF_IMAGE_U8) ? (*(vx_uint8 *)srcp) : (*(vx_int16 *)srcp);

                if (out_format == VX_DF_IMAGE_U8)
                {
                    if (out0 > UINT8_MAX)
                        out0 = UINT8_MAX;
                    else if (out0 < 0)
                        out0 = 0;
                    *(vx_uint8 *)dstp = (vx_uint8)out0;
                }
                else
                {
                    if (out0 > INT16_MAX)
                        out0 = INT16_MAX;
                    else if (out0 < INT16_MIN)
                        out0 = INT16_MIN;
                    *(vx_int16 *)dstp = (vx_int16)out0;
                }
            }
        }

        if (status == VX_SUCCESS)
        {
            status |= vxUnmapImagePatch(input, map_id1);
            status |= vxUnmapImagePatch(output, map_id2);
        }
    }

    return status;
}

static vx_bool own_read_pixel_16s(void *base, vx_imagepatch_addressing_t *addr,
    vx_int32 x, vx_int32 y, const vx_border_t *borders, vx_int16 *pixel)
{
    vx_uint32 bx;
    vx_uint32 by;
    vx_int16* bpixel;

    vx_bool out_of_bounds = (vx_bool)(x < 0 || y < 0 || x >= (vx_int32)addr->dim_x || y >= (vx_int32)addr->dim_y);

    if (out_of_bounds)
    {
        if (borders->mode == VX_BORDER_UNDEFINED)
            return vx_false_e;
        if (borders->mode == VX_BORDER_CONSTANT)
        {
            *pixel = (vx_int16)borders->constant_value.S16;
            return vx_true_e;
        }
    }

    // bounded x/y
    bx = x < 0 ? 0 : x >= (vx_int32)addr->dim_x ? addr->dim_x - 1 : (vx_uint32)x;
    by = y < 0 ? 0 : y >= (vx_int32)addr->dim_y ? addr->dim_y - 1 : (vx_uint32)y;

    bpixel = (vx_int16*)vxFormatImagePatchAddress2d(base, bx, by, addr);
    *pixel = *bpixel;

    return vx_true_e;
}

static vx_status ownScaleImageNearestS16(vx_image src_image, vx_image dst_image, const vx_border_t *borders)
{
    vx_status status = VX_SUCCESS;
    vx_int32 x1, y1, x2, y2;
    void* src_base = NULL;
    void* dst_base = NULL;
    vx_rectangle_t src_rect;
    vx_rectangle_t dst_rect;
    vx_imagepatch_addressing_t src_addr;
    vx_imagepatch_addressing_t dst_addr;
    vx_uint32 w1 = 0, h1 = 0, w2 = 0, h2 = 0;
    vx_float32 wr, hr;
    vx_map_id map_id1;
    vx_map_id map_id2;

    vxQueryImage(src_image, VX_IMAGE_WIDTH, &w1, sizeof(w1));
    vxQueryImage(src_image, VX_IMAGE_HEIGHT, &h1, sizeof(h1));

    vxQueryImage(dst_image, VX_IMAGE_WIDTH, &w2, sizeof(w2));
    vxQueryImage(dst_image, VX_IMAGE_HEIGHT, &h2, sizeof(h2));

    src_rect.start_x = src_rect.start_y = 0;
    src_rect.end_x = w1;
    src_rect.end_y = h1;

    dst_rect.start_x = dst_rect.start_y = 0;
    dst_rect.end_x = w2;
    dst_rect.end_y = h2;

    status = VX_SUCCESS;
    status |= vxMapImagePatch(src_image, &src_rect, 0, &map_id1, &src_addr, &src_base, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
    status |= vxMapImagePatch(dst_image, &dst_rect, 0, &map_id2, &dst_addr, &dst_base, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0);

    wr = (vx_float32)w1 / (vx_float32)w2;
    hr = (vx_float32)h1 / (vx_float32)h2;

    for (y2 = 0; y2 < (vx_int32)dst_addr.dim_y; y2 += dst_addr.step_y)
    {
        for (x2 = 0; x2 < (vx_int32)dst_addr.dim_x; x2 += dst_addr.step_x)
        {
            vx_int16 v = 0;
            vx_int16* dst = vxFormatImagePatchAddress2d(dst_base, x2, y2, &dst_addr);
            vx_float32 x_src = ((vx_float32)x2 + 0.5f)*wr - 0.5f;
            vx_float32 y_src = ((vx_float32)y2 + 0.5f)*hr - 0.5f;
            vx_float32 x_min = floorf(x_src);
            vx_float32 y_min = floorf(y_src);
            x1 = (vx_int32)x_min;
            y1 = (vx_int32)y_min;

            if (x_src - x_min >= 0.5f)
                x1++;
            if (y_src - y_min >= 0.5f)
                y1++;

            if (dst && vx_true_e == own_read_pixel_16s(src_base, &src_addr, x1, y1, borders, &v))
                *dst = v;
        }
    }

    status |= vxUnmapImagePatch(src_image, map_id1);
    status |= vxUnmapImagePatch(dst_image, map_id2);

    return VX_SUCCESS;
}

static const vx_uint32 gaussian5x5scale = 256;
static const vx_int16 gaussian5x5[5][5] =
{
    { 1, 4, 6, 4, 1 },
    { 4, 16, 24, 16, 4 },
    { 6, 24, 36, 24, 6 },
    { 4, 16, 24, 16, 4 },
    { 1, 4, 6, 4, 1 }
};

static vx_convolution vxCreateGaussian5x5Convolution(vx_context context)
{
    vx_convolution conv = vxCreateConvolution(context, 5, 5);
    vx_status status = vxCopyConvolutionCoefficients(conv, (vx_int16 *)gaussian5x5, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST);
    if (status != VX_SUCCESS)
    {
        vxReleaseConvolution(&conv);
        return NULL;
    }

    status = vxSetConvolutionAttribute(conv, VX_CONVOLUTION_SCALE, (void *)&gaussian5x5scale, sizeof(vx_uint32));
    if (status != VX_SUCCESS)
    {
        vxReleaseConvolution(&conv);
        return NULL;
    }
    return conv;
}

void readRect(const void *base, const vx_imagepatch_addressing_t *addr, const vx_border_t *borders, vx_df_image type,
    vx_uint32 center_x, vx_uint32 center_y, vx_uint32 radius_x, vx_uint32 radius_y, void *destination)
{
    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_REPLICATE || borders->mode == VX_BORDER_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_CONSTANT)
    {
        vx_pixel_value_t 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.U8;
                    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.U16;
                    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.U32;
                    break;
                default:
                    abort();
                }
            }
        }
    }
    else
        abort();
}

#define CONV_DIM 5
#define CONV_DIM_HALF CONV_DIM / 2

#define INSERT_ZERO_Y(slice, y) for (int i=0; i<CONV_DIM; i++) slice[CONV_DIM*(1-y)+i] = 0;
#define INSERT_VALUES_Y(slice, y) for (int i=0; i<CONV_DIM; i++) slice[CONV_DIM*(high_y-y)+i+CONV_DIM_HALF*CONV_DIM] = slice[CONV_DIM*(high_y-y)+i];
#define INSERT_ZERO_X(slice, x) for (int i=0; i<CONV_DIM; i++) slice[CONV_DIM*i+1-x] = 0;
#define INSERT_VALUES_X(slice, x) for (int i=0; i<CONV_DIM; i++) slice[CONV_DIM*i+(high_x-x)+CONV_DIM_HALF] = slice[CONV_DIM*i+(high_x-x)];

#define C_MAX_CONVOLUTION_DIM 15
vx_status convolve(vx_image src, vx_convolution conv, vx_image dst, vx_border_t *bordermode)
{
    vx_int32 y, x, i;
    void *src_base = NULL;
    void *dst_base = NULL;
    vx_imagepatch_addressing_t src_addr, dst_addr;
    vx_rectangle_t rect;

    vx_size conv_width, conv_height;
    vx_int32 conv_radius_x, conv_radius_y;
    vx_int16 conv_mat[C_MAX_CONVOLUTION_DIM * C_MAX_CONVOLUTION_DIM] = { 0 };
    vx_int32 sum = 0, value = 0;
    vx_uint32 scale = 1;
    vx_df_image src_format = 0;
    vx_df_image dst_format = 0;
    vx_status status = VX_SUCCESS;
    vx_int32 low_x, low_y, high_x, high_y;

    status |= vxQueryImage(src, VX_IMAGE_FORMAT, &src_format, sizeof(src_format));
    status |= vxQueryImage(dst, VX_IMAGE_FORMAT, &dst_format, sizeof(dst_format));
    status |= vxQueryConvolution(conv, VX_CONVOLUTION_COLUMNS, &conv_width, sizeof(conv_width));
    status |= vxQueryConvolution(conv, VX_CONVOLUTION_ROWS, &conv_height, sizeof(conv_height));
    status |= vxQueryConvolution(conv, VX_CONVOLUTION_SCALE, &scale, sizeof(scale));
    conv_radius_x = (vx_int32)conv_width / 2;
    conv_radius_y = (vx_int32)conv_height / 2;
    status |= vxCopyConvolutionCoefficients(conv, conv_mat, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
    status |= vxGetValidRegionImage(src, &rect);
    status |= vxAccessImagePatch(src, &rect, 0, &src_addr, &src_base, VX_READ_ONLY);
    status |= vxAccessImagePatch(dst, &rect, 0, &dst_addr, &dst_base, VX_WRITE_ONLY);

    low_x = 0;
    high_x = src_addr.dim_x;
    low_y = 0;
    high_y = src_addr.dim_y;

    for (y = low_y; y < high_y; ++y)
    {
        for (x = low_x; x < high_x; ++x)
        {
            sum = 0;

            if (src_format == VX_DF_IMAGE_U8)
            {
                vx_uint8 slice[C_MAX_CONVOLUTION_DIM * C_MAX_CONVOLUTION_DIM] = { 0 };

                readRect(src_base, &src_addr, bordermode, src_format, x, y, conv_radius_x, conv_radius_y, slice);

                // purpose of this section is to compensate extra terms caused by replicate border mode (it is the only one allowed)

                if (y < CONV_DIM_HALF)
                {
                    INSERT_ZERO_Y(slice, y)
                }
                else if (y >= high_y - CONV_DIM_HALF)
                {
                    INSERT_VALUES_Y(slice, y)
                }

                if (x < CONV_DIM_HALF)
                {
                    INSERT_ZERO_X(slice, x)
                }
                else if (x >= high_x - CONV_DIM_HALF)
                {
                    INSERT_VALUES_X(slice, x)
                }

                for (i = 0; i < (vx_int32)(conv_width * conv_height); ++i)
                    sum += conv_mat[conv_width * conv_height - 1 - i] * slice[i];
            }
            else if (src_format == VX_DF_IMAGE_S16)
            {
                vx_int16 slice[C_MAX_CONVOLUTION_DIM * C_MAX_CONVOLUTION_DIM] = { 0 };

                readRect(src_base, &src_addr, bordermode, src_format, x, y, conv_radius_x, conv_radius_y, slice);

                if (y < CONV_DIM_HALF)
                {
                    INSERT_ZERO_Y(slice, y)
                }
                else if (y >= high_y - CONV_DIM_HALF)
                {
                    INSERT_VALUES_Y(slice, y)
                }

                if (x < CONV_DIM_HALF)
                {
                    INSERT_ZERO_X(slice, x)
                }
                else if (x >= high_x - CONV_DIM_HALF)
                {
                    INSERT_VALUES_X(slice, x)
                }

                for (i = 0; i < (vx_int32)(conv_width * conv_height); ++i)
                    sum += conv_mat[conv_width * conv_height - 1 - i] * slice[i];
            }

            value = sum / (vx_int32)scale;

            if (dst_format == VX_DF_IMAGE_U8)
            {
                vx_uint8 *dstp = vxFormatImagePatchAddress2d(dst_base, x, y, &dst_addr);
                if (value < 0) *dstp = 0;
                else if (value > UINT8_MAX) *dstp = UINT8_MAX;
                else *dstp = value;
            }
            else if (dst_format == VX_DF_IMAGE_S16)
            {
                vx_int16 *dstp = vxFormatImagePatchAddress2d(dst_base, x, y, &dst_addr);
                if (value < INT16_MIN) *dstp = INT16_MIN;
                else if (value > INT16_MAX) *dstp = INT16_MAX;
                else *dstp = value;
            }
        }
    }

    status |= vxCommitImagePatch(src, NULL, 0, &src_addr, src_base);
    status |= vxCommitImagePatch(dst, &rect, 0, &dst_addr, dst_base);

    return status;
}

static vx_status upsampleImage(vx_context context, vx_uint32 width, vx_uint32 height, vx_image filling, vx_convolution conv, vx_image upsample, vx_border_t *border)
{
    vx_status status = VX_SUCCESS;
    vx_df_image format, filling_format;

    format = VX_DF_IMAGE_U8;
    vx_image tmp = vxCreateImage(context, width, height, VX_DF_IMAGE_U8);
    status |= vxQueryImage(filling, VX_IMAGE_FORMAT, &filling_format, sizeof(filling_format));

    vx_rectangle_t tmp_rect, filling_rect;
    vx_imagepatch_addressing_t tmp_addr = VX_IMAGEPATCH_ADDR_INIT;
    vx_imagepatch_addressing_t filling_addr = VX_IMAGEPATCH_ADDR_INIT;
    vx_map_id tmp_map_id, filling_map_id;
    void *tmp_base = NULL;
    void *filling_base = NULL;

    status = vxGetValidRegionImage(tmp, &tmp_rect);
    status |= vxMapImagePatch(tmp, &tmp_rect, 0, &tmp_map_id, &tmp_addr, (void **)&tmp_base, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0);
    status = vxGetValidRegionImage(filling, &filling_rect);
    status |= vxMapImagePatch(filling, &filling_rect, 0, &filling_map_id, &filling_addr, (void **)&filling_base, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0);

    for (vx_uint32 ix = 0; ix < width; ix++)
    {
        for (vx_uint32 iy = 0; iy < height; iy++)
        {

            void* tmp_datap = vxFormatImagePatchAddress2d(tmp_base, ix, iy, &tmp_addr);

            if (iy % 2 != 0 || ix % 2 != 0)
            {
                if (format == VX_DF_IMAGE_U8)
                    *(vx_uint8 *)tmp_datap = (vx_uint8)0;
                else
                    *(vx_int16 *)tmp_datap = (vx_int16)0;
            }
            else
            {
                void* filling_tmp = vxFormatImagePatchAddress2d(filling_base, ix / 2, iy / 2, &filling_addr);
                vx_int32 filling_data = filling_format == VX_DF_IMAGE_U8 ? *(vx_uint8 *)filling_tmp : *(vx_int16 *)filling_tmp;
                if (format == VX_DF_IMAGE_U8)
                {
                    if (filling_data > UINT8_MAX)
                        filling_data = UINT8_MAX;
                    else if (filling_data < 0)
                        filling_data = 0;
                    *(vx_uint8 *)tmp_datap = (vx_uint8)filling_data;
                }
                else
                {
                    if (filling_data > INT16_MAX)
                        filling_data = INT16_MAX;
                    else if (filling_data < INT16_MIN)
                        filling_data = INT16_MIN;
                    *(vx_int16 *)tmp_datap = (vx_int16)filling_data;
                }
            }
        }
    }

    status |= vxUnmapImagePatch(tmp, tmp_map_id);
    status |= vxUnmapImagePatch(filling, filling_map_id);

    status |= convolve(tmp, conv, upsample, border);

    vx_rectangle_t upsample_rect;
    vx_imagepatch_addressing_t upsample_addr = VX_IMAGEPATCH_ADDR_INIT;
    vx_map_id upsample_map_id;
    void * upsample_base = NULL;
    vx_df_image upsample_format;

    status |= vxQueryImage(upsample, VX_IMAGE_FORMAT, &upsample_format, sizeof(upsample_format));
    status = vxGetValidRegionImage(upsample, &upsample_rect);
    status |= vxMapImagePatch(upsample, &upsample_rect, 0, &upsample_map_id, &upsample_addr, (void **)&upsample_base, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0);

    for (vx_uint32 ix = 0; ix < width; ix++)
    {
        for (vx_uint32 iy = 0; iy < height; iy++)
        {
            void* upsample_p = vxFormatImagePatchAddress2d(upsample_base, ix, iy, &upsample_addr);
            vx_int32 upsample_data = upsample_format == VX_DF_IMAGE_U8 ? *(vx_uint8 *)upsample_p : *(vx_int16 *)upsample_p;
            upsample_data *= 4;
            if (upsample_format == VX_DF_IMAGE_U8)
            {
                if (upsample_data > UINT8_MAX)
                    upsample_data = UINT8_MAX;
                else if (upsample_data < 0)
                    upsample_data = 0;
                *(vx_uint8 *)upsample_p = (vx_uint8)upsample_data;
            }
            else
            {
                if (upsample_data > INT16_MAX)
                    upsample_data = INT16_MAX;
                else if (upsample_data < INT16_MIN)
                    upsample_data = INT16_MIN;
                *(vx_int16 *)upsample_p = (vx_int16)upsample_data;
            }
        }
    }
    status |= vxUnmapImagePatch(upsample, upsample_map_id);
    status |= vxReleaseImage(&tmp);
    return status;
}

static void own_laplacian_pyramid_reference(vx_context context, vx_border_t border, vx_image input, vx_pyramid laplacian, vx_image output)
{
    vx_uint32 i;
    vx_size levels = 0;
    vx_uint32 width = 0;
    vx_uint32 height = 0;
    vx_df_image format = 0;
    vx_pyramid gaussian = 0;
    vx_convolution conv = 0;

    border.mode = VX_BORDER_REPLICATE;
    
    VX_CALL(vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border)));

    VX_CALL(vxQueryPyramid(laplacian, VX_PYRAMID_LEVELS, &levels, sizeof(levels)));

    VX_CALL(vxQueryImage(input, VX_IMAGE_WIDTH, &width, sizeof(width)));
    VX_CALL(vxQueryImage(input, VX_IMAGE_HEIGHT, &height, sizeof(height)));
    VX_CALL(vxQueryImage(input, VX_IMAGE_FORMAT, &format, sizeof(format)));

    ASSERT_VX_OBJECT(gaussian = vxCreatePyramid(context, levels + 1, VX_SCALE_PYRAMID_HALF, width, height, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);

    VX_CALL(vxuGaussianPyramid(context, input, gaussian));

    ASSERT_VX_OBJECT(conv = vxCreateConvolution(context, 5, 5), VX_TYPE_CONVOLUTION);

    VX_CALL(vxCopyConvolutionCoefficients(conv, (vx_int16*)gaussian5x5, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
    VX_CALL(vxSetConvolutionAttribute(conv, VX_CONVOLUTION_SCALE, (void*)&gaussian5x5scale, sizeof(gaussian5x5scale)));

    for (i = 0; i < levels; i++)
    {
        vx_uint32 w = 0;
        vx_uint32 h = 0;
        vx_image in1 = 0;
        vx_image in2 = 0;
        vx_image filter = 0;
        vx_image out = 0;

        ASSERT_VX_OBJECT(in1 = vxGetPyramidLevel(gaussian, i), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(in2 = vxGetPyramidLevel(gaussian, i + 1), VX_TYPE_IMAGE);

        VX_CALL(vxQueryImage(in1, VX_IMAGE_WIDTH, &w, sizeof(vx_uint32)));
        VX_CALL(vxQueryImage(in1, VX_IMAGE_HEIGHT, &h, sizeof(vx_uint32)));

        ASSERT_VX_OBJECT(filter = vxCreateImage(context, w, h, VX_DF_IMAGE_S16), VX_TYPE_IMAGE);
        border.mode = VX_BORDER_REPLICATE;
        upsampleImage(context, w, h, in2, conv, filter, &border);
        /* laplacian is S16 format */
        ASSERT_VX_OBJECT(out = vxGetPyramidLevel(laplacian, i), VX_TYPE_IMAGE);
        VX_CALL(vxuSubtract(context, in1, filter, VX_CONVERT_POLICY_SATURATE, out));

        if (i == levels - 1)
        {
            vx_image tmp = vxGetPyramidLevel(gaussian, levels);
            ownCopyImage(tmp, output);
            VX_CALL(vxReleaseImage(&tmp));
        }

        VX_CALL(vxReleaseImage(&filter));
        VX_CALL(vxReleaseImage(&in1));
        VX_CALL(vxReleaseImage(&in2));
        VX_CALL(vxReleaseImage(&out));

    }

    VX_CALL(vxReleasePyramid(&gaussian));
    VX_CALL(vxReleaseConvolution(&conv));

    ASSERT(conv == 0);
    ASSERT(gaussian == 0);

    return;
}

static void own_laplacian_pyramid_openvx(vx_context context, vx_border_t border, vx_image input, vx_pyramid laplacian, vx_image output)
{
    vx_graph graph = 0;
    vx_node node = 0;

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

    ASSERT_VX_OBJECT(node = vxLaplacianPyramidNode(graph, input, laplacian, output), VX_TYPE_NODE);

    VX_CALL(vxSetNodeAttribute(node, VX_NODE_BORDER, &border, sizeof(border)));

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

    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseGraph(&graph));

    ASSERT(node == 0);
    ASSERT(graph == 0);

    return;
}

typedef struct
{
    const char* testName;
    CT_Image(*generator)(const char* fileName, int width, int height);
    const char* fileName;
    vx_border_t border;
    int width;
    int height;
} Arg;


#define ADD_SIZE_OWN_SET(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sz=128x128", __VA_ARGS__, 128, 128)), \
    CT_EXPAND(nextmacro(testArgName "/sz=256x256", __VA_ARGS__, 256, 256)), \
    CT_EXPAND(nextmacro(testArgName "/sz=640x480", __VA_ARGS__, 640, 480))


#define LAPLACIAN_PYRAMID_PARAMETERS \
    CT_GENERATE_PARAMETERS("randomInput", ADD_VX_BORDERS_REQUIRE_UNDEFINED_ONLY, ADD_SIZE_OWN_SET, ARG, own_generate_random, NULL), \
    CT_GENERATE_PARAMETERS("lena", ADD_VX_BORDERS_REQUIRE_UNDEFINED_ONLY, ADD_SIZE_NONE, ARG, own_read_image, "lena.bmp")

TEST_WITH_ARG(LaplacianPyramid, testGraphProcessing, Arg, LAPLACIAN_PYRAMID_PARAMETERS)
{
    vx_context context = context_->vx_context_;
    vx_size levels = 0;
    vx_uint32 i;
    vx_image src = 0;
    vx_image ref_dst = 0;
    vx_image tst_dst = 0;
    vx_pyramid ref_pyr = 0;
    vx_pyramid tst_pyr = 0;

    CT_Image input = NULL;

    vx_border_t border = arg_->border;

    ASSERT_NO_FAILURE(input = arg_->generator(arg_->fileName, arg_->width, arg_->height));
    ASSERT_VX_OBJECT(src = ct_image_to_vx_image(input, context), VX_TYPE_IMAGE);

    levels = own_pyramid_calc_max_levels_count(input->width, input->height, VX_SCALE_PYRAMID_HALF) - 1;

    {
        vx_uint32 next_lev_width = input->width;
        vx_uint32 next_lev_height = input->height;

        ASSERT_VX_OBJECT(ref_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);
        ASSERT_VX_OBJECT(tst_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);

        for (i = 1; i < levels + 1; i++)
        {
            next_lev_width = (vx_uint32)ceilf(next_lev_width * VX_SCALE_PYRAMID_HALF);
            next_lev_height = (vx_uint32)ceilf(next_lev_height * VX_SCALE_PYRAMID_HALF);
        }

        ASSERT_VX_OBJECT(ref_dst = vxCreateImage(context, next_lev_width, next_lev_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(tst_dst = vxCreateImage(context, next_lev_width, next_lev_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    }

    own_laplacian_pyramid_reference(context, border, src, ref_pyr, ref_dst);
    own_laplacian_pyramid_openvx(context, border, src, tst_pyr, tst_dst);

    {
        CT_Image ct_ref_dst = 0;
        CT_Image ct_tst_dst = 0;

        ASSERT_NO_FAILURE(ct_ref_dst = ct_image_from_vx_image(ref_dst));
        ASSERT_NO_FAILURE(ct_tst_dst = ct_image_from_vx_image(tst_dst));
        EXPECT_CTIMAGE_NEAR(ct_ref_dst, ct_tst_dst, 1);

        for (i = 0; i < levels; i++)
        {
            CT_Image ct_ref_lev = 0;
            CT_Image ct_tst_lev = 0;
            vx_image ref_lev = 0;
            vx_image tst_lev = 0;

            ASSERT_VX_OBJECT(ref_lev = vxGetPyramidLevel(ref_pyr, i), VX_TYPE_IMAGE);
            ASSERT_VX_OBJECT(tst_lev = vxGetPyramidLevel(tst_pyr, i), VX_TYPE_IMAGE);

            ASSERT_NO_FAILURE(ct_ref_lev = ct_image_from_vx_image(ref_lev));
            ASSERT_NO_FAILURE(ct_tst_lev = ct_image_from_vx_image(tst_lev));
            EXPECT_CTIMAGE_NEAR(ct_ref_lev, ct_tst_lev, 1);

            VX_CALL(vxReleaseImage(&ref_lev));
            VX_CALL(vxReleaseImage(&tst_lev));
        }
    }

    VX_CALL(vxReleaseImage(&src));
    VX_CALL(vxReleasePyramid(&ref_pyr));
    VX_CALL(vxReleasePyramid(&tst_pyr));
    VX_CALL(vxReleaseImage(&ref_dst));
    VX_CALL(vxReleaseImage(&tst_dst));

    ASSERT(src == 0);
    ASSERT(ref_pyr == 0);
    ASSERT(tst_pyr == 0);
    ASSERT(ref_dst == 0);
    ASSERT(tst_dst == 0);
}

TEST_WITH_ARG(LaplacianPyramid, testImmediateProcessing, Arg, LAPLACIAN_PYRAMID_PARAMETERS)
{
    vx_context context = context_->vx_context_;
    vx_size levels = 0;
    vx_uint32 i;
    vx_image src = 0;
    vx_image ref_dst = 0;
    vx_image tst_dst = 0;
    vx_pyramid ref_pyr = 0;
    vx_pyramid tst_pyr = 0;
    int undefined_border = 2; // 5x5 kernel border

    CT_Image input = NULL;

    vx_border_t border = arg_->border;

    ASSERT_NO_FAILURE(input = arg_->generator(arg_->fileName, arg_->width, arg_->height));
    ASSERT_VX_OBJECT(src = ct_image_to_vx_image(input, context), VX_TYPE_IMAGE);

    levels = own_pyramid_calc_max_levels_count(input->width, input->height, VX_SCALE_PYRAMID_HALF) - 1;

    {
        vx_uint32 next_lev_width = input->width;
        vx_uint32 next_lev_height = input->height;

        ASSERT_VX_OBJECT(ref_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);
        ASSERT_VX_OBJECT(tst_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);

        for (i = 1; i < levels + 1; i++)
        {
            next_lev_width = (vx_uint32)ceilf(next_lev_width * VX_SCALE_PYRAMID_HALF);
            next_lev_height = (vx_uint32)ceilf(next_lev_height * VX_SCALE_PYRAMID_HALF);
        }

        ASSERT_VX_OBJECT(ref_dst = vxCreateImage(context, next_lev_width, next_lev_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(tst_dst = vxCreateImage(context, next_lev_width, next_lev_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    }

    own_laplacian_pyramid_reference(context, border, src, ref_pyr, ref_dst);
    
    border.mode = VX_BORDER_REPLICATE;
    
    VX_CALL(vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border)));
    VX_CALL(vxuLaplacianPyramid(context, src, tst_pyr, tst_dst));

    {
        CT_Image ct_ref_dst = 0;
        CT_Image ct_tst_dst = 0;

        ASSERT_NO_FAILURE(ct_ref_dst = ct_image_from_vx_image(ref_dst));
        ASSERT_NO_FAILURE(ct_tst_dst = ct_image_from_vx_image(tst_dst));
        ASSERT_NO_FAILURE(ct_adjust_roi(ct_ref_dst, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border));
        ASSERT_NO_FAILURE(ct_adjust_roi(ct_tst_dst, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border));
        EXPECT_CTIMAGE_NEAR(ct_ref_dst, ct_tst_dst, 1);

        for (i = 0; i < levels; i++)
        {
            CT_Image ct_ref_lev = 0;
            CT_Image ct_tst_lev = 0;
            vx_image ref_lev = 0;
            vx_image tst_lev = 0;

            ASSERT_VX_OBJECT(ref_lev = vxGetPyramidLevel(ref_pyr, i), VX_TYPE_IMAGE);
            ASSERT_VX_OBJECT(tst_lev = vxGetPyramidLevel(tst_pyr, i), VX_TYPE_IMAGE);

            ASSERT_NO_FAILURE(ct_ref_lev = ct_image_from_vx_image(ref_lev));
            ASSERT_NO_FAILURE(ct_tst_lev = ct_image_from_vx_image(tst_lev));
            ASSERT_NO_FAILURE(ct_adjust_roi(ct_ref_lev, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border));
            ASSERT_NO_FAILURE(ct_adjust_roi(ct_tst_lev, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border, 2 * undefined_border));
            EXPECT_CTIMAGE_NEAR(ct_ref_lev, ct_tst_lev, 1);

            VX_CALL(vxReleaseImage(&ref_lev));
            VX_CALL(vxReleaseImage(&tst_lev));
        }
    }

    VX_CALL(vxReleaseImage(&src));
    VX_CALL(vxReleasePyramid(&ref_pyr));
    VX_CALL(vxReleasePyramid(&tst_pyr));
    VX_CALL(vxReleaseImage(&ref_dst));
    VX_CALL(vxReleaseImage(&tst_dst));

    ASSERT(src == 0);
    ASSERT(ref_pyr == 0);
    ASSERT(tst_pyr == 0);
    ASSERT(ref_dst == 0);
    ASSERT(tst_dst == 0);
}

TESTCASE_TESTS(LaplacianPyramid,
    testNodeCreation,
    testGraphProcessing,
    testImmediateProcessing
)

/* reconstruct image from laplacian pyramid */

#define VX_SCALE_PYRAMID_DOUBLE (2.0f)

TESTCASE(LaplacianReconstruct, CT_VXContext, ct_setup_vx_context, 0)

TEST(LaplacianReconstruct, testNodeCreation)
{
    vx_context context = context_->vx_context_;
    vx_pyramid laplacian = 0;
    vx_image   input = 0;
    vx_image   output = 0;
    vx_graph   graph = 0;
    vx_node    node = 0;
    const vx_size levels = 4;
    const vx_float32 scale = VX_SCALE_PYRAMID_HALF;
    const vx_uint32 width = 640;
    const vx_uint32 height = 480;
    vx_size num_levels = levels;
    vx_uint32 w = width;
    vx_uint32 h = height;

    while (num_levels--)
    {
        w = (vx_uint32)ceilf(w * scale);
        h = (vx_uint32)ceilf(h * scale);
    }

    ASSERT_VX_OBJECT(input = vxCreateImage(context, w, h, VX_DF_IMAGE_S16), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(output = vxCreateImage(context, width, height, VX_DF_IMAGE_S16), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(laplacian = vxCreatePyramid(context, levels, scale, width, height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);

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

    ASSERT_VX_OBJECT(node = vxLaplacianReconstructNode(graph, laplacian, input, output), VX_TYPE_NODE);

    VX_CALL(vxVerifyGraph(graph));

    VX_CALL(vxReleaseImage(&input));
    VX_CALL(vxReleasePyramid(&laplacian));
    VX_CALL(vxReleaseImage(&output));
    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseGraph(&graph));

    ASSERT(laplacian == 0);
    ASSERT(input == 0);
    ASSERT(output == 0);
    ASSERT(node == 0);
    ASSERT(graph == 0);
}

static void own_laplacian_reconstruct_reference(vx_context context, vx_border_t border, vx_pyramid laplacian, vx_image input, vx_image output)
{
    vx_size i;
    vx_size levels = 0;
    vx_uint32 width = 0;
    vx_uint32 height = 0;
    vx_uint32 prev_lev_width = 0;
    vx_uint32 prev_lev_height = 0;
    vx_df_image format = 0;
    vx_image pyr_level = 0;
    vx_image filling = 0;
    vx_image filter = 0;
    vx_image out = 0;
    vx_convolution conv;

    VX_CALL(vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border)));

    VX_CALL(vxQueryPyramid(laplacian, VX_PYRAMID_LEVELS, &levels, sizeof(vx_size)));
    VX_CALL(vxQueryPyramid(laplacian, VX_PYRAMID_FORMAT, &format, sizeof(vx_df_image)));

    VX_CALL(vxQueryImage(input, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32)));
    VX_CALL(vxQueryImage(input, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32)));

    conv = vxCreateGaussian5x5Convolution(context);

    prev_lev_width = (vx_uint32)ceilf(width  * VX_SCALE_PYRAMID_DOUBLE);
    prev_lev_height = (vx_uint32)ceilf(height * VX_SCALE_PYRAMID_DOUBLE);

    ASSERT_VX_OBJECT(filling = vxCreateImage(context, width, height, format), VX_TYPE_IMAGE);
    VX_CALL(ownCopyImage(input, filling));

    for (i = 0; i < levels; i++)
    {
        ASSERT_VX_OBJECT(pyr_level = vxGetPyramidLevel(laplacian, (vx_uint32)((levels - 1) - i)), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(out = vxCreateImage(context, prev_lev_width, prev_lev_height, format), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(filter = vxCreateImage(context, prev_lev_width, prev_lev_height, format), VX_TYPE_IMAGE);

        upsampleImage(context, prev_lev_width, prev_lev_height, filling, conv, filter, &border);
        VX_CALL(vxuAdd(context, filter, pyr_level, VX_CONVERT_POLICY_SATURATE, out));

        VX_CALL(vxReleaseImage(&pyr_level));

        if ((levels - 1) - i == 0)
        {
            VX_CALL(ownCopyImage(out, output));
            VX_CALL(vxReleaseImage(&filling));
        }
        else
        {
            VX_CALL(vxReleaseImage(&filling));
            ASSERT_VX_OBJECT(filling = vxCreateImage(context, prev_lev_width, prev_lev_height, format), VX_TYPE_IMAGE);
            VX_CALL(ownCopyImage(out, filling));
            /* compute dimensions for the prev level */
            prev_lev_width = (vx_uint32)ceilf(prev_lev_width * VX_SCALE_PYRAMID_DOUBLE);
            prev_lev_height = (vx_uint32)ceilf(prev_lev_height * VX_SCALE_PYRAMID_DOUBLE);
        }

        VX_CALL(vxReleaseImage(&out));
        VX_CALL(vxReleaseImage(&filter));
    }

    VX_CALL(vxReleaseConvolution(&conv));

    return;
}

static void own_laplacian_reconstruct_openvx(vx_context context, vx_border_t border, vx_pyramid laplacian, vx_image input, vx_image output)
{
    vx_graph graph = 0;
    vx_node node = 0;

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

    ASSERT_VX_OBJECT(node = vxLaplacianReconstructNode(graph, laplacian, input, output), VX_TYPE_NODE);

    VX_CALL(vxSetNodeAttribute(node, VX_NODE_BORDER, &border, sizeof(border)));

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

    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseGraph(&graph));

    ASSERT(node == 0);
    ASSERT(graph == 0);

    return;
}

#define LAPLACIAN_RECONSTRUCT_PARAMETERS \
    CT_GENERATE_PARAMETERS("randomInput", ADD_VX_BORDERS_REQUIRE_UNDEFINED_ONLY, ADD_SIZE_OWN_SET, ARG, own_generate_random, NULL), \
    CT_GENERATE_PARAMETERS("lena", ADD_VX_BORDERS_REQUIRE_UNDEFINED_ONLY, ADD_SIZE_NONE, ARG, own_read_image, "lena.bmp")

TEST_WITH_ARG(LaplacianReconstruct, testGraphProcessing, Arg, LAPLACIAN_RECONSTRUCT_PARAMETERS)
{
    vx_uint32 i;
    vx_context context = context_->vx_context_;
    vx_size levels = 0;
    vx_image src = 0;
    vx_image ref_lowest_res = 0;
    vx_image ref_dst = 0;
    vx_image tst_dst = 0;
    vx_pyramid ref_pyr = 0;

    CT_Image input = NULL;

    //vx_border_t border = arg_->border;
    vx_border_t build_border = { VX_BORDER_REPLICATE };

    ASSERT_NO_FAILURE(input = arg_->generator(arg_->fileName, arg_->width, arg_->height));
    ASSERT_VX_OBJECT(src = ct_image_to_vx_image(input, context), VX_TYPE_IMAGE);

    levels = own_pyramid_calc_max_levels_count(input->width, input->height, VX_SCALE_PYRAMID_HALF) - 1;

    {
        vx_uint32 lowest_res_width = input->width;
        vx_uint32 lowest_res_height = input->height;

        for (i = 0; i < levels; i++)
        {
            lowest_res_width = (vx_uint32)ceilf(lowest_res_width * VX_SCALE_PYRAMID_HALF);
            lowest_res_height = (vx_uint32)ceilf(lowest_res_height * VX_SCALE_PYRAMID_HALF);
        }

        ASSERT_VX_OBJECT(ref_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);

        ASSERT_VX_OBJECT(ref_lowest_res = vxCreateImage(context, lowest_res_width, lowest_res_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(ref_dst = vxCreateImage(context, input->width, input->height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(tst_dst = vxCreateImage(context, input->width, input->height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    }

    own_laplacian_pyramid_reference(context, build_border, src, ref_pyr, ref_lowest_res);
    own_laplacian_reconstruct_reference(context, build_border, ref_pyr, ref_lowest_res, ref_dst);
    own_laplacian_reconstruct_openvx(context, build_border, ref_pyr, ref_lowest_res, tst_dst);

    {
        CT_Image ct_ref_dst = 0;
        CT_Image ct_tst_dst = 0;

        ASSERT_NO_FAILURE(ct_ref_dst = ct_image_from_vx_image(ref_dst));
        ASSERT_NO_FAILURE(ct_tst_dst = ct_image_from_vx_image(tst_dst));
        EXPECT_CTIMAGE_NEAR(ct_ref_dst, ct_tst_dst, 1);
    }

    VX_CALL(vxReleaseImage(&src));
    VX_CALL(vxReleasePyramid(&ref_pyr));
    VX_CALL(vxReleaseImage(&ref_lowest_res));
    VX_CALL(vxReleaseImage(&ref_dst));
    VX_CALL(vxReleaseImage(&tst_dst));

    ASSERT(src == 0);
    ASSERT(ref_pyr == 0);
    ASSERT(ref_lowest_res == 0);
    ASSERT(ref_dst == 0);
    ASSERT(tst_dst == 0);
}

TEST_WITH_ARG(LaplacianReconstruct, testImmediateProcessing, Arg, LAPLACIAN_RECONSTRUCT_PARAMETERS)
{
    vx_uint32 i;
    vx_context context = context_->vx_context_;
    vx_size levels = 0;
    vx_image src = 0;
    vx_image ref_lovest_res = 0;
    vx_image ref_dst = 0;
    vx_image tst_dst = 0;
    vx_pyramid ref_pyr = 0;

    CT_Image input = NULL;

    //vx_border_t border = arg_->border;
    vx_border_t build_border = { VX_BORDER_REPLICATE };

    ASSERT_NO_FAILURE(input = arg_->generator(arg_->fileName, arg_->width, arg_->height));
    ASSERT_VX_OBJECT(src = ct_image_to_vx_image(input, context), VX_TYPE_IMAGE);

    levels = own_pyramid_calc_max_levels_count(input->width, input->height, VX_SCALE_PYRAMID_HALF) - 1;

    {
        vx_uint32 lowest_res_width = input->width;
        vx_uint32 lowest_res_height = input->height;

        for (i = 0; i < levels; i++)
        {
            lowest_res_width = (vx_uint32)ceilf(lowest_res_width * VX_SCALE_PYRAMID_HALF);
            lowest_res_height = (vx_uint32)ceilf(lowest_res_height * VX_SCALE_PYRAMID_HALF);
        }

        ASSERT_VX_OBJECT(ref_pyr = vxCreatePyramid(context, levels, VX_SCALE_PYRAMID_HALF, input->width, input->height, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);

        ASSERT_VX_OBJECT(ref_lovest_res = vxCreateImage(context, lowest_res_width, lowest_res_height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(ref_dst = vxCreateImage(context, input->width, input->height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(tst_dst = vxCreateImage(context, input->width, input->height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    }

    own_laplacian_pyramid_reference(context, build_border, src, ref_pyr, ref_lovest_res);
    own_laplacian_reconstruct_reference(context, build_border, ref_pyr, ref_lovest_res, ref_dst);

    VX_CALL(vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &build_border, sizeof(build_border)));
    VX_CALL(vxuLaplacianReconstruct(context, ref_pyr, ref_lovest_res, tst_dst));

    {
        CT_Image ct_ref_dst = 0;
        CT_Image ct_tst_dst = 0;

        ASSERT_NO_FAILURE(ct_ref_dst = ct_image_from_vx_image(ref_dst));
        ASSERT_NO_FAILURE(ct_tst_dst = ct_image_from_vx_image(tst_dst));
        EXPECT_CTIMAGE_NEAR(ct_ref_dst, ct_tst_dst, 1);
    }

    VX_CALL(vxReleaseImage(&src));
    VX_CALL(vxReleasePyramid(&ref_pyr));
    VX_CALL(vxReleaseImage(&ref_lovest_res));
    VX_CALL(vxReleaseImage(&ref_dst));
    VX_CALL(vxReleaseImage(&tst_dst));

    ASSERT(src == 0);
    ASSERT(ref_pyr == 0);
    ASSERT(ref_lovest_res == 0);
    ASSERT(ref_dst == 0);
    ASSERT(tst_dst == 0);
}

TESTCASE_TESTS(LaplacianReconstruct,
    testNodeCreation,
    testGraphProcessing,
    testImmediateProcessing
)