Google Git
Sign in
fuchsia / third_party / github.com / KhronosGroup / OpenVX-cts / 51233dd4c6298d5ea118afb5d4b61124a3f82832 / . / test_conformance / test_graph.c
blob: 10f812bcea203839123bcf9184249ab615dc5f7d [file] [log] [blame]
/*
* 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 "test_engine/test.h"
#include <VX/vx.h>
#include <VX/vxu.h>
TESTCASE(Graph, CT_VXContext, ct_setup_vx_context, 0)
TEST(Graph, testTwoNodes)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testVirtualImage)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(interm_image = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
#ifndef dimof
# define dimof(arr) (sizeof(arr)/sizeof((arr)[0]))
#endif
// example from specification wrapped into asserts
static void testCornersGraphFactory(vx_context context, vx_graph* graph_out)
{
vx_uint32 i;
vx_float32 strength_thresh = 10000.0f;
vx_float32 r = 1.5f;
vx_float32 sensitivity = 0.14f;
vx_int32 window_size = 3;
vx_int32 block_size = 3;
vx_graph graph = 0;
vx_enum channel = VX_CHANNEL_Y;
*graph_out = NULL;
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
// if (vxGetStatus((vx_reference)graph) == VX_SUCCESS)
{
vx_image virts[] = {
vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT),
vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT)
};
vx_kernel kernels[] = {
vxGetKernelByEnum(context, VX_KERNEL_CHANNEL_EXTRACT),
vxGetKernelByEnum(context, VX_KERNEL_MEDIAN_3x3),
vxGetKernelByEnum(context, VX_KERNEL_HARRIS_CORNERS)
};
vx_node nodes[dimof(kernels)] = {
vxCreateGenericNode(graph, kernels[0]),
vxCreateGenericNode(graph, kernels[1]),
vxCreateGenericNode(graph, kernels[2])
};
vx_scalar scalars[] = {
vxCreateScalar(context, VX_TYPE_ENUM, &channel),
vxCreateScalar(context, VX_TYPE_FLOAT32, &strength_thresh),
vxCreateScalar(context, VX_TYPE_FLOAT32, &r),
vxCreateScalar(context, VX_TYPE_FLOAT32, &sensitivity),
vxCreateScalar(context, VX_TYPE_INT32, &window_size),
vxCreateScalar(context, VX_TYPE_INT32, &block_size)
};
vx_parameter parameters[] = {
vxGetParameterByIndex(nodes[0], 0),
vxGetParameterByIndex(nodes[2], 6)
};
for (i = 0; i < dimof(virts); i++)
ASSERT_VX_OBJECT(virts[i], VX_TYPE_IMAGE);
for (i = 0; i < dimof(kernels); i++)
ASSERT_VX_OBJECT(kernels[i], VX_TYPE_KERNEL);
for (i = 0; i < dimof(nodes); i++)
ASSERT_VX_OBJECT(nodes[i], VX_TYPE_NODE);
for (i = 0; i < dimof(scalars); i++)
ASSERT_VX_OBJECT(scalars[i], VX_TYPE_SCALAR);
for (i = 0; i < dimof(parameters); i++)
ASSERT_VX_OBJECT(parameters[i], VX_TYPE_PARAMETER);
// Channel Extract
VX_CALL(vxAddParameterToGraph(graph, parameters[0]));
VX_CALL(vxSetParameterByIndex(nodes[0], 1, (vx_reference)scalars[0]));
VX_CALL(vxSetParameterByIndex(nodes[0], 2, (vx_reference)virts[0]));
// Median Filter
VX_CALL(vxSetParameterByIndex(nodes[1], 0, (vx_reference)virts[0]));
VX_CALL(vxSetParameterByIndex(nodes[1], 1, (vx_reference)virts[1]));
// Harris Corners
VX_CALL(vxSetParameterByIndex(nodes[2], 0, (vx_reference)virts[1]));
VX_CALL(vxSetParameterByIndex(nodes[2], 1, (vx_reference)scalars[1]));
VX_CALL(vxSetParameterByIndex(nodes[2], 2, (vx_reference)scalars[2]));
VX_CALL(vxSetParameterByIndex(nodes[2], 3, (vx_reference)scalars[3]));
VX_CALL(vxSetParameterByIndex(nodes[2], 4, (vx_reference)scalars[4]));
VX_CALL(vxSetParameterByIndex(nodes[2], 5, (vx_reference)scalars[5]));
VX_CALL(vxAddParameterToGraph(graph, parameters[1]));
for (i = 0; i < dimof(scalars); i++)
{
VX_CALL(vxReleaseScalar(&scalars[i]));
ASSERT(scalars[i] == NULL);
}
for (i = 0; i < dimof(virts); i++)
{
VX_CALL(vxReleaseImage(&virts[i]));
ASSERT(virts[i] == NULL);
}
for (i = 0; i < dimof(kernels); i++)
{
VX_CALL(vxReleaseKernel(&kernels[i]));
ASSERT(kernels[i] == NULL);
}
for (i = 0; i < dimof(nodes); i++)
{
VX_CALL(vxReleaseNode(&nodes[i]));
ASSERT(nodes[i] == NULL);
}
for (i = 0; i < dimof(parameters); i++)
{
VX_CALL(vxReleaseParameter(&parameters[i]));
ASSERT(parameters[i] == NULL);
}
}
*graph_out = graph;
}
TEST(Graph, testGraphFactory)
{
vx_context context = context_->vx_context_;
vx_graph graph;
vx_image source;
vx_array points;
vx_parameter points_param;
ASSERT_NO_FAILURE(testCornersGraphFactory(context, &graph));
ASSERT_VX_OBJECT(source = vxCreateImage(context, 640, 480, VX_DF_IMAGE_YUV4), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(points = vxCreateArray(context, VX_TYPE_KEYPOINT, 100), VX_TYPE_ARRAY);
ASSERT_NO_FAILURE(ct_fill_image_random(source, &CT()->seed_));
VX_CALL(vxSetGraphParameterByIndex(graph, 0, (vx_reference)source));
ASSERT_VX_OBJECT(points_param = vxGetGraphParameterByIndex(graph, 1), VX_TYPE_PARAMETER);
VX_CALL(vxSetParameterByReference(points_param, (vx_reference)points));
VX_CALL(vxReleaseParameter(&points_param));
ASSERT(points_param == NULL);
VX_CALL(vxReleaseImage(&source));
ASSERT(source == NULL);
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseArray(&points));
ASSERT(points == NULL);
VX_CALL(vxReleaseGraph(&graph));
ASSERT(graph == NULL);
}
#define VX_KERNEL_CONFORMANCE_TEST_TAKE10_NAME "org.khronos.openvx.test.array_take_10"
static vx_status VX_CALLBACK take10_ParameterValidator(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
{
vx_size capacity = 10;
vx_enum type = VX_TYPE_KEYPOINT;
// are we really required to set these attributes???
VX_CALL_(return VX_FAILURE, vxSetMetaFormatAttribute(metas[1], VX_ARRAY_CAPACITY, &capacity, sizeof(capacity)));
VX_CALL_(return VX_FAILURE, vxSetMetaFormatAttribute(metas[1], VX_ARRAY_ITEMTYPE, &type, sizeof(type)));
return VX_SUCCESS;
}
static vx_status VX_CALLBACK take10_Kernel(vx_node node, const vx_reference *parameters, vx_uint32 num)
{
vx_array input, output;
vx_size len = 0;
vx_size stride = 0;
void* data = 0;
vx_map_id map_id;
ASSERT_(return VX_FAILURE, num == 2);
ASSERT_VX_OBJECT_(return VX_FAILURE, input = (vx_array)parameters[0], VX_TYPE_ARRAY);
ASSERT_VX_OBJECT_(return VX_FAILURE, output = (vx_array)parameters[1], VX_TYPE_ARRAY);
VX_CALL_(return VX_FAILURE, vxTruncateArray(output, 0));
VX_CALL_(return VX_FAILURE, vxQueryArray(input, VX_ARRAY_NUMITEMS, &len, sizeof(len)));
if (len > 10) len = 10;
VX_CALL_(return VX_FAILURE, vxMapArrayRange(input, 0, len, &map_id, &stride, &data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X));
VX_CALL_(return VX_FAILURE, vxAddArrayItems(output, len, data, stride));
VX_CALL_(return VX_FAILURE, vxUnmapArrayRange(input, map_id));
return VX_SUCCESS;
}
static void take10_node(vx_graph graph, vx_array in, vx_array out)
{
vx_kernel kernel = 0;
vx_node node = 0;
vx_context context = vxGetContext((vx_reference)graph);
vx_enum take10_enumId = 0u;
ASSERT_VX_OBJECT(context, VX_TYPE_CONTEXT);
VX_CALL(vxAllocateUserKernelId(context, &take10_enumId));
ASSERT_VX_OBJECT(kernel = vxAddUserKernel(
context,
VX_KERNEL_CONFORMANCE_TEST_TAKE10_NAME,
take10_enumId,
take10_Kernel,
2,
take10_ParameterValidator,
NULL,
NULL), VX_TYPE_KERNEL);
VX_CALL(vxAddParameterToKernel(kernel, 0, VX_INPUT, VX_TYPE_ARRAY, VX_PARAMETER_STATE_REQUIRED));
VX_CALL(vxAddParameterToKernel(kernel, 1, VX_OUTPUT, VX_TYPE_ARRAY, VX_PARAMETER_STATE_REQUIRED));
VX_CALL(vxFinalizeKernel(kernel));
ASSERT_VX_OBJECT(node = vxCreateGenericNode(graph, kernel), VX_TYPE_NODE);
VX_CALL(vxSetParameterByIndex(node, 0, (vx_reference)in));
VX_CALL(vxSetParameterByIndex(node, 1, (vx_reference)out));
VX_CALL(vxReleaseNode(&node));
ASSERT(node == 0);
VX_CALL(vxReleaseKernel(&kernel));
ASSERT(kernel == 0);
}
TEST(Graph, testVirtualArray)
{
vx_bool use_estimations;
vx_uint32 num_iter;
vx_float32 threshold_f;
vx_float32 eps;
vx_scalar fast_thresh;
vx_scalar flow_eps;
vx_scalar flow_num_iter;
vx_scalar flow_use_estimations;
vx_size window;
vx_array corners;
vx_array new_corners, corners10;
vx_image frame0 = 0;
vx_image frame1 = 0;
vx_pyramid p0;
vx_pyramid p1;
vx_node n1;
vx_node n2;
vx_node n3;
vx_node n4;
vx_graph graph;
vx_context context;
vx_kernel kernel;
CT_Image src0 = 0, src1 = 0;
vx_scalar scalar_fastCorners = 0;
vx_size fastCorners = 0;
ASSERT_VX_OBJECT(context = context_->vx_context_, VX_TYPE_CONTEXT);
ASSERT_NO_FAILURE(src0 = ct_read_image("optflow_00.bmp", 1));
ASSERT_NO_FAILURE(src1 = ct_read_image("optflow_01.bmp", 1));
ASSERT_VX_OBJECT(frame0 = ct_image_to_vx_image(src0, context), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(frame1 = ct_image_to_vx_image(src1, context), VX_TYPE_IMAGE);
threshold_f = 80;
eps = 0.01f;
num_iter = 10;
use_estimations = vx_false_e;
window = 3;
ASSERT_VX_OBJECT(fast_thresh = vxCreateScalar(context, VX_TYPE_FLOAT32, &threshold_f), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(flow_eps = vxCreateScalar(context, VX_TYPE_FLOAT32, &eps), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(flow_num_iter = vxCreateScalar(context, VX_TYPE_UINT32, &num_iter), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(flow_use_estimations = vxCreateScalar(context, VX_TYPE_BOOL, &use_estimations), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
// Don't use zero capacity here
ASSERT_VX_OBJECT(corners = vxCreateVirtualArray(graph, 0, 100), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(new_corners = vxCreateVirtualArray(graph, 0, 0), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(corners10 = vxCreateArray(context, VX_TYPE_KEYPOINT, 10), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(scalar_fastCorners = vxCreateScalar(context, VX_TYPE_SIZE, &fastCorners), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(n1 = vxFastCornersNode(graph, frame0, fast_thresh, vx_true_e, corners, scalar_fastCorners), VX_TYPE_NODE);
ASSERT_VX_OBJECT(p0 = vxCreateVirtualPyramid(graph, 4, VX_SCALE_PYRAMID_HALF, 0, 0, VX_DF_IMAGE_VIRT), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(p1 = vxCreateVirtualPyramid(graph, 4, VX_SCALE_PYRAMID_HALF, 0, 0, VX_DF_IMAGE_VIRT), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(n2 = vxGaussianPyramidNode(graph, frame0, p0), VX_TYPE_NODE);
ASSERT_VX_OBJECT(n3 = vxGaussianPyramidNode(graph, frame1, p1), VX_TYPE_NODE);
ASSERT_VX_OBJECT(n4 = vxOpticalFlowPyrLKNode(graph, p0, p1, corners, corners, new_corners, VX_TERM_CRITERIA_BOTH, flow_eps, flow_num_iter, flow_use_estimations, window), VX_TYPE_NODE);
take10_node(graph, new_corners, corners10);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxCopyScalar(scalar_fastCorners, &fastCorners, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
ASSERT(fastCorners > 0);
VX_CALL(vxReleaseScalar(&scalar_fastCorners));
VX_CALL(vxReleaseScalar(&fast_thresh));
VX_CALL(vxReleaseScalar(&flow_eps));
VX_CALL(vxReleaseScalar(&flow_num_iter));
VX_CALL(vxReleaseScalar(&flow_use_estimations));
VX_CALL(vxReleaseArray(&corners));
VX_CALL(vxReleaseArray(&new_corners));
VX_CALL(vxReleaseArray(&corners10));
VX_CALL(vxReleasePyramid(&p0));
VX_CALL(vxReleasePyramid(&p1));
VX_CALL(vxReleaseImage(&frame0));
VX_CALL(vxReleaseImage(&frame1));
VX_CALL(vxReleaseNode(&n1));
VX_CALL(vxReleaseNode(&n2));
VX_CALL(vxReleaseNode(&n3));
VX_CALL(vxReleaseNode(&n4));
VX_CALL(vxReleaseGraph(&graph));
ASSERT_VX_OBJECT(kernel = vxGetKernelByName(context, VX_KERNEL_CONFORMANCE_TEST_TAKE10_NAME), VX_TYPE_KERNEL);
VX_CALL(vxRemoveKernel(kernel));
}
TEST(Graph, testNodeRemove)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
vx_uint32 num_nodes = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_NUMNODES, &num_nodes, sizeof(num_nodes)));
ASSERT(num_nodes == 2);
VX_CALL(vxRemoveNode(&node2));
ASSERT(node2 == 0);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_NUMNODES, &num_nodes, sizeof(num_nodes)));
ASSERT(num_nodes == 1);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testNodeFromEnum)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_kernel kernel = 0;
vx_node node = 0;
vx_uint32 num_params = 0;
vx_parameter parameter = 0;
vx_image p_image = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(kernel = vxGetKernelByEnum(context, VX_KERNEL_BOX_3x3), VX_TYPE_KERNEL);
VX_CALL(vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &num_params, sizeof(num_params)));
ASSERT_EQ_INT(2, num_params);
ASSERT_VX_OBJECT(node = vxCreateGenericNode(graph, kernel), VX_TYPE_NODE);
VX_CALL(vxSetParameterByIndex(node, 0, (vx_reference)src_image));
ASSERT_VX_OBJECT(parameter = vxGetParameterByIndex(node, 0), VX_TYPE_PARAMETER);
VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
ASSERT(p_image == src_image);
VX_CALL(vxReleaseImage(&p_image));
VX_CALL(vxReleaseParameter(&parameter));
{
/* check set node parameter by reference */
ASSERT_VX_OBJECT(parameter = vxGetParameterByIndex(node, 1), VX_TYPE_PARAMETER);
/* parameter was not set yet */
VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
ASSERT(p_image != dst_image);
VX_CALL(vxSetParameterByReference(parameter, (vx_reference)dst_image));
/* expect parameter is set to know value */
VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
ASSERT(p_image == dst_image);
}
VX_CALL(vxReleaseImage(&p_image));
VX_CALL(vxReleaseParameter(&parameter));
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseKernel(&kernel));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node == 0);
ASSERT(kernel == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testTwoNodesWithSameDst)
{
vx_context context = context_->vx_context_;
vx_image src1_image = 0, src2_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
ASSERT_VX_OBJECT(src1_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src1_image, dst_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxMedian3x3Node(graph, src2_image, dst_image), VX_TYPE_NODE);
EXPECT_NE_VX_STATUS(vxVerifyGraph(graph), VX_SUCCESS);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&src1_image));
VX_CALL(vxReleaseImage(&src2_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(src1_image == 0); ASSERT(src2_image == 0);
}
TEST(Graph, testCycle)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, dst_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxMedian3x3Node(graph, dst_image, src_image), VX_TYPE_NODE);
EXPECT_NE_VX_STATUS(vxVerifyGraph(graph), VX_SUCCESS);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testCycle2)
{
vx_context context = context_->vx_context_;
vx_image src1_image = 0, src2_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0, node3 = 0;
ASSERT_VX_OBJECT(src1_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxAddNode(graph, src1_image, src2_image, VX_CONVERT_POLICY_SATURATE, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxBox3x3Node(graph, interm_image, dst_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node3 = vxMedian3x3Node(graph, dst_image, src2_image), VX_TYPE_NODE);
EXPECT_NE_VX_STATUS(vxVerifyGraph(graph), VX_SUCCESS);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseNode(&node3));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&src1_image));
VX_CALL(vxReleaseImage(&src2_image));
VX_CALL(vxReleaseImage(&interm_image));
ASSERT(node1 == 0); ASSERT(node2 == 0); ASSERT(node3 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(src1_image == 0); ASSERT(src2_image == 0); ASSERT(interm_image == 0);
}
TEST(Graph, testMultipleRun)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
CT_Image res1 = 0, res2 = 0;
vx_border_t border = { VX_BORDER_UNDEFINED };
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_NO_FAILURE(ct_fill_image_random(src_image, &CT()->seed_));
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
VX_CALL(vxSetNodeAttribute(node1, VX_NODE_BORDER, &border, sizeof(border)));
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
ASSERT_NO_FAILURE(res1 = ct_image_from_vx_image(dst_image));
ASSERT_NO_FAILURE(ct_fill_image_random(dst_image, &CT()->seed_));
VX_CALL(vxProcessGraph(graph));
ASSERT_NO_FAILURE(res2 = ct_image_from_vx_image(dst_image));
ct_adjust_roi(res1, 1, 1, 1, 1);
ct_adjust_roi(res2, 1, 1, 1, 1);
ASSERT_EQ_CTIMAGE(res1, res2);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testMultipleRunAsync)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
CT_Image res1 = 0, res2 = 0;
vx_border_t border = { VX_BORDER_UNDEFINED };
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_NO_FAILURE(ct_fill_image_random(src_image, &CT()->seed_));
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
VX_CALL(vxSetNodeAttribute(node1, VX_NODE_BORDER, &border, sizeof(border)));
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxScheduleGraph(graph));
VX_CALL(vxWaitGraph(graph));
ASSERT_NO_FAILURE(res1 = ct_image_from_vx_image(dst_image));
ASSERT_NO_FAILURE(ct_fill_image_random(dst_image, &CT()->seed_));
VX_CALL(vxScheduleGraph(graph));
VX_CALL(vxWaitGraph(graph));
ASSERT_NO_FAILURE(res2 = ct_image_from_vx_image(dst_image));
ct_adjust_roi(res1, 1, 1, 1, 1);
ct_adjust_roi(res2, 1, 1, 1, 1);
ASSERT_EQ_CTIMAGE(res1, res2);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testAsyncWaitWithoutSchedule)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
ASSERT_NE_VX_STATUS(VX_SUCCESS, vxWaitGraph(graph));
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testNodePerformance)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
vx_perf_t perf;
vx_perf_t perf2;
VX_CALL(vxDirective((vx_reference)context, VX_DIRECTIVE_ENABLE_PERFORMANCE));
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxQueryNode(node1, VX_NODE_PERFORMANCE, &perf, sizeof(perf)));
ASSERT(perf.num == 1);
ASSERT(perf.beg > 0);
ASSERT(perf.min > 0);
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxQueryNode(node1, VX_NODE_PERFORMANCE, &perf2, sizeof(perf)));
ASSERT(perf2.num == 2);
ASSERT(perf2.beg > perf.end);
ASSERT(perf2.min > 0);
ASSERT(perf2.sum > perf.sum);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TEST(Graph, testGraphPerformance)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
vx_perf_t perf;
vx_perf_t perf2;
VX_CALL(vxDirective((vx_reference)context, VX_DIRECTIVE_ENABLE_PERFORMANCE));
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxQueryGraph(graph, VX_GRAPH_PERFORMANCE, &perf, sizeof(perf)));
ASSERT(perf.num == 1);
ASSERT(perf.beg > 0);
ASSERT(perf.min > 0);
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxQueryGraph(graph, VX_GRAPH_PERFORMANCE, &perf2, sizeof(perf)));
ASSERT(perf2.num == 2);
ASSERT(perf2.beg >= perf.end);
ASSERT(perf2.min > 0);
ASSERT(perf2.sum >= perf.sum);
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
typedef struct
{
char* name;
vx_enum kernel_id;
} kernel_name_arg;
TEST_WITH_ARG(Graph, testKernelName, kernel_name_arg,
ARG("org.khronos.openvx.color_convert", VX_KERNEL_COLOR_CONVERT),
ARG("org.khronos.openvx.channel_extract", VX_KERNEL_CHANNEL_EXTRACT),
ARG("org.khronos.openvx.channel_combine", VX_KERNEL_CHANNEL_COMBINE),
ARG("org.khronos.openvx.sobel_3x3", VX_KERNEL_SOBEL_3x3),
ARG("org.khronos.openvx.magnitude", VX_KERNEL_MAGNITUDE),
ARG("org.khronos.openvx.phase", VX_KERNEL_PHASE),
ARG("org.khronos.openvx.scale_image", VX_KERNEL_SCALE_IMAGE),
ARG("org.khronos.openvx.table_lookup", VX_KERNEL_TABLE_LOOKUP),
ARG("org.khronos.openvx.histogram", VX_KERNEL_HISTOGRAM),
ARG("org.khronos.openvx.equalize_histogram", VX_KERNEL_EQUALIZE_HISTOGRAM),
ARG("org.khronos.openvx.absdiff", VX_KERNEL_ABSDIFF),
ARG("org.khronos.openvx.mean_stddev", VX_KERNEL_MEAN_STDDEV),
ARG("org.khronos.openvx.threshold", VX_KERNEL_THRESHOLD),
ARG("org.khronos.openvx.integral_image", VX_KERNEL_INTEGRAL_IMAGE),
ARG("org.khronos.openvx.dilate_3x3", VX_KERNEL_DILATE_3x3),
ARG("org.khronos.openvx.erode_3x3", VX_KERNEL_ERODE_3x3),
ARG("org.khronos.openvx.median_3x3", VX_KERNEL_MEDIAN_3x3),
ARG("org.khronos.openvx.box_3x3", VX_KERNEL_BOX_3x3),
ARG("org.khronos.openvx.gaussian_3x3", VX_KERNEL_GAUSSIAN_3x3),
ARG("org.khronos.openvx.custom_convolution", VX_KERNEL_CUSTOM_CONVOLUTION),
ARG("org.khronos.openvx.gaussian_pyramid", VX_KERNEL_GAUSSIAN_PYRAMID),
ARG("org.khronos.openvx.accumulate", VX_KERNEL_ACCUMULATE),
ARG("org.khronos.openvx.accumulate_weighted", VX_KERNEL_ACCUMULATE_WEIGHTED),
ARG("org.khronos.openvx.accumulate_square", VX_KERNEL_ACCUMULATE_SQUARE),
ARG("org.khronos.openvx.minmaxloc", VX_KERNEL_MINMAXLOC),
ARG("org.khronos.openvx.convertdepth", VX_KERNEL_CONVERTDEPTH),
ARG("org.khronos.openvx.canny_edge_detector", VX_KERNEL_CANNY_EDGE_DETECTOR),
ARG("org.khronos.openvx.and", VX_KERNEL_AND),
ARG("org.khronos.openvx.or", VX_KERNEL_OR),
ARG("org.khronos.openvx.xor", VX_KERNEL_XOR),
ARG("org.khronos.openvx.not", VX_KERNEL_NOT),
ARG("org.khronos.openvx.multiply", VX_KERNEL_MULTIPLY),
ARG("org.khronos.openvx.add", VX_KERNEL_ADD),
ARG("org.khronos.openvx.subtract", VX_KERNEL_SUBTRACT),
ARG("org.khronos.openvx.warp_affine", VX_KERNEL_WARP_AFFINE),
ARG("org.khronos.openvx.warp_perspective", VX_KERNEL_WARP_PERSPECTIVE),
ARG("org.khronos.openvx.harris_corners", VX_KERNEL_HARRIS_CORNERS),
ARG("org.khronos.openvx.fast_corners", VX_KERNEL_FAST_CORNERS),
ARG("org.khronos.openvx.optical_flow_pyr_lk", VX_KERNEL_OPTICAL_FLOW_PYR_LK),
ARG("org.khronos.openvx.remap", VX_KERNEL_REMAP),
ARG("org.khronos.openvx.halfscale_gaussian", VX_KERNEL_HALFSCALE_GAUSSIAN),
ARG("org.khronos.openvx.min", VX_KERNEL_MIN),
ARG("org.khronos.openvx.max", VX_KERNEL_MAX),
)
{
vx_context context = context_->vx_context_;
vx_kernel kernel = 0;
vx_enum kernel_id = 0;
EXPECT_VX_OBJECT(kernel = vxGetKernelByName(context, arg_->name), VX_TYPE_KERNEL);
if (CT_HasFailure())
{
vx_char name[VX_MAX_KERNEL_NAME] = {0};
ASSERT_VX_OBJECT(kernel = vxGetKernelByEnum(context, arg_->kernel_id), VX_TYPE_KERNEL);
VX_CALL(vxQueryKernel(kernel, VX_KERNEL_NAME, &name, sizeof(name)));
printf("\tExpected kernel name is: %s\n", arg_->name);
printf("\tActual kernel name is: %-*s\n", VX_MAX_KERNEL_NAME, name);
}
else
{
VX_CALL(vxQueryKernel(kernel, VX_KERNEL_ENUM, &kernel_id, sizeof(kernel_id)));
EXPECT_EQ_INT(arg_->kernel_id, kernel_id);
}
VX_CALL(vxReleaseKernel(&kernel));
}
TEST(Graph, testAllocateUserKernelId)
{
vx_context context = context_->vx_context_;
vx_enum kernel_id = 0;
ASSERT_EQ_VX_STATUS(vxAllocateUserKernelId(NULL, &kernel_id), VX_ERROR_INVALID_REFERENCE);
ASSERT_NE_VX_STATUS(vxAllocateUserKernelId(context, NULL), VX_SUCCESS);
VX_CALL(vxAllocateUserKernelId(context, &kernel_id));
ASSERT(kernel_id >= VX_KERNEL_BASE(VX_ID_USER, 0));
ASSERT(kernel_id < (VX_KERNEL_BASE(VX_ID_USER, 0) + 4096));
}
TEST(Graph, testAllocateUserKernelLibraryId)
{
vx_context context = context_->vx_context_;
vx_enum library_id = 0;
ASSERT_EQ_VX_STATUS(vxAllocateUserKernelLibraryId(NULL, &library_id), VX_ERROR_INVALID_REFERENCE);
ASSERT_NE_VX_STATUS(vxAllocateUserKernelLibraryId(context, NULL), VX_SUCCESS);
VX_CALL(vxAllocateUserKernelLibraryId(context, &library_id));
ASSERT(library_id >= 1);
ASSERT(library_id <= 255);
}
void test_case_1(vx_context context, vx_uint32 width, vx_uint32 height)
{
vx_image src1 = 0;
vx_image src2 = 0;
vx_image d1 = 0;
vx_image d2 = 0;
vx_image res = 0;
vx_graph graph = 0;
vx_node N1 = 0;
vx_node N2 = 0;
vx_node node3 = 0;
vx_node node4 = 0;
vx_pixel_value_t src1_val = {{ 1 }};
vx_pixel_value_t src2_val = {{ 2 }};
vx_rectangle_t roi_rect = { width / 2, height / 2, width, height };
vx_enum convert_policy = VX_CONVERT_POLICY_SATURATE;
vx_scalar mean1 = 0;
vx_scalar stddev1 = 0;
vx_float32 mean_val1 = 0.0f;
vx_float32 stddev_val1 = 0.0f;
vx_scalar mean2 = 0;
vx_scalar stddev2 = 0;
vx_float32 mean_val2 = 0.0f;
vx_float32 stddev_val2 = 0.0f;
ASSERT_VX_OBJECT(src1 = vxCreateUniformImage(context, width, height, VX_DF_IMAGE_U8, &src1_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxCreateUniformImage(context, width, height, VX_DF_IMAGE_U8, &src2_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(d1 = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(d2 = vxCreateImageFromROI(d1, &roi_rect), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(res = vxCreateImage(context, width / 2, height / 2, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(mean1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(mean2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
/* add nodes in arbitrary order */
ASSERT_VX_OBJECT(node3 = vxMeanStdDevNode(graph, res, mean1, stddev1), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N2 = vxNotNode(graph, d2, res), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node4 = vxMeanStdDevNode(graph, d1, mean2, stddev2), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N1 = vxAddNode(graph, src1, src2, convert_policy, d1), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxCopyScalar(mean1, &mean_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev1, &stddev_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(mean2, &mean_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev2, &stddev_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
EXPECT_EQ_INT((vx_uint8)( ~(src1_val.U8 + src2_val.U8) ), (vx_uint8)mean_val1);
EXPECT_EQ_INT((vx_uint8)((src1_val.U8 + src2_val.U8)), (vx_uint8)mean_val2);
VX_CALL(vxReleaseNode(&N1));
VX_CALL(vxReleaseNode(&N2));
VX_CALL(vxReleaseNode(&node3));
VX_CALL(vxReleaseNode(&node4));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&d1));
VX_CALL(vxReleaseImage(&d2));
VX_CALL(vxReleaseImage(&res));
VX_CALL(vxReleaseScalar(&mean1));
VX_CALL(vxReleaseScalar(&stddev1));
VX_CALL(vxReleaseScalar(&mean2));
VX_CALL(vxReleaseScalar(&stddev2));
ASSERT(N1 == 0);
ASSERT(N2 == 0);
ASSERT(node3 == 0);
ASSERT(node4 == 0);
ASSERT(graph == 0);
ASSERT(src1 == 0);
ASSERT(src2 == 0);
ASSERT(d1 == 0);
ASSERT(d2 == 0);
ASSERT(res == 0);
ASSERT(mean1 == 0);
ASSERT(stddev1 == 0);
ASSERT(mean2 == 0);
ASSERT(stddev2 == 0);
return;
}
void test_case_2(vx_context context, vx_uint32 width, vx_uint32 height)
{
vx_image d2 = 0;
vx_image src1 = 0;
vx_image src2 = 0;
vx_image d1 = 0;
vx_image res = 0;
vx_graph graph = 0;
vx_node N1 = 0;
vx_node N2 = 0;
vx_node node3 = 0;
vx_node node4 = 0;
vx_pixel_value_t d2_val = {{ 1 }};
vx_pixel_value_t src1_val = {{ 2 }};
vx_pixel_value_t src2_val = {{ 3 }};
vx_rectangle_t img_rect = { 0, 0, width, height };
vx_rectangle_t roi_rect = { width / 2, height / 2, width, height };
vx_imagepatch_addressing_t addr = { 0 };
vx_uint8* base_ptr = NULL;
vx_enum convert_policy = VX_CONVERT_POLICY_SATURATE;
vx_scalar mean1 = 0;
vx_scalar stddev1 = 0;
vx_float32 mean_val1 = 0.0f;
vx_float32 stddev_val1 = 0.0f;
vx_scalar mean2 = 0;
vx_scalar stddev2 = 0;
vx_float32 mean_val2 = 0.0f;
vx_float32 stddev_val2 = 0.0f;
vx_map_id map_id;
vx_uint32 x, y;
ASSERT_VX_OBJECT(mean1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(mean2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(d2 = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
VX_CALL(vxMapImagePatch(d2, &img_rect, 0, &map_id, &addr, (void**)&base_ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for ( y = 0; y < addr.dim_y; y += addr.step_y)
{
for ( x = 0; x < addr.dim_x; x += addr.step_x)
{
vx_uint8* ptr = vxFormatImagePatchAddress2d(base_ptr, x, y, &addr);
*ptr = d2_val.U8;
}
}
VX_CALL(vxUnmapImagePatch(d2, map_id));
ASSERT_VX_OBJECT(d1 = vxCreateImageFromROI(d2, &roi_rect), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src1 = vxCreateUniformImage(context, width / 2, height / 2, VX_DF_IMAGE_U8, &src1_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxCreateUniformImage(context, width / 2, height / 2, VX_DF_IMAGE_U8, &src2_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(res = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
/* add nodes in arbitrary order */
ASSERT_VX_OBJECT(node3 = vxMeanStdDevNode(graph, d1, mean2, stddev2), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N2 = vxMeanStdDevNode(graph, res, mean1, stddev1), VX_TYPE_NODE);
ASSERT_VX_OBJECT(node4 = vxNotNode(graph, d2, res), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N1 = vxAddNode(graph, src1, src2, convert_policy, d1), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxCopyScalar(mean1, &mean_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev1, &stddev_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(mean2, &mean_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev2, &stddev_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
EXPECT_EQ_INT((vx_uint8)(~(src1_val.U8 + src2_val.U8) / 2), (vx_uint8)mean_val1);
EXPECT_EQ_INT((vx_uint8)((src1_val.U8 + src2_val.U8)), (vx_uint8)mean_val2);
VX_CALL(vxReleaseNode(&N1));
VX_CALL(vxReleaseNode(&N2));
VX_CALL(vxReleaseNode(&node3));
VX_CALL(vxReleaseNode(&node4));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&d1));
VX_CALL(vxReleaseImage(&d2));
VX_CALL(vxReleaseImage(&res));
VX_CALL(vxReleaseScalar(&mean1));
VX_CALL(vxReleaseScalar(&stddev1));
VX_CALL(vxReleaseScalar(&mean2));
VX_CALL(vxReleaseScalar(&stddev2));
ASSERT(N1 == 0);
ASSERT(N2 == 0);
ASSERT(node3 == 0);
ASSERT(node4 == 0);
ASSERT(graph == 0);
ASSERT(src1 == 0);
ASSERT(src2 == 0);
ASSERT(d1 == 0);
ASSERT(d2 == 0);
ASSERT(res == 0);
ASSERT(mean1 == 0);
ASSERT(stddev1 == 0);
ASSERT(mean2 == 0);
ASSERT(stddev2 == 0);
return;
}
void test_case_3(vx_context context, vx_uint32 width, vx_uint32 height)
{
vx_image image = 0;
vx_image src1 = 0;
vx_image src2 = 0;
vx_image d1 = 0;
vx_image d2 = 0;
vx_graph graph = 0;
vx_node N1 = 0;
vx_node N2 = 0;
vx_node node = 0;
vx_pixel_value_t val = {{ 1 }};
vx_pixel_value_t src1_val = {{ 2 }};
vx_pixel_value_t src2_val = {{ 3 }};
vx_rectangle_t img_rect = { 0, 0, width, height };
vx_rectangle_t roi_rect1 = { width / 2, height / 2, width, height };
vx_rectangle_t roi_rect2 = { 0, height / 2, width, height };
vx_imagepatch_addressing_t addr = { 0 };
vx_uint8* base_ptr = NULL;
vx_enum convert_policy = VX_CONVERT_POLICY_SATURATE;
vx_scalar mean1 = 0;
vx_scalar stddev1 = 0;
vx_float32 mean_val1 = 0.0f;
vx_float32 stddev_val1 = 0.0f;
vx_scalar mean2 = 0;
vx_scalar stddev2 = 0;
vx_float32 mean_val2 = 0.0f;
vx_float32 stddev_val2 = 0.0f;
vx_map_id map_id;
vx_uint32 x, y;
ASSERT_VX_OBJECT(image = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
VX_CALL(vxMapImagePatch(image, &img_rect, 0, &map_id, &addr, (void**)&base_ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for ( y = 0; y < addr.dim_y; y += addr.step_y)
{
for ( x = 0; x < addr.dim_x; x += addr.step_x)
{
vx_uint8* ptr = vxFormatImagePatchAddress2d(base_ptr, x, y, &addr);
*ptr = val.U8;
}
}
VX_CALL(vxUnmapImagePatch(image, map_id));
ASSERT_VX_OBJECT(src1 = vxCreateUniformImage(context, width / 2, height / 2, VX_DF_IMAGE_U8, &src1_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxCreateUniformImage(context, width / 2, height / 2, VX_DF_IMAGE_U8, &src2_val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(d1 = vxCreateImageFromROI(image, &roi_rect1), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(d2 = vxCreateImageFromROI(image, &roi_rect2), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(mean1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(mean2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev2 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val2), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
/* add nodes in arbitrary order */
ASSERT_VX_OBJECT(node = vxMeanStdDevNode(graph, d1, mean2, stddev2), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N2 = vxMeanStdDevNode(graph, d2, mean1, stddev1), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N1 = vxAddNode(graph, src1, src2, convert_policy, d1), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxCopyScalar(mean1, &mean_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev1, &stddev_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(mean2, &mean_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev2, &stddev_val2, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
EXPECT_EQ_INT((vx_uint8)((val.U8 + src1_val.U8 + src2_val.U8) / 2), (vx_uint8)mean_val1);
EXPECT_EQ_INT((vx_uint8)((src1_val.U8 + src2_val.U8)), (vx_uint8)mean_val2);
VX_CALL(vxReleaseNode(&N1));
VX_CALL(vxReleaseNode(&N2));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&image));
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&d1));
VX_CALL(vxReleaseImage(&d2));
VX_CALL(vxReleaseScalar(&mean1));
VX_CALL(vxReleaseScalar(&stddev1));
VX_CALL(vxReleaseScalar(&mean2));
VX_CALL(vxReleaseScalar(&stddev2));
ASSERT(N1 == 0);
ASSERT(N2 == 0);
ASSERT(node == 0);
ASSERT(graph == 0);
ASSERT(image == 0);
ASSERT(src1 == 0);
ASSERT(src2 == 0);
ASSERT(d1 == 0);
ASSERT(d2 == 0);
ASSERT(mean1 == 0);
ASSERT(stddev1 == 0);
ASSERT(mean2 == 0);
ASSERT(stddev2 == 0);
return;
}
void test_case_4(vx_context context, vx_uint32 width, vx_uint32 height)
{
vx_image image = 0;
vx_pyramid d1 = 0;
vx_image d2 = 0;
vx_graph graph = 0;
vx_node N1 = 0;
vx_node N2 = 0;
vx_pixel_value_t val = {{ 5 }};
vx_size levels = 3;
vx_float32 scale = VX_SCALE_PYRAMID_HALF;
vx_scalar mean1 = 0;
vx_scalar stddev1 = 0;
vx_float32 mean_val1 = 0.0f;
vx_float32 stddev_val1 = 0.0f;
ASSERT_VX_OBJECT(image = vxCreateUniformImage(context, width, height, VX_DF_IMAGE_U8, &val), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(d1 = vxCreatePyramid(context, levels, scale, width, height, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(d2 = vxGetPyramidLevel(d1, 0), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(mean1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &mean_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(stddev1 = vxCreateScalar(context, VX_TYPE_FLOAT32, &stddev_val1), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
/* add nodes in arbitrary order */
ASSERT_VX_OBJECT(N2 = vxMeanStdDevNode(graph, d2, mean1, stddev1), VX_TYPE_NODE);
ASSERT_VX_OBJECT(N1 = vxGaussianPyramidNode(graph, image, d1), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxCopyScalar(mean1, &mean_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
VX_CALL(vxCopyScalar(stddev1, &stddev_val1, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
EXPECT_EQ_INT(val.U8, (vx_uint8)mean_val1);
VX_CALL(vxReleaseNode(&N1));
VX_CALL(vxReleaseNode(&N2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&image));
VX_CALL(vxReleasePyramid(&d1));
VX_CALL(vxReleaseImage(&d2));
VX_CALL(vxReleaseScalar(&mean1));
VX_CALL(vxReleaseScalar(&stddev1));
ASSERT(N1 == 0);
ASSERT(N2 == 0);
ASSERT(graph == 0);
ASSERT(image == 0);
ASSERT(d1 == 0);
ASSERT(d2 == 0);
ASSERT(mean1 == 0);
ASSERT(stddev1 == 0);
return;
}
TEST(Graph, testImageContainmentRelationship)
{
vx_context context = context_->vx_context_;
vx_uint32 width = 128;
vx_uint32 height = 128;
test_case_1(context, width, height);
test_case_2(context, width, height);
test_case_3(context, width, height);
test_case_4(context, width, height);
}
/* test replicate node */
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;
}
typedef enum
{
ADD = 0,
SUB,
MUL,
LUT
} OWN_OPERATION_TYPE;
typedef struct
{
const char* testName;
CT_Image(*generator)(const char* fileName, int width, int height);
const char* fileName;
int width;
int height;
vx_size levels;
vx_float32 scale;
vx_df_image format;
OWN_OPERATION_TYPE op;
} Test_Replicate_Arg;
#define ADD_SIZE_SET(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/sz=256x256", __VA_ARGS__, 256, 256)), \
CT_EXPAND(nextmacro(testArgName "/sz=640x480", __VA_ARGS__, 640, 480))
#define ADD_VX_LEVELS(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/REPLICAS=3", __VA_ARGS__, 3)), \
CT_EXPAND(nextmacro(testArgName "/REPLICAS=4", __VA_ARGS__, 4))
#define ADD_VX_SCALE(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/PYRAMID:SCALE_HALF", __VA_ARGS__, VX_SCALE_PYRAMID_HALF)), \
CT_EXPAND(nextmacro(testArgName "/PYRAMID:SCALE_ORB", __VA_ARGS__, VX_SCALE_PYRAMID_ORB)), \
CT_EXPAND(nextmacro(testArgName "/OBJECT_ARRAY", __VA_ARGS__, -1))
#define ADD_VX_FORMAT(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/VX_DF_IMAGE_U8", __VA_ARGS__, VX_DF_IMAGE_U8))
#define ADD_VX_OPERATION(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/Add", __VA_ARGS__, ADD)), \
CT_EXPAND(nextmacro(testArgName "/Sub", __VA_ARGS__, SUB)), \
CT_EXPAND(nextmacro(testArgName "/Mul", __VA_ARGS__, MUL)), \
CT_EXPAND(nextmacro(testArgName "/LUT", __VA_ARGS__, LUT))
#define TEST_REPLICATE_PARAMETERS \
CT_GENERATE_PARAMETERS("random", ADD_SIZE_SET, ADD_VX_LEVELS, ADD_VX_SCALE, ADD_VX_FORMAT, ADD_VX_OPERATION, ARG, own_generate_random, NULL)
static void ref_replicate_op(vx_context context, vx_reference input1, vx_reference input2, vx_reference output, OWN_OPERATION_TYPE op)
{
vx_uint32 i, k;
vx_size levels = 0;
vx_enum type = VX_TYPE_INVALID;
VX_CALL(vxQueryReference(input1, VX_REFERENCE_TYPE, &type, sizeof(type)));
if (type == VX_TYPE_PYRAMID)
{
VX_CALL(vxQueryPyramid((vx_pyramid)input1, VX_PYRAMID_LEVELS, &levels, sizeof(vx_size)));
// add, sub, mul, lut
for (k = 0; k < levels; k++)
{
vx_image src1 = 0;
vx_image src2 = 0;
vx_image dst = 0;
vx_enum policy = VX_CONVERT_POLICY_SATURATE;
vx_float32 scale_val = 1.0f;
vx_enum rounding = VX_ROUND_POLICY_TO_ZERO;
ASSERT_VX_OBJECT(src1 = vxGetPyramidLevel((vx_pyramid)input1, k), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxGetPyramidLevel((vx_pyramid)input2, k), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxGetPyramidLevel((vx_pyramid)output, k), VX_TYPE_IMAGE);
switch (op)
{
case ADD:
VX_CALL(vxuAdd(context, src1, src2, policy, dst));
break;
case SUB:
VX_CALL(vxuSubtract(context, src1, src2, policy, dst));
break;
case MUL:
VX_CALL(vxuMultiply(context, src1, src2, scale_val, policy, rounding, dst));
break;
case LUT:
{
vx_lut lut = 0;
vx_uint8* data = 0;
vx_map_id map_id;
ASSERT_VX_OBJECT(lut = vxCreateLUT(context, VX_TYPE_UINT8, 256), VX_TYPE_LUT);
VX_CALL(vxMapLUT(lut, &map_id, (void **)&data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for (i = 0; i < 256; i++)
data[i] = 255 - i;
VX_CALL(vxUnmapLUT(lut, map_id));
VX_CALL(vxuTableLookup(context, src1, lut, dst));
VX_CALL(vxReleaseLUT(&lut));
break;
}
default:
ASSERT(0);
}
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&dst));
}
}
else if (type == VX_TYPE_OBJECT_ARRAY)
{
VX_CALL(vxQueryObjectArray((vx_object_array)input1, VX_OBJECT_ARRAY_NUMITEMS, &levels, sizeof(vx_size)));
// add, sub, mul, lut
for (k = 0; k < levels; k++)
{
vx_image src1 = 0;
vx_image src2 = 0;
vx_image dst = 0;
vx_enum policy = VX_CONVERT_POLICY_SATURATE;
vx_float32 scale_val = 1.0f;
vx_enum rounding = VX_ROUND_POLICY_TO_ZERO;
ASSERT_VX_OBJECT(src1 = (vx_image)vxGetObjectArrayItem((vx_object_array)input1, k), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = (vx_image)vxGetObjectArrayItem((vx_object_array)input2, k), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = (vx_image)vxGetObjectArrayItem((vx_object_array)output, k), VX_TYPE_IMAGE);
switch (op)
{
case ADD:
VX_CALL(vxuAdd(context, src1, src2, policy, dst));
break;
case SUB:
VX_CALL(vxuSubtract(context, src1, src2, policy, dst));
break;
case MUL:
VX_CALL(vxuMultiply(context, src1, src2, scale_val, policy, rounding, dst));
break;
case LUT:
{
vx_lut lut = 0;
vx_uint8* data = 0;
vx_map_id map_id;
ASSERT_VX_OBJECT(lut = vxCreateLUT(context, VX_TYPE_UINT8, 256), VX_TYPE_LUT);
VX_CALL(vxMapLUT(lut, &map_id, (void **)&data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for (i = 0; i < 256; i++)
data[i] = 255 - i - k;
VX_CALL(vxUnmapLUT(lut, map_id));
VX_CALL(vxuTableLookup(context, src1, lut, dst));
VX_CALL(vxReleaseLUT(&lut));
break;
}
default:
ASSERT(0);
}
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&dst));
}
}
else
ASSERT(0);
return;
}
static void tst_replicate_op(vx_context context, vx_reference input1, vx_reference input2, vx_reference output, OWN_OPERATION_TYPE op)
{
vx_graph graph = 0;
vx_node node = 0;
vx_object_array object_array = 0;
vx_image src1 = 0;
vx_image src2 = 0;
vx_image dst = 0;
vx_enum policy = VX_CONVERT_POLICY_SATURATE;
vx_float32 scale_val = 1.0f;
vx_scalar scale = 0;
vx_enum rounding = VX_ROUND_POLICY_TO_ZERO;
vx_size levels = 0;
vx_enum type = VX_TYPE_INVALID;
VX_CALL(vxQueryReference(input1, VX_REFERENCE_TYPE, &type, sizeof(type)));
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
if (type == VX_TYPE_PYRAMID)
{
ASSERT_VX_OBJECT(src1 = vxGetPyramidLevel((vx_pyramid)input1, 0), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxGetPyramidLevel((vx_pyramid)input2, 0), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxGetPyramidLevel((vx_pyramid)output, 0), VX_TYPE_IMAGE);
VX_CALL(vxQueryPyramid((vx_pyramid)input1, VX_PYRAMID_LEVELS, &levels, sizeof(levels)));
// add, sub, mul, lut
switch (op)
{
case ADD:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(node = vxAddNode(graph, src1, src2, policy, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 4));
break;
}
case SUB:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(node = vxSubtractNode(graph, src1, src2, policy, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 4));
break;
}
case MUL:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_false_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &scale_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(node = vxMultiplyNode(graph, src1, src2, scale, policy, rounding, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 6));
VX_CALL(vxReleaseScalar(&scale));
break;
}
case LUT:
{
vx_uint32 i;
vx_lut lut = 0;
vx_uint8* data = 0;
vx_bool replicate[] = { vx_true_e, vx_false_e, vx_true_e };
vx_map_id map_id;
ASSERT_VX_OBJECT(lut = vxCreateLUT(context, VX_TYPE_UINT8, 256), VX_TYPE_LUT);
VX_CALL(vxMapLUT(lut, &map_id, (void **)&data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for (i = 0; i < 256; i++)
data[i] = 255 - i;
VX_CALL(vxUnmapLUT(lut, map_id));
ASSERT_VX_OBJECT(node = vxTableLookupNode(graph, src1, lut, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 3));
VX_CALL(vxReleaseLUT(&lut));
break;
}
default:
ASSERT(0);
}
}
else if (type == VX_TYPE_OBJECT_ARRAY)
{
ASSERT_VX_OBJECT(src1 = (vx_image)vxGetObjectArrayItem((vx_object_array)input1, 0), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = (vx_image)vxGetObjectArrayItem((vx_object_array)input2, 0), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = (vx_image)vxGetObjectArrayItem((vx_object_array)output, 0), VX_TYPE_IMAGE);
VX_CALL(vxQueryObjectArray((vx_object_array)input1, VX_OBJECT_ARRAY_NUMITEMS, &levels, sizeof(levels)));
// add, sub, mul, lut
switch (op)
{
case ADD:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(node = vxAddNode(graph, src1, src2, policy, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 4));
break;
}
case SUB:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(node = vxSubtractNode(graph, src1, src2, policy, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 4));
break;
}
case MUL:
{
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_false_e, vx_false_e, vx_false_e, vx_true_e };
ASSERT_VX_OBJECT(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &scale_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(node = vxMultiplyNode(graph, src1, src2, scale, policy, rounding, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 6));
VX_CALL(vxReleaseScalar(&scale));
break;
}
case LUT:
{
vx_uint32 i, k;
vx_lut lut = 0;
vx_uint8* data = 0;
vx_bool replicate[] = { vx_true_e, vx_true_e, vx_true_e };
vx_map_id map_id;
ASSERT_VX_OBJECT(lut = vxCreateLUT(context, VX_TYPE_UINT8, 256), VX_TYPE_LUT);
ASSERT_VX_OBJECT(object_array = vxCreateObjectArray(context, (vx_reference)lut, levels), VX_TYPE_OBJECT_ARRAY);
VX_CALL(vxReleaseLUT(&lut));
for (k = 0; k < levels; ++k)
{
ASSERT_VX_OBJECT(lut = (vx_lut)vxGetObjectArrayItem(object_array, k), VX_TYPE_LUT);
VX_CALL(vxMapLUT(lut, &map_id, (void **)&data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
for (i = 0; i < 256; i++)
data[i] = 255 - i - k;
VX_CALL(vxUnmapLUT(lut, map_id));
VX_CALL(vxReleaseLUT(&lut));
}
ASSERT_VX_OBJECT(lut = (vx_lut)vxGetObjectArrayItem(object_array, 0), VX_TYPE_LUT);
ASSERT_VX_OBJECT(node = vxTableLookupNode(graph, src1, lut, dst), VX_TYPE_NODE);
VX_CALL(vxReplicateNode(graph, node, replicate, 3));
VX_CALL(vxReleaseLUT(&lut));
break;
}
default:
ASSERT(0);
}
}
else
ASSERT(0);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxProcessGraph(graph));
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
VX_CALL(vxReleaseImage(&dst));
if (object_array)
VX_CALL(vxReleaseObjectArray(&object_array));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
return;
}
static void check_replicas(vx_reference ref, vx_reference tst, vx_border_t border)
{
vx_uint32 i;
vx_size ref_levels = 0;
vx_size tst_levels = 0;
vx_enum type = VX_TYPE_INVALID;
VX_CALL(vxQueryReference(ref, VX_REFERENCE_TYPE, &type, sizeof(type)));
if (type == VX_TYPE_PYRAMID)
{
vx_float32 scale;
VX_CALL(vxQueryPyramid((vx_pyramid)ref, VX_PYRAMID_SCALE, &scale, sizeof(scale)));
VX_CALL(vxQueryPyramid((vx_pyramid)ref, VX_PYRAMID_LEVELS, &ref_levels, sizeof(vx_size)));
VX_CALL(vxQueryPyramid((vx_pyramid)tst, VX_PYRAMID_LEVELS, &tst_levels, sizeof(vx_size)));
EXPECT_EQ_INT(ref_levels, tst_levels);
for (i = 0; i < ref_levels; i++)
{
vx_image src1 = 0;
vx_image src2 = 0;
CT_Image img1 = 0;
CT_Image img2 = 0;
ASSERT_VX_OBJECT(src1 = vxGetPyramidLevel((vx_pyramid)ref, i), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = vxGetPyramidLevel((vx_pyramid)tst, i), VX_TYPE_IMAGE);
ASSERT_NO_FAILURE(img1 = ct_image_from_vx_image(src1));
ASSERT_NO_FAILURE(img2 = ct_image_from_vx_image(src2));
if (VX_BORDER_UNDEFINED == border.mode)
{
if (i > 0)
{
if (VX_SCALE_PYRAMID_ORB == scale)
{
ct_adjust_roi(img1, 2, 2, 2, 2);
ct_adjust_roi(img2, 2, 2, 2, 2);
}
else if (VX_SCALE_PYRAMID_HALF == scale)
{
ct_adjust_roi(img1, 1, 1, 1, 1);
ct_adjust_roi(img2, 1, 1, 1, 1);
}
}
}
EXPECT_EQ_CTIMAGE(img1, img2);
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
}
}
else if (type == VX_TYPE_OBJECT_ARRAY)
{
VX_CALL(vxQueryObjectArray((vx_object_array)ref, VX_OBJECT_ARRAY_NUMITEMS, &ref_levels, sizeof(vx_size)));
VX_CALL(vxQueryObjectArray((vx_object_array)tst, VX_OBJECT_ARRAY_NUMITEMS, &tst_levels, sizeof(vx_size)));
EXPECT_EQ_INT(ref_levels, tst_levels);
for (i = 0; i < ref_levels; i++)
{
vx_image src1 = 0;
vx_image src2 = 0;
CT_Image img1 = 0;
CT_Image img2 = 0;
ASSERT_VX_OBJECT(src1 = (vx_image)vxGetObjectArrayItem((vx_object_array)ref, i), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src2 = (vx_image)vxGetObjectArrayItem((vx_object_array)tst, i), VX_TYPE_IMAGE);
ASSERT_NO_FAILURE(img1 = ct_image_from_vx_image(src1));
ASSERT_NO_FAILURE(img2 = ct_image_from_vx_image(src2));
EXPECT_EQ_CTIMAGE(img1, img2);
VX_CALL(vxReleaseImage(&src1));
VX_CALL(vxReleaseImage(&src2));
}
}
else
ASSERT(0);
return;
}
TEST_WITH_ARG(Graph, testReplicateNode, Test_Replicate_Arg, TEST_REPLICATE_PARAMETERS)
{
vx_context context = context_->vx_context_;
CT_Image src = 0;
vx_reference src1 = 0;
vx_reference src2 = 0;
vx_reference ref = 0;
vx_reference tst = 0;
vx_image input1 = 0;
vx_image input2 = 0;
vx_pixel_value_t value = {{ 2 }};
vx_border_t border;
ASSERT_NO_FAILURE(src = arg_->generator(arg_->fileName, arg_->width, arg_->height));
if (arg_->scale < 0)
{
vx_size i;
ASSERT_VX_OBJECT(input1 = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src1 = (vx_reference)vxCreateObjectArray(context, (vx_reference)input1, arg_->levels), VX_TYPE_OBJECT_ARRAY);
ASSERT_VX_OBJECT(src2 = (vx_reference)vxCreateObjectArray(context, (vx_reference)input1, arg_->levels), VX_TYPE_OBJECT_ARRAY);
ASSERT_VX_OBJECT(ref = (vx_reference)vxCreateObjectArray(context, (vx_reference)input1, arg_->levels), VX_TYPE_OBJECT_ARRAY);
ASSERT_VX_OBJECT(tst = (vx_reference)vxCreateObjectArray(context, (vx_reference)input1, arg_->levels), VX_TYPE_OBJECT_ARRAY);
/* Initialize array items */
for (i = 0; i < arg_->levels; ++i)
{
vx_image item = 0;
value.U8 = (vx_uint8)i;
ASSERT_VX_OBJECT(input2 = vxCreateUniformImage(context, arg_->width, arg_->height, arg_->format, &value), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(item = (vx_image)vxGetObjectArrayItem((vx_object_array)src1, (vx_uint32)i), VX_TYPE_IMAGE);
VX_CALL(vxuAdd(context, input1, input2, VX_CONVERT_POLICY_WRAP, item));
VX_CALL(vxReleaseImage(&item));
VX_CALL(vxReleaseImage(&input2));
}
VX_CALL(vxReleaseImage(&input1));
}
else
{
ASSERT_VX_OBJECT(input1 = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(input2 = vxCreateUniformImage(context, arg_->width, arg_->height, arg_->format, &value), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(src1 = (vx_reference)vxCreatePyramid(context, arg_->levels, arg_->scale, arg_->width, arg_->height, arg_->format), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(src2 = (vx_reference)vxCreatePyramid(context, arg_->levels, arg_->scale, arg_->width, arg_->height, arg_->format), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(ref = (vx_reference)vxCreatePyramid(context, arg_->levels, arg_->scale, arg_->width, arg_->height, arg_->format), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(tst = (vx_reference)vxCreatePyramid(context, arg_->levels, arg_->scale, arg_->width, arg_->height, arg_->format), VX_TYPE_PYRAMID);
/* Initialize pyramids */
VX_CALL(vxuGaussianPyramid(context, input1, (vx_pyramid)src1));
VX_CALL(vxuGaussianPyramid(context, input2, (vx_pyramid)src2));
VX_CALL(vxReleaseImage(&input1));
VX_CALL(vxReleaseImage(&input2));
}
ref_replicate_op(context, src1, src2, ref, arg_->op);
tst_replicate_op(context, src1, src2, tst, arg_->op);
VX_CALL(vxQueryContext(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border)));
check_replicas(ref, tst, border);
VX_CALL(vxReleaseReference(&src1));
VX_CALL(vxReleaseReference(&src2));
VX_CALL(vxReleaseReference(&ref));
VX_CALL(vxReleaseReference(&tst));
}
static void test_halfscalegaussian(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
{
int count;
vx_image src = 0;
vx_image dst = 0;
vx_graph graph = 0;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreateImage(context, 160, 120, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxHalfScaleGaussianNode(graph, src, dst, 3), VX_TYPE_NODE);
for (count = 0; count < 2; count++)
{
VX_CALL(vxVerifyGraph(graph));
}
VX_CALL(vxReleaseImage(&src));
VX_CALL(vxReleaseImage(&dst));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
nrefs_dangling = nrefs_after - nrefs_before;
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_cannyedgedetector(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
vx_uint32 nkernels_before = 0;
vx_uint32 nkernels_after = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_before, sizeof(nkernels_before)));
{
vx_image src = 0;
vx_image dst = 0;
vx_graph graph = 0;
vx_threshold threshold = 0;
vx_int32 val1 = 16;
vx_int32 val2 = 32;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(threshold = vxCreateThreshold(context, VX_THRESHOLD_TYPE_RANGE, VX_TYPE_UINT8), VX_TYPE_THRESHOLD);
VX_CALL(vxSetThresholdAttribute(threshold, VX_THRESHOLD_THRESHOLD_LOWER, &val1, sizeof(val1)));
VX_CALL(vxSetThresholdAttribute(threshold, VX_THRESHOLD_THRESHOLD_UPPER, &val2, sizeof(val2)));
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxCannyEdgeDetectorNode(graph, src, threshold, 3, VX_NORM_L1, dst), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxReleaseImage(&src));
VX_CALL(vxReleaseImage(&dst));
VX_CALL(vxReleaseThreshold(&threshold));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_after, sizeof(nkernels_after)));
nrefs_dangling = nrefs_after - nrefs_before;
if(nkernels_after != nkernels_before)
nrefs_dangling -= (nkernels_after - nkernels_before);
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_harriscorners(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
vx_uint32 nkernels_before = 0;
vx_uint32 nkernels_after = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_before, sizeof(nkernels_before)));
{
vx_image src = 0;
vx_array dst = 0;
vx_graph graph = 0;
vx_size capacity = 1000;
vx_scalar strength = 0;
vx_float32 strength_val = 0.5f;
vx_scalar min_distance = 0;
vx_float32 min_distance_val = 0.5f;
vx_scalar sensitivity = 0;
vx_float32 sensitivity_val = 0.1f;
vx_scalar num_corners = 0;
vx_size num_corners_val = 10;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreateArray(context, VX_TYPE_KEYPOINT, capacity), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(strength = vxCreateScalar(context, VX_TYPE_FLOAT32, &strength_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(min_distance = vxCreateScalar(context, VX_TYPE_FLOAT32, &min_distance_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(sensitivity = vxCreateScalar(context, VX_TYPE_FLOAT32, &sensitivity_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(num_corners = vxCreateScalar(context, VX_TYPE_SIZE, &num_corners_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxHarrisCornersNode(graph, src, strength, min_distance, sensitivity, 3, 3, dst, num_corners), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxReleaseImage(&src));
VX_CALL(vxReleaseArray(&dst));
VX_CALL(vxReleaseScalar(&strength));
VX_CALL(vxReleaseScalar(&min_distance));
VX_CALL(vxReleaseScalar(&sensitivity));
VX_CALL(vxReleaseScalar(&num_corners));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_after, sizeof(nkernels_after)));
nrefs_dangling = nrefs_after - nrefs_before;
if (nkernels_after != nkernels_before)
nrefs_dangling -= (nkernels_after - nkernels_before);
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_gaussianpyramid(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
vx_uint32 nkernels_before = 0;
vx_uint32 nkernels_after = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_before, sizeof(nkernels_before)));
{
vx_image src = 0;
vx_pyramid dst = 0;
vx_size levels = 2;
vx_float32 scale = VX_SCALE_PYRAMID_HALF;
vx_graph graph = 0;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreatePyramid(context, levels, scale, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxGaussianPyramidNode(graph, src, dst), VX_TYPE_NODE);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxReleaseImage(&src));
VX_CALL(vxReleasePyramid(&dst));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_after, sizeof(nkernels_after)));
nrefs_dangling = nrefs_after - nrefs_before;
if (nkernels_after != nkernels_before)
nrefs_dangling -= (nkernels_after - nkernels_before);
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_laplacianpyramid(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
vx_uint32 nkernels_before = 0;
vx_uint32 nkernels_after = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_before, sizeof(nkernels_before)));
{
int count;
vx_image src = 0;
vx_image out = 0;
vx_pyramid dst = 0;
vx_size levels = 2;
vx_float32 scale = VX_SCALE_PYRAMID_HALF;
vx_graph graph = 0;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(out = vxCreateImage(context, 80, 60, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreatePyramid(context, levels, scale, 320, 240, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxLaplacianPyramidNode(graph, src, dst, out), VX_TYPE_NODE);
for (count = 0; count < 2; count++)
{
VX_CALL(vxVerifyGraph(graph));
}
VX_CALL(vxReleaseImage(&src));
VX_CALL(vxReleaseImage(&out));
VX_CALL(vxReleasePyramid(&dst));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_after, sizeof(nkernels_after)));
nrefs_dangling = nrefs_after - nrefs_before;
if (nkernels_after != nkernels_before)
nrefs_dangling -= (nkernels_after - nkernels_before);
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_laplacianreconstruct(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
vx_uint32 nkernels_before = 0;
vx_uint32 nkernels_after = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_before, sizeof(nkernels_before)));
{
int count;
vx_pyramid src = 0;
vx_image in = 0;
vx_image dst = 0;
vx_size levels = 2;
vx_float32 scale = VX_SCALE_PYRAMID_HALF;
vx_graph graph = 0;
vx_node node = 0;
ASSERT_VX_OBJECT(src = vxCreatePyramid(context, levels, scale, 320, 240, VX_DF_IMAGE_S16), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(in = vxCreateImage(context, 80, 60, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxLaplacianReconstructNode(graph, src, in, dst), VX_TYPE_NODE);
for (count = 0; count < 2; count++)
{
VX_CALL(vxVerifyGraph(graph));
}
VX_CALL(vxReleasePyramid(&src));
VX_CALL(vxReleaseImage(&in));
VX_CALL(vxReleaseImage(&dst));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
VX_CALL(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &nkernels_after, sizeof(nkernels_after)));
nrefs_dangling = nrefs_after - nrefs_before;
if (nkernels_after != nkernels_before)
nrefs_dangling -= (nkernels_after - nkernels_before);
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
static void test_opticalflowpyrlk(vx_context context)
{
vx_uint32 nrefs_before = 0;
vx_uint32 nrefs_after = 0;
vx_uint32 nrefs_dangling = 0;
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_before, sizeof(nrefs_before)));
{
int count;
vx_size levels = 2;
vx_float32 scale = VX_SCALE_PYRAMID_HALF;
vx_pyramid old_images = 0;
vx_pyramid new_images = 0;
vx_size capacity = 1000;
vx_array old_points = 0;
vx_array new_points_estimates = 0;
vx_array new_points = 0;
vx_graph graph = 0;
vx_scalar epsilon = 0;
vx_float32 epsilon_val = 0.5f;
vx_scalar num_iter = 0;
vx_uint32 num_iter_val = 5;
vx_scalar use_initial_estimate = 0;
vx_bool use_initial_estimate_val = vx_true_e;
vx_size window_dims = 10;
vx_node node = 0;
ASSERT_VX_OBJECT(old_images = vxCreatePyramid(context, levels, scale, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(new_images = vxCreatePyramid(context, levels, scale, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);
ASSERT_VX_OBJECT(old_points = vxCreateArray(context, VX_TYPE_KEYPOINT, capacity), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(new_points_estimates = vxCreateArray(context, VX_TYPE_KEYPOINT, capacity), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(new_points = vxCreateArray(context, VX_TYPE_KEYPOINT, capacity), VX_TYPE_ARRAY);
ASSERT_VX_OBJECT(epsilon = vxCreateScalar(context, VX_TYPE_FLOAT32, &epsilon_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(num_iter = vxCreateScalar(context, VX_TYPE_UINT32, &num_iter_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(use_initial_estimate = vxCreateScalar(context, VX_TYPE_BOOL, &use_initial_estimate_val), VX_TYPE_SCALAR);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
ASSERT_VX_OBJECT(node = vxOpticalFlowPyrLKNode(graph,
old_images, new_images,
old_points, new_points_estimates, new_points,
VX_TERM_CRITERIA_BOTH, epsilon, num_iter, use_initial_estimate, window_dims), VX_TYPE_NODE);
for (count = 0; count < 2; count++)
{
VX_CALL(vxVerifyGraph(graph));
}
VX_CALL(vxReleasePyramid(&old_images));
VX_CALL(vxReleasePyramid(&new_images));
VX_CALL(vxReleaseArray(&old_points));
VX_CALL(vxReleaseArray(&new_points_estimates));
VX_CALL(vxReleaseArray(&new_points));
VX_CALL(vxReleaseScalar(&epsilon));
VX_CALL(vxReleaseScalar(&num_iter));
VX_CALL(vxReleaseScalar(&use_initial_estimate));
VX_CALL(vxReleaseNode(&node));
VX_CALL(vxReleaseGraph(&graph));
}
VX_CALL(vxQueryContext(context, VX_CONTEXT_REFERENCES, &nrefs_after, sizeof(nrefs_after)));
nrefs_dangling = nrefs_after - nrefs_before;
ASSERT_EQ_INT(0, nrefs_dangling);
return;
}
typedef enum
{
fn_vxOpticalFlowPyrLKNode = 0,
fn_vxGaussianPyramidNode,
fn_vxCannyEdgeDetectorNode,
fn_vxHarrisCornersNode,
fn_vxHalfScaleGaussianNode,
fn_vxLaplacianPyramidNode,
fn_vxLaplacianReconstructNode
} test_case;
typedef struct
{
const char* testName;
CT_Image(*generator)(const char* fileName, int width, int height);
test_case test_id;
} ResourceLeakage_Arg;
#define ADD_TEST_CASES(testArgName, nextmacro, ...) \
CT_EXPAND(nextmacro(testArgName "/vxOpticalFlowPyrLKNode", __VA_ARGS__, fn_vxOpticalFlowPyrLKNode)), \
CT_EXPAND(nextmacro(testArgName "/vxGaussianPyramidNode", __VA_ARGS__, fn_vxGaussianPyramidNode)), \
CT_EXPAND(nextmacro(testArgName "/vxCannyEdgeDetectorNode", __VA_ARGS__, fn_vxCannyEdgeDetectorNode)), \
CT_EXPAND(nextmacro(testArgName "/vxHarrisCornersNode", __VA_ARGS__, fn_vxHarrisCornersNode)), \
CT_EXPAND(nextmacro(testArgName "/vxHalfScaleGausianNode", __VA_ARGS__, fn_vxHalfScaleGaussianNode)), \
CT_EXPAND(nextmacro(testArgName "/vxLaplacianPyramidNode", __VA_ARGS__, fn_vxLaplacianPyramidNode)), \
CT_EXPAND(nextmacro(testArgName "/vxLaplacianReconstructNode", __VA_ARGS__, fn_vxLaplacianReconstructNode))
#define RESOURCE_LEAKAGE_PARAMETERS \
CT_GENERATE_PARAMETERS("func", ADD_TEST_CASES, ARG, NULL)
TEST_WITH_ARG(Graph, testVerifyGraphLeak, ResourceLeakage_Arg, RESOURCE_LEAKAGE_PARAMETERS)
{
vx_context context = context_->vx_context_;
switch (arg_->test_id)
{
case fn_vxOpticalFlowPyrLKNode: test_opticalflowpyrlk(context); break;
case fn_vxGaussianPyramidNode: test_gaussianpyramid(context); break;
case fn_vxCannyEdgeDetectorNode: test_cannyedgedetector(context); break;
case fn_vxHarrisCornersNode: test_harriscorners(context); break;
case fn_vxHalfScaleGaussianNode: test_halfscalegaussian(context); break;
case fn_vxLaplacianPyramidNode: test_laplacianpyramid(context); break;
case fn_vxLaplacianReconstructNode: test_laplacianreconstruct(context); break;
default: break;
}
return;
}
static vx_graph graph_to_abandon = NULL;
static vx_status saved_graph_state_status = VX_FAILURE;
static vx_bool saved_graph_state_queried = vx_false_e;
static vx_enum saved_graph_state = VX_GRAPH_STATE_UNVERIFIED;
static vx_action VX_CALLBACK abandon_graph(vx_node node)
{
vx_action action = VX_ACTION_ABANDON;
if (graph_to_abandon != NULL)
{
saved_graph_state_status = vxQueryGraph(graph_to_abandon, VX_GRAPH_STATE, &saved_graph_state, sizeof(saved_graph_state));
saved_graph_state_queried = vx_true_e;
}
return action;
}
TEST(Graph, testGraphState)
{
vx_context context = context_->vx_context_;
vx_image src_image = 0, interm_image = 0, dst_image = 0;
vx_graph graph = 0;
vx_node node1 = 0, node2 = 0;
vx_enum graph_state = VX_GRAPH_STATE_UNVERIFIED;
int phase;
ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(interm_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U32), VX_TYPE_IMAGE);
ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_UNVERIFIED);
ASSERT_VX_OBJECT(node1 = vxBox3x3Node(graph, src_image, interm_image), VX_TYPE_NODE);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_UNVERIFIED);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_VERIFIED);
ASSERT_VX_OBJECT(node2 = vxIntegralImageNode(graph, interm_image, dst_image), VX_TYPE_NODE);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_UNVERIFIED);
VX_CALL(vxVerifyGraph(graph));
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_VERIFIED);
for (phase = 0; phase < 2; ++phase)
{
vx_bool do_async = (vx_bool)(phase != 0);
if (do_async)
{
VX_CALL(vxScheduleGraph(graph));
VX_CALL(vxWaitGraph(graph));
}
else
{
VX_CALL(vxProcessGraph(graph));
}
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_COMPLETED);
graph_to_abandon = graph;
saved_graph_state_status = VX_FAILURE;
saved_graph_state_queried = vx_false_e;
saved_graph_state = VX_GRAPH_STATE_UNVERIFIED;
VX_CALL(vxAssignNodeCallback(node1, &abandon_graph));
if (do_async)
{
VX_CALL(vxScheduleGraph(graph));
ASSERT_EQ_VX_STATUS(VX_ERROR_GRAPH_ABANDONED, vxWaitGraph(graph));
}
else
{
ASSERT_EQ_VX_STATUS(VX_ERROR_GRAPH_ABANDONED, vxProcessGraph(graph));
}
ASSERT(saved_graph_state_queried == vx_true_e);
ASSERT_EQ_VX_STATUS(VX_SUCCESS, saved_graph_state_status);
ASSERT(saved_graph_state == VX_GRAPH_STATE_RUNNING);
VX_CALL(vxQueryGraph(graph, VX_GRAPH_STATE, &graph_state, sizeof(graph_state)));
ASSERT(graph_state == VX_GRAPH_STATE_ABANDONED);
VX_CALL(vxAssignNodeCallback(node1, NULL));
}
VX_CALL(vxReleaseNode(&node1));
VX_CALL(vxReleaseNode(&node2));
VX_CALL(vxReleaseGraph(&graph));
VX_CALL(vxReleaseImage(&dst_image));
VX_CALL(vxReleaseImage(&interm_image));
VX_CALL(vxReleaseImage(&src_image));
ASSERT(node1 == 0); ASSERT(node2 == 0);
ASSERT(graph == 0);
ASSERT(dst_image == 0); ASSERT(interm_image == 0); ASSERT(src_image == 0);
}
TESTCASE_TESTS(Graph,
testTwoNodes,
testGraphFactory,
testVirtualImage,
testVirtualArray,
testNodeRemove,
testNodeFromEnum,
testTwoNodesWithSameDst,
testCycle,
testCycle2,
testMultipleRun,
testMultipleRunAsync,
DISABLED_testAsyncWaitWithoutSchedule,
testNodePerformance,
testGraphPerformance,
testKernelName,
testAllocateUserKernelId,
testAllocateUserKernelLibraryId,
testReplicateNode,
testImageContainmentRelationship,
testVerifyGraphLeak,
testGraphState
)