vx_image input,

vx_image output,

vx_int32 ksize )

{

vx_node node = NULL; // vxCreateGenericNode( /* Fill in parameters */ );

return node;

vx_uint32 index )

{

return VX_SUCCESS;

vx_uint32 index,

vx_meta_format meta )

{

if( index == 1 )

{

}

else

{

// invalid input parameter

return VX_ERROR_INVALID_PARAMETERS;

}

return VX_SUCCESS;

{

vx_image input = ( vx_image ) refs[0];

vx_image output = ( vx_image ) refs[1];

vx_scalar s_ksize = ( vx_scalar )refs[2];

return VX_SUCCESS;

{

vxAddLogEntry( ( vx_reference ) context, VX_SUCCESS, "OK: registered user kernel app.userkernels.median_blur\n" );

return VX_SUCCESS;

vx_reference ref,

vx_status status,

const vx_char string[] )

{

printf( "LOG: [ status = %d ] %s\n", status, string );

fflush( stdout );

{

// Get default video sequence when nothing is specified on command-line and

// instantiate OpenCV GUI module for reading input RGB images and displaying

// the image with OpenVX results

const char * video_sequence = argv[1];

CGuiModule gui( video_sequence );

// Try grab first video frame from the sequence using cv::VideoCapture

// and check if video frame is available

if( !gui.Grab() )

{

printf( "ERROR: input has no video\n" );

return 1;

}

////////

// Set the application configuration parameters. Note that input video

// sequence is an 8-bit RGB image with dimensions given by gui.GetWidth()

// and gui.GetHeight(). The parameters for the median filter are:

// ksize - median filter kernel size

vx_uint32 width = gui.GetWidth();

vx_uint32 height = gui.GetHeight();

vx_int32 ksize = 7;

////////

// Create the OpenVX context and make sure returned context is valid and

// register the log_callback to receive messages from OpenVX framework.

vx_context context = vxCreateContext();

ERROR_CHECK_OBJECT( context );

vxRegisterLogCallback( context, log_callback, vx_false_e );

////////

// Register user kernels with the context.

//

// TODO STEP 07:********

// 1. Register user kernel with context by calling your implementation of "registerUserKernel()".

////////

// Create OpenVX image object for input RGB image and median filter output image.

vx_image input_rgb_image = vxCreateImage( context, width, height, VX_DF_IMAGE_RGB );

vx_image output_filtered_image = vxCreateImage( context, width, height, VX_DF_IMAGE_U8 );

ERROR_CHECK_OBJECT( input_rgb_image );

ERROR_CHECK_OBJECT( output_filtered_image );

////////********

// Create graph object and intermediate image objects.

// Given that input is an RGB image, it is best to extract a gray image

// from RGB image, which requires two steps:

// - perform RGB to IYUV color conversion

// - extract Y channel from IYUV image

// This requires two intermediate OpenVX image objects. Since you don't

// need to access these objects from the application, they can be virtual

// objects that can be created using the vxCreateVirtualImage API.

vx_graph graph = vxCreateGraph( context );

ERROR_CHECK_OBJECT( graph );

vx_image yuv_image = vxCreateVirtualImage( graph, width, height, VX_DF_IMAGE_IYUV );

vx_image luma_image = vxCreateVirtualImage( graph, width, height, VX_DF_IMAGE_U8 );

ERROR_CHECK_OBJECT( yuv_image );

ERROR_CHECK_OBJECT( luma_image );

////////********

// Now all the objects have been created for building the graph

// that converts RGB into luma image and then performs median blur

// using user kernel USER_KERNEL_MEDIAN_BLUR.

// Then use vxVerifyGraph API for initialization.

//

// TODO STEP 08:********

// 1. Use userMedianBlurNode function to add "median_blur" node.

// We gave most of the code in comments; fill in parameters for user kernel.

////////

// Process the video sequence frame by frame until the end of sequence or aborted.

for( int frame_index = 0; !gui.AbortRequested(); frame_index++ )

{

////////

// Copy input RGB frame from OpenCV to OpenVX. In order to do this,

// you need to use vxAccessImagePatch and vxCommitImagePatch APIs.

// See "VX/vx_api.h" for the description of these APIs.

vx_rectangle_t cv_rgb_image_region;

cv_rgb_image_region.start_x = 0;

cv_rgb_image_region.start_y = 0;

cv_rgb_image_region.end_x = width;

cv_rgb_image_region.end_y = height;

vx_imagepatch_addressing_t cv_rgb_image_layout;

cv_rgb_image_layout.stride_x = 3;

cv_rgb_image_layout.stride_y = gui.GetStride();

vx_uint8 * cv_rgb_image_buffer = gui.GetBuffer();

ERROR_CHECK_STATUS( vxAccessImagePatch( input_rgb_image, &cv_rgb_image_region, 0,

&cv_rgb_image_layout, ( void ** )&cv_rgb_image_buffer, VX_WRITE_ONLY ) );

ERROR_CHECK_STATUS( vxCommitImagePatch( input_rgb_image, &cv_rgb_image_region, 0,

&cv_rgb_image_layout, cv_rgb_image_buffer ) );

////////********

// Now that input RGB image is ready, just run the graph.

// TODO STEP 09:********

// 1. Use vxProcessGraph to run the graph.

// We gave the code in comments; just uncomment.

////////

// Display the output filtered image.

vx_rectangle_t rect = { 0, 0, width, height };

vx_imagepatch_addressing_t addr = { 0 };

void * ptr = NULL;

ERROR_CHECK_STATUS( vxAccessImagePatch( output_filtered_image, &rect, 0, &addr, &ptr, VX_READ_ONLY ) );

cv::Mat mat( height, width, CV_8U, ptr, addr.stride_y );

cv::imshow( "MedianBlur", mat );

ERROR_CHECK_STATUS( vxCommitImagePatch( output_filtered_image, &rect, 0, &addr, ptr ) );

////////

// Display the results and grab the next input RGB frame for the next iteration.

char text[128];

sprintf( text, "Keyboard ESC/Q-Quit SPACE-Pause [FRAME %d] [ksize %d]", frame_index, ksize );

gui.DrawText( 0, 16, text );

gui.Show();

if( !gui.Grab() )

{

// Terminate the processing loop if the end of sequence is detected.

gui.WaitForKey();

break;

}

}

////////********

// Query graph performance using VX_GRAPH_ATTRIBUTE_PERFORMANCE and print timing

// in milliseconds. Note that time units of vx_perf_t fields are nanoseconds.

vx_perf_t perf = { 0 };

ERROR_CHECK_STATUS( vxQueryGraph( graph, VX_GRAPH_ATTRIBUTE_PERFORMANCE, &perf, sizeof( perf ) ) );

printf( "GraphName NumFrames Avg(ms) Min(ms)\n"

"Median %9d %7.3f %7.3f\n",

( int )perf.num, ( float )perf.avg * 1e-6f, ( float )perf.min * 1e-6f );

////////********

// To release an OpenVX object, you need to call vxRelease<Object> API which takes a pointer to the object.

// If the release operation is successful, the OpenVX framework will reset the object to NULL.

ERROR_CHECK_STATUS( vxReleaseGraph( &graph ) );

ERROR_CHECK_STATUS( vxReleaseImage( &input_rgb_image ) );

ERROR_CHECK_STATUS( vxReleaseImage( &output_filtered_image ) );

ERROR_CHECK_STATUS( vxReleaseContext( &context ) );

return 0;