develop/amd_openvx/openvx/include/VX/vx_nodes.h File Reference

develop/amd_openvx/openvx/include/VX/vx_nodes.h File Reference#

MIVisionX: develop/amd_openvx/openvx/include/VX/vx_nodes.h File Reference
vx_nodes.h File Reference

The "Simple" API interface for OpenVX. These APIs are just wrappers around the more verbose functions defined in vx_api.h. More...

Go to the source code of this file.

Functions

VX_API_ENTRY vx_node VX_API_CALL vxColorConvertNode (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a color conversion node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxChannelExtractNode (vx_graph graph, vx_image input, vx_enum channel, vx_image output)
 [Graph] Creates a channel extract node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxChannelCombineNode (vx_graph graph, vx_image plane0, vx_image plane1, vx_image plane2, vx_image plane3, vx_image output)
 [Graph] Creates a channel combine node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxPhaseNode (vx_graph graph, vx_image grad_x, vx_image grad_y, vx_image orientation)
 [Graph] Creates a Phase node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxSobel3x3Node (vx_graph graph, vx_image input, vx_image output_x, vx_image output_y)
 [Graph] Creates a Sobel3x3 node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMagnitudeNode (vx_graph graph, vx_image grad_x, vx_image grad_y, vx_image mag)
 [Graph] Create a Magnitude node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxScaleImageNode (vx_graph graph, vx_image src, vx_image dst, vx_enum type)
 [Graph] Creates a Scale Image Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTableLookupNode (vx_graph graph, vx_image input, vx_lut lut, vx_image output)
 [Graph] Creates a Table Lookup node. If a value from the input image is not present in the lookup table, the result is undefined. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHistogramNode (vx_graph graph, vx_image input, vx_distribution distribution)
 [Graph] Creates a Histogram node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxEqualizeHistNode (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a Histogram Equalization node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxAbsDiffNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates an AbsDiff node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMeanStdDevNode (vx_graph graph, vx_image input, vx_scalar mean, vx_scalar stddev)
 [Graph] Creates a mean value and optionally, a standard deviation node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxThresholdNode (vx_graph graph, vx_image input, vx_threshold thresh, vx_image output)
 [Graph] Creates a Threshold node and returns a reference to it. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxNonMaxSuppressionNode (vx_graph graph, vx_image input, vx_image mask, vx_int32 win_size, vx_image output)
 [Graph] Creates a Non-Maxima Suppression node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxIntegralImageNode (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates an Integral Image Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxErode3x3Node (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates an Erosion Image Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxDilate3x3Node (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a Dilation Image Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMedian3x3Node (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a Median Image Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxBox3x3Node (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a Box Filter Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxGaussian3x3Node (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a Gaussian Filter Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxNonLinearFilterNode (vx_graph graph, vx_enum function, vx_image input, vx_matrix mask, vx_image output)
 [Graph] Creates a Non-linear Filter Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxConvolveNode (vx_graph graph, vx_image input, vx_convolution conv, vx_image output)
 [Graph] Creates a custom convolution node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxGaussianPyramidNode (vx_graph graph, vx_image input, vx_pyramid gaussian)
 [Graph] Creates a node for a Gaussian Image Pyramid. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxLaplacianPyramidNode (vx_graph graph, vx_image input, vx_pyramid laplacian, vx_image output)
 [Graph] Creates a node for a Laplacian Image Pyramid. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxLaplacianReconstructNode (vx_graph graph, vx_pyramid laplacian, vx_image input, vx_image output)
 [Graph] Reconstructs an image from a Laplacian Image pyramid. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxWeightedAverageNode (vx_graph graph, vx_image img1, vx_scalar alpha, vx_image img2, vx_image output)
 [Graph] Creates a image weighted average node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMinMaxLocNode (vx_graph graph, vx_image input, vx_scalar minVal, vx_scalar maxVal, vx_array minLoc, vx_array maxLoc, vx_scalar minCount, vx_scalar maxCount)
 [Graph] Creates a min,max,loc node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMinNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates a pixel-wise minimum kernel. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMaxNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates a pixel-wise maximum kernel. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxAndNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates a bitwise AND node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxOrNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates a bitwise INCLUSIVE OR node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxXorNode (vx_graph graph, vx_image in1, vx_image in2, vx_image out)
 [Graph] Creates a bitwise EXCLUSIVE OR node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxNotNode (vx_graph graph, vx_image input, vx_image output)
 [Graph] Creates a bitwise NOT node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxScalarOperationNode (vx_graph graph, vx_enum scalar_operation, vx_scalar a, vx_scalar b, vx_scalar output)
 [Graph] Creates a scalar operation node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxSelectNode (vx_graph graph, vx_scalar condition, vx_reference true_value, vx_reference false_value, vx_reference output)
 [Graph] Selects one of two data objects depending on the the value of a condition (boolean scalar), and copies its data into another data object. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMultiplyNode (vx_graph graph, vx_image in1, vx_image in2, vx_scalar scale, vx_enum overflow_policy, vx_enum rounding_policy, vx_image out)
 [Graph] Creates an pixelwise-multiplication node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxAddNode (vx_graph graph, vx_image in1, vx_image in2, vx_enum policy, vx_image out)
 [Graph] Creates an arithmetic addition node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxSubtractNode (vx_graph graph, vx_image in1, vx_image in2, vx_enum policy, vx_image out)
 [Graph] Creates an arithmetic subtraction node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxConvertDepthNode (vx_graph graph, vx_image input, vx_image output, vx_enum policy, vx_scalar shift)
 [Graph] Creates a bit-depth conversion node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxCannyEdgeDetectorNode (vx_graph graph, vx_image input, vx_threshold hyst, vx_int32 gradient_size, vx_enum norm_type, vx_image output)
 [Graph] Creates a Canny Edge Detection Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxWarpAffineNode (vx_graph graph, vx_image input, vx_matrix matrix, vx_enum type, vx_image output)
 [Graph] Creates an Affine Warp Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxWarpPerspectiveNode (vx_graph graph, vx_image input, vx_matrix matrix, vx_enum type, vx_image output)
 [Graph] Creates a Perspective Warp Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHarrisCornersNode (vx_graph graph, vx_image input, vx_scalar strength_thresh, vx_scalar min_distance, vx_scalar sensitivity, vx_int32 gradient_size, vx_int32 block_size, vx_array corners, vx_scalar num_corners)
 [Graph] Creates a Harris Corners Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxFastCornersNode (vx_graph graph, vx_image input, vx_scalar strength_thresh, vx_bool nonmax_suppression, vx_array corners, vx_scalar num_corners)
 [Graph] Creates a FAST Corners Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxOpticalFlowPyrLKNode (vx_graph graph, vx_pyramid old_images, vx_pyramid new_images, vx_array old_points, vx_array new_points_estimates, vx_array new_points, vx_enum termination, vx_scalar epsilon, vx_scalar num_iterations, vx_scalar use_initial_estimate, vx_size window_dimension)
 [Graph] Creates a Lucas Kanade Tracking Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxRemapNode (vx_graph graph, vx_image input, vx_remap table, vx_enum policy, vx_image output)
 [Graph] Creates a Remap Node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHalfScaleGaussianNode (vx_graph graph, vx_image input, vx_image output, vx_int32 kernel_size)
 [Graph] Performs a Gaussian Blur on an image then half-scales it. The interpolation mode used is nearest-neighbor. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxMatchTemplateNode (vx_graph graph, vx_image src, vx_image templateImage, vx_enum matchingMethod, vx_image output)
 [Graph] The Node Compares an image template against overlapped image regions. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxLBPNode (vx_graph graph, vx_image in, vx_enum format, vx_int8 kernel_size, vx_image out)
 [Graph] Creates a node that extracts LBP image from an input image More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHOGCellsNode (vx_graph graph, vx_image input, vx_int32 cell_width, vx_int32 cell_height, vx_int32 num_bins, vx_tensor magnitudes, vx_tensor bins)
 [Graph] Performs cell calculations for the average gradient magnitude and gradient orientation histograms. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHOGFeaturesNode (vx_graph graph, vx_image input, vx_tensor magnitudes, vx_tensor bins, const vx_hog_t *params, vx_size hog_param_size, vx_tensor features)
 [Graph] The node produces HOG features for the W1xW2 window in a sliding window fashion over the whole input image. Each position produces a HOG feature vector. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxHoughLinesPNode (vx_graph graph, vx_image input, const vx_hough_lines_p_t *params, vx_array lines_array, vx_scalar num_lines)
 [Graph] Finds the Probabilistic Hough Lines detected in the input binary image, each line is stored in the output array as a set of points (x1, y1, x2, y2) . More...
 
VX_API_ENTRY vx_node VX_API_CALL vxBilateralFilterNode (vx_graph graph, vx_tensor src, vx_int32 diameter, vx_float32 sigmaSpace, vx_float32 sigmaValues, vx_tensor dst)
 [Graph] The function applies bilateral filtering to the input tensor. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorMultiplyNode (vx_graph graph, vx_tensor input1, vx_tensor input2, vx_scalar scale, vx_enum overflow_policy, vx_enum rounding_policy, vx_tensor output)
 [Graph] Performs element wise multiplications on element values in the input tensor data with a scale. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorAddNode (vx_graph graph, vx_tensor input1, vx_tensor input2, vx_enum policy, vx_tensor output)
 [Graph] Performs arithmetic addition on element values in the input tensor data. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorSubtractNode (vx_graph graph, vx_tensor input1, vx_tensor input2, vx_enum policy, vx_tensor output)
 [Graph] Performs arithmetic subtraction on element values in the input tensor data. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorTableLookupNode (vx_graph graph, vx_tensor input1, vx_lut lut, vx_tensor output)
 [Graph] Performs LUT on element values in the input tensor data. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorTransposeNode (vx_graph graph, vx_tensor input, vx_tensor output, vx_size dimension1, vx_size dimension2)
 [Graph] Performs transpose on the input tensor. The node transpose the tensor according to a specified 2 indexes in the tensor (0-based indexing) More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorConvertDepthNode (vx_graph graph, vx_tensor input, vx_enum policy, vx_scalar norm, vx_scalar offset, vx_tensor output)
 [Graph] Creates a bit-depth conversion node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxTensorMatrixMultiplyNode (vx_graph graph, vx_tensor input1, vx_tensor input2, vx_tensor input3, const vx_tensor_matrix_multiply_params_t *matrix_multiply_params, vx_tensor output)
 [Graph] Creates a generalized matrix multiplication node. More...
 
VX_API_ENTRY vx_node VX_API_CALL vxCopyNode (vx_graph graph, vx_reference input, vx_reference output)
 Copy data from one object to another. More...
 

Detailed Description

The "Simple" API interface for OpenVX. These APIs are just wrappers around the more verbose functions defined in vx_api.h.

Function Documentation

◆ vxAbsDiffNode()

VX_API_ENTRY vx_node VX_API_CALL vxAbsDiffNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates an AbsDiff node.

Parameters
[in]graphThe reference to the graph.
[in]in1An input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format.
[in]in2An input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format.
[out]outThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format, which must have the same dimensions as the input image.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxAddNode()

VX_API_ENTRY vx_node VX_API_CALL vxAddNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_enum  policy,
vx_image  out 
)

[Graph] Creates an arithmetic addition node.

Parameters
[in]graphThe reference to the graph.
[in]in1An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]in2An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]policyA VX_TYPE_ENUM of the vx_convert_policy_e enumeration.
[out]outThe output image, a VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 image, which must have the same dimensions as the input images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxAndNode()

VX_API_ENTRY vx_node VX_API_CALL vxAndNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates a bitwise AND node.

Parameters
[in]graphThe reference to the graph.
[in]in1A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[in]in2A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[out]outThe VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 output image, which must have the same dimensions and type as the input images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxBilateralFilterNode()

VX_API_ENTRY vx_node VX_API_CALL vxBilateralFilterNode ( vx_graph  graph,
vx_tensor  src,
vx_int32  diameter,
vx_float32  sigmaSpace,
vx_float32  sigmaValues,
vx_tensor  dst 
)

[Graph] The function applies bilateral filtering to the input tensor.

Parameters
[in]graphThe reference to the graph.
[in]srcThe input data a vx_tensor. maximum 3 dimension and minimum 2. The tensor is of type VX_TYPE_UINT8 or VX_TYPE_INT16. dimensions are [radiometric ,width,height] or [width,height].See vxCreateTensor and vxCreateVirtualTensor.
[in]diameterof each pixel neighbourhood that is used during filtering. Values of diameter must be odd. Bigger then 3 and smaller then 10.
[in]sigmaValuesFilter sigma in the radiometric space. Supported values are bigger then 0 and smaller or equal 20.
[in]sigmaSpaceFilter sigma in the spatial space. Supported values are bigger then 0 and smaller or equal 20.
[out]dstThe output data a vx_tensor,Of type VX_TYPE_UINT8 or VX_TYPE_INT16. And must be the same type and size of the input.
Note
The border modes VX_NODE_BORDER value VX_BORDER_REPLICATE and VX_BORDER_CONSTANT are supported.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxBox3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxBox3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a Box Filter Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[out]outputThe output image in VX_DF_IMAGE_U8 format, which must have the same dimensions as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxCannyEdgeDetectorNode()

VX_API_ENTRY vx_node VX_API_CALL vxCannyEdgeDetectorNode ( vx_graph  graph,
vx_image  input,
vx_threshold  hyst,
vx_int32  gradient_size,
vx_enum  norm_type,
vx_image  output 
)

[Graph] Creates a Canny Edge Detection Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 image.
[in]hystThe double threshold for hysteresis. The VX_THRESHOLD_INPUT_FORMAT shall be either VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16. The VX_THRESHOLD_OUTPUT_FORMAT is ignored.
[in]gradient_sizeThe size of the Sobel filter window, must support at least 3, 5, and 7.
[in]norm_typeA flag indicating the norm used to compute the gradient, VX_NORM_L1 or VX_NORM_L2.
[out]outputThe binary output image in VX_DF_IMAGE_U1 or VX_DF_IMAGE_U8 format with values either 0 and 1 (VX_DF_IMAGE_U1), or 0 and 255 (VX_DF_IMAGE_U8).
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxChannelCombineNode()

VX_API_ENTRY vx_node VX_API_CALL vxChannelCombineNode ( vx_graph  graph,
vx_image  plane0,
vx_image  plane1,
vx_image  plane2,
vx_image  plane3,
vx_image  output 
)

[Graph] Creates a channel combine node.

Parameters
[in]graphThe graph reference.
[in]plane0The plane that forms channel 0. Must be VX_DF_IMAGE_U8.
[in]plane1The plane that forms channel 1. Must be VX_DF_IMAGE_U8.
[in]plane2[optional] The plane that forms channel 2. Must be VX_DF_IMAGE_U8.
[in]plane3[optional] The plane that forms channel 3. Must be VX_DF_IMAGE_U8.
[out]outputThe output image. The format of the image must be defined, even if the image is virtual. Must have the same dimensions as the input images
See also
VX_KERNEL_CHANNEL_COMBINE
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxChannelExtractNode()

VX_API_ENTRY vx_node VX_API_CALL vxChannelExtractNode ( vx_graph  graph,
vx_image  input,
vx_enum  channel,
vx_image  output 
)

[Graph] Creates a channel extract node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image. Must be one of the defined vx_df_image_e multi-channel formats.
[in]channelThe vx_channel_e channel to extract.
[out]outputThe output image. Must be VX_DF_IMAGE_U8, and must have the same dimensions as the input image.
See also
VX_KERNEL_CHANNEL_EXTRACT
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxColorConvertNode()

VX_API_ENTRY vx_node VX_API_CALL vxColorConvertNode ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a color conversion node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image from which to convert.
[out]outputThe output image to which to convert, which must have the same dimensions as the input image.
See also
VX_KERNEL_COLOR_CONVERT
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxConvertDepthNode()

VX_API_ENTRY vx_node VX_API_CALL vxConvertDepthNode ( vx_graph  graph,
vx_image  input,
vx_image  output,
vx_enum  policy,
vx_scalar  shift 
)

[Graph] Creates a bit-depth conversion node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image.
[out]outputThe output image with the same dimensions of the input image.
[in]policyA VX_TYPE_ENUM of the vx_convert_policy_e enumeration.
[in]shiftA scalar containing a VX_TYPE_INT32 of the shift value.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxConvolveNode()

VX_API_ENTRY vx_node VX_API_CALL vxConvolveNode ( vx_graph  graph,
vx_image  input,
vx_convolution  conv,
vx_image  output 
)

[Graph] Creates a custom convolution node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[in]convThe vx_int16 convolution matrix.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format, which must have the same dimensions as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxCopyNode()

VX_API_ENTRY vx_node VX_API_CALL vxCopyNode ( vx_graph  graph,
vx_reference  input,
vx_reference  output 
)

Copy data from one object to another.

Note
An implementation may optimize away the copy when virtual data objects are used.
Parameters
[in]graphThe reference to the graph.
[in]inputThe input data object.
[out]outputThe output data object with meta-data identical to the input data object.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxDilate3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxDilate3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a Dilation Image Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format, which must have the same dimensions and type as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxEqualizeHistNode()

VX_API_ENTRY vx_node VX_API_CALL vxEqualizeHistNode ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a Histogram Equalization node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe grayscale input image in VX_DF_IMAGE_U8.
[out]outputThe grayscale output image of type VX_DF_IMAGE_U8 with equalized brightness and contrast and same size as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxErode3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxErode3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates an Erosion Image Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format, which must have the same dimensions and type as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxFastCornersNode()

VX_API_ENTRY vx_node VX_API_CALL vxFastCornersNode ( vx_graph  graph,
vx_image  input,
vx_scalar  strength_thresh,
vx_bool  nonmax_suppression,
vx_array  corners,
vx_scalar  num_corners 
)

[Graph] Creates a FAST Corners Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 image.
[in]strength_threshThreshold on difference between intensity of the central pixel and pixels on Bresenham's circle of radius 3 (VX_TYPE_FLOAT32 scalar), with a value in the range of 0.0 \(\le\) strength_thresh < 256.0. Any fractional value will be truncated to an integer.
[in]nonmax_suppressionIf true, non-maximum suppression is applied to detected corners before being placed in the vx_array of VX_TYPE_KEYPOINT objects.
[out]cornersOutput corner vx_array of VX_TYPE_KEYPOINT. The order of the keypoints in this array is implementation dependent.
[out]num_corners[optional] The total number of detected corners in image. Use a VX_TYPE_SIZE scalar.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxGaussian3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxGaussian3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a Gaussian Filter Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[out]outputThe output image in VX_DF_IMAGE_U8 format, which must have the same dimensions as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxGaussianPyramidNode()

VX_API_ENTRY vx_node VX_API_CALL vxGaussianPyramidNode ( vx_graph  graph,
vx_image  input,
vx_pyramid  gaussian 
)

[Graph] Creates a node for a Gaussian Image Pyramid.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[out]gaussianThe Gaussian pyramid with VX_DF_IMAGE_U8 to construct.
See also
group_pyramid
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxHalfScaleGaussianNode()

VX_API_ENTRY vx_node VX_API_CALL vxHalfScaleGaussianNode ( vx_graph  graph,
vx_image  input,
vx_image  output,
vx_int32  kernel_size 
)

[Graph] Performs a Gaussian Blur on an image then half-scales it. The interpolation mode used is nearest-neighbor.

The output image size is determined by:

\[ W_{output} = \frac{W_{input} + 1}{2} \\ , H_{output} = \frac{H_{input} + 1}{2} \]

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 image.
[out]outputThe output VX_DF_IMAGE_U8 image.
[in]kernel_sizeThe input size of the Gaussian filter. Supported values are 1, 3 and 5.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxHarrisCornersNode()

VX_API_ENTRY vx_node VX_API_CALL vxHarrisCornersNode ( vx_graph  graph,
vx_image  input,
vx_scalar  strength_thresh,
vx_scalar  min_distance,
vx_scalar  sensitivity,
vx_int32  gradient_size,
vx_int32  block_size,
vx_array  corners,
vx_scalar  num_corners 
)

[Graph] Creates a Harris Corners Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 image.
[in]strength_threshThe VX_TYPE_FLOAT32 minimum threshold with which to eliminate Harris Corner scores (computed using the normalized Sobel kernel).
[in]min_distanceThe VX_TYPE_FLOAT32 radial Euclidean distance for non-maximum suppression.
[in]sensitivityThe VX_TYPE_FLOAT32 scalar sensitivity threshold \( k \) from the Harris-Stephens equation.
[in]gradient_sizeThe gradient window size to use on the input. The implementation must support at least 3, 5, and 7.
[in]block_sizeThe block window size used to compute the Harris Corner score. The implementation must support at least 3, 5, and 7.
[out]cornersThe array of VX_TYPE_KEYPOINT objects. The order of the keypoints in this array is implementation dependent.
[out]num_corners[optional] The total number of detected corners in image. Use a VX_TYPE_SIZE scalar.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxHistogramNode()

VX_API_ENTRY vx_node VX_API_CALL vxHistogramNode ( vx_graph  graph,
vx_image  input,
vx_distribution  distribution 
)

[Graph] Creates a Histogram node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8.
[out]distributionThe output distribution.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxHOGCellsNode()

VX_API_ENTRY vx_node VX_API_CALL vxHOGCellsNode ( vx_graph  graph,
vx_image  input,
vx_int32  cell_width,
vx_int32  cell_height,
vx_int32  num_bins,
vx_tensor  magnitudes,
vx_tensor  bins 
)

[Graph] Performs cell calculations for the average gradient magnitude and gradient orientation histograms.

Firstly, the gradient magnitude and gradient orientation are computed for each pixel in the input image. Two 1-D centred, point discrete derivative masks are applied to the input image in the horizontal and vertical directions.

\[ M_h = [-1, 0, 1] \]

and

\[ M_v = [-1, 0, 1]^T \]

\(G_v\) is the result of applying mask \(M_v\) to the input image, and \(G_h\) is the result of applying mask \(M_h\) to the input image. The border mode used for the gradient calculation is implementation dependent. Its behavior should be similar to VX_BORDER_UNDEFINED. The gradient magnitudes and gradient orientations for each pixel are then calculated in the following manner.

\[ G(x,y) = \sqrt{G_v(x,y)^2 + G_h(x,y)^2} \]

\[ \theta(x,y) = arctan(G_v(x,y), G_h(x,y)) \]

where \(arctan(v, h)\) is \( tan^{-1}(v/h)\) when \(h!=0\),

\( -pi/2 \) if \(v<0\) and \(h==0\),

\( pi/2 \) if \(v>0\) and \(h==0\)

and \( 0 \) if \(v==0\) and \(h==0\)

Secondly, the gradient magnitudes and orientations are used to compute the bins output tensor and optional magnitudes output tensor. These tensors are computed on a cell level where the cells are rectangular in shape. The magnitudes tensor contains the average gradient magnitude for each cell.

\[magnitudes(c) = \frac{1}{(cell\_width * cell\_height)}\sum\limits_{w=0}^{cell\_width} \sum\limits_{h=0}^{cell\_height} G_c(w,h)\]

where \(G_c\) is the gradient magnitudes related to cell \(c\). The bins tensor contains histograms of gradient orientations for each cell. The gradient orientations at each pixel range from 0 to 360 degrees. These are quantised into a set of histogram bins based on the num_bins parameter. Each pixel votes for a specific cell histogram bin based on its gradient orientation. The vote itself is the pixel's gradient magnitude.

\[bins(c, n) = \sum\limits_{w=0}^{cell\_width} \sum\limits_{h=0}^{cell\_height} G_c(w,h) * 1[B_c(w, h, num\_bins) == n]\]

where \(B_c\) produces the histogram bin number based on the gradient orientation of the pixel at location ( \(w\), \(h\)) in cell \(c\) based on the \(num\_bins\) and

\[1[B_c(w, h, num\_bins) == n]\]

is a delta-function with value 1 when \(B_c(w, h, num\_bins) == n\) or 0 otherwise.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image of type VX_DF_IMAGE_U8.
[in]cell_widthThe histogram cell width of type VX_TYPE_INT32.
[in]cell_heightThe histogram cell height of type VX_TYPE_INT32.
[in]num_binsThe histogram size of type VX_TYPE_INT32.
[out]magnitudes(Optional) The output average gradient magnitudes per cell of vx_tensor of type VX_TYPE_INT16 of size \( [floor(image_{width}/cell_{width}) ,floor(image_{height}/cell_{height}) ] \).
[out]binsThe output gradient orientation histograms per cell of vx_tensor of type VX_TYPE_INT16 of size \( [floor(image_{width}/cell_{width}) ,floor(image_{height}/cell_{height}), num_{bins}] \).
Returns
vx_node.
Return values
0Node could not be created.
*Node handle.

◆ vxHOGFeaturesNode()

VX_API_ENTRY vx_node VX_API_CALL vxHOGFeaturesNode ( vx_graph  graph,
vx_image  input,
vx_tensor  magnitudes,
vx_tensor  bins,
const vx_hog_t params,
vx_size  hog_param_size,
vx_tensor  features 
)

[Graph] The node produces HOG features for the W1xW2 window in a sliding window fashion over the whole input image. Each position produces a HOG feature vector.

Firstly if a magnitudes tensor is provided the cell histograms in the bins tensor are normalised by the average cell gradient magnitudes.

\[bins(c,n) = \frac{bins(c,n)}{magnitudes(c)}\]

To account for changes in illumination and contrast the cell histograms must be locally normalized which requires grouping the cell histograms together into larger spatially connected blocks. Blocks are rectangular grids represented by three parameters: the number of cells per block, the number of pixels per cell, and the number of bins per cell histogram. These blocks typically overlap, meaning that each cell histogram contributes more than once to the final descriptor. To normalize a block its cell histograms \(h\) are grouped together to form a vector \(v = [h_1, h_2, h_3, ... , h_n]\). This vector is normalised using L2-Hys which means performing L2-norm on this vector; clipping the result (by limiting the maximum values of v to be threshold) and renormalizing again. If the threshold is equal to zero then L2-Hys normalization is not performed.

\[L2norm(v) = \frac{v}{\sqrt{\|v\|_2^2 + \epsilon^2}}\]

where \( \|v\|_k \) be its k-norm for k=1, 2, and \( \epsilon \) be a small constant. For a specific window its HOG descriptor is then the concatenated vector of the components of the normalized cell histograms from all of the block regions contained in the window. The W1xW2 window starting position is at coordinates 0x0. If the input image has dimensions that are not an integer multiple of W1xW2 blocks with the specified stride, then the last positions that contain only a partial W1xW2 window will be calculated with the remaining part of the W1xW2 window padded with zeroes. The Window W1xW2 must also have a size so that it contains an integer number of cells, otherwise the node is not well-defined. The final output tensor will contain HOG descriptors equal to the number of windows in the input image. The output features tensor has 3 dimensions, given by:

\[[ (floor((image_{width}-window_{width})/window_{stride}) + 1),\]

\[ (floor((image_{height}-window_{height})/window_{stride}) + 1),\]

\[ floor((window_{width} - block_{width})/block_{stride} + 1) * floor((window_{height} - block_{height})/block_{stride} + 1) *\]

\[ (((block_{width} * block_{height}) / (cell_{width} * cell_{height})) * num_{bins})] \]

See vxCreateTensor and vxCreateVirtualTensor. We recommend the output tensors always be virtual objects, with this node connected directly to the classifier. The output tensor will be very large, and using non-virtual tensors will result in a poorly optimized implementation. Merging of this node with a classifier node such as that described in the classifier extension will result in better performance. Notice that this node creation function has more parameters than the corresponding kernel. Numbering of kernel parameters (required if you create this node using the generic interface) is explicitly specified here.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image of type VX_DF_IMAGE_U8. (Kernel parameter #0)
[in]magnitudes(Optional) The gradient magnitudes per cell of vx_tensor of type VX_TYPE_INT16. It is the output of vxHOGCellsNode. (Kernel parameter #1)
[in]binsThe gradient orientation histograms per cell of vx_tensor of type VX_TYPE_INT16. It is the output of vxHOGCellsNode. (Kernel parameter #2)
[in]paramsThe parameters of type vx_hog_t. (Kernel parameter #3)
[in]hog_param_sizeSize of vx_hog_t in bytes. Note that this parameter is not counted as one of the kernel parameters.
[out]featuresThe output HOG features of vx_tensor of type VX_TYPE_INT16. (Kernel parameter #4)
Returns
vx_node.
Return values
0Node could not be created.
*Node handle.

◆ vxHoughLinesPNode()

VX_API_ENTRY vx_node VX_API_CALL vxHoughLinesPNode ( vx_graph  graph,
vx_image  input,
const vx_hough_lines_p_t params,
vx_array  lines_array,
vx_scalar  num_lines 
)

[Graph] Finds the Probabilistic Hough Lines detected in the input binary image, each line is stored in the output array as a set of points (x1, y1, x2, y2) .

Some implementations of the algorithm may have a random or non-deterministic element. If the target application is in a safety-critical environment this should be borne in mind and steps taken in the implementation, the application or both to achieve the level of determinism required by the system design.

Parameters
[in]graphgraph handle
[in]inputA single channel binary source image of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1.
[in]paramsparameters of the struct vx_hough_lines_p_t
[out]lines_arraylines_array contains array of lines, see vx_line2d_t The order of lines in implementation dependent
[out]num_lines[optional] The total number of detected lines in image. Use a VX_TYPE_SIZE scalar
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxIntegralImageNode()

VX_API_ENTRY vx_node VX_API_CALL vxIntegralImageNode ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates an Integral Image Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[out]outputThe output image in VX_DF_IMAGE_U32 format, which must have the same dimensions as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxLaplacianPyramidNode()

VX_API_ENTRY vx_node VX_API_CALL vxLaplacianPyramidNode ( vx_graph  graph,
vx_image  input,
vx_pyramid  laplacian,
vx_image  output 
)

[Graph] Creates a node for a Laplacian Image Pyramid.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format.
[out]laplacianThe Laplacian pyramid with VX_DF_IMAGE_S16 to construct.
[out]outputThe lowest resolution image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format necessary to reconstruct the input image from the pyramid. The output image format should be same as input image format.
See also
group_pyramid
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxLaplacianReconstructNode()

VX_API_ENTRY vx_node VX_API_CALL vxLaplacianReconstructNode ( vx_graph  graph,
vx_pyramid  laplacian,
vx_image  input,
vx_image  output 
)

[Graph] Reconstructs an image from a Laplacian Image pyramid.

Parameters
[in]graphThe reference to the graph.
[in]laplacianThe Laplacian pyramid with VX_DF_IMAGE_S16 format.
[in]inputThe lowest resolution image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format for the Laplacian pyramid.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format with the highest possible resolution reconstructed from the Laplacian pyramid. The output image format should be same as input image format.
See also
group_pyramid
Returns
vx_node.
Return values
0Node could not be created.
*Node handle.

◆ vxLBPNode()

VX_API_ENTRY vx_node VX_API_CALL vxLBPNode ( vx_graph  graph,
vx_image  in,
vx_enum  format,
vx_int8  kernel_size,
vx_image  out 
)

[Graph] Creates a node that extracts LBP image from an input image

Parameters
[in]graphThe reference to the graph.
[in]inAn input image in vx_image. Or \( SrcImg\) in the equations. the image is of type VX_DF_IMAGE_U8
[in]formatA variation of LBP like original LBP and mLBP. see vx_lbp_format_e
[in]kernel_sizeKernel size. Only size of 3 and 5 are supported
[out]outAn output image in vx_image.Or \( DstImg\) in the equations. the image is of type VX_DF_IMAGE_U8 with the same dimensions as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMagnitudeNode()

VX_API_ENTRY vx_node VX_API_CALL vxMagnitudeNode ( vx_graph  graph,
vx_image  grad_x,
vx_image  grad_y,
vx_image  mag 
)

[Graph] Create a Magnitude node.

Parameters
[in]graphThe reference to the graph.
[in]grad_xThe input x image. This must be in VX_DF_IMAGE_S16 format.
[in]grad_yThe input y image. This must be in VX_DF_IMAGE_S16 format.
[out]magThe magnitude image. This is in VX_DF_IMAGE_S16 format. Must have the same dimensions as the input image.
See also
VX_KERNEL_MAGNITUDE
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMatchTemplateNode()

VX_API_ENTRY vx_node VX_API_CALL vxMatchTemplateNode ( vx_graph  graph,
vx_image  src,
vx_image  templateImage,
vx_enum  matchingMethod,
vx_image  output 
)

[Graph] The Node Compares an image template against overlapped image regions.

The detailed equation to the matching can be found in vx_comp_metric_e. The output of the template matching node is a comparison map as described in vx_comp_metric_e. The Node have a limitation on the template image size (width*height). It should not be larger then 65535. If the valid region of the template image is smaller than the entire template image, the result in the destination image is implementation-dependent.

Parameters
[in]graphThe reference to the graph.
[in]srcThe input image of type VX_DF_IMAGE_U8.
[in]templateImageSearched template of type VX_DF_IMAGE_U8.
[in]matchingMethodattribute specifying the comparison method vx_comp_metric_e. This function support only VX_COMPARE_CCORR_NORM and VX_COMPARE_L2.
[out]outputMap of comparison results. The output is an image of type VX_DF_IMAGE_S16
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMaxNode()

VX_API_ENTRY vx_node VX_API_CALL vxMaxNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates a pixel-wise maximum kernel.

Parameters
[in]graphThe reference to the graph where to create the node.
[in]in1The first input image. Must be of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]in2The second input image. Must be of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[out]outThe output image which will hold the result of max and will have the same type and dimensions of the imput images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMeanStdDevNode()

VX_API_ENTRY vx_node VX_API_CALL vxMeanStdDevNode ( vx_graph  graph,
vx_image  input,
vx_scalar  mean,
vx_scalar  stddev 
)

[Graph] Creates a mean value and optionally, a standard deviation node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image. VX_DF_IMAGE_U8 and VX_DF_IMAGE_U1 are supported.
[out]meanThe VX_TYPE_FLOAT32 average pixel value.
[out]stddev[optional] The VX_TYPE_FLOAT32 standard deviation of the pixel values.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMedian3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxMedian3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a Median Image Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format, which must have the same dimensions and type as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMinMaxLocNode()

VX_API_ENTRY vx_node VX_API_CALL vxMinMaxLocNode ( vx_graph  graph,
vx_image  input,
vx_scalar  minVal,
vx_scalar  maxVal,
vx_array  minLoc,
vx_array  maxLoc,
vx_scalar  minCount,
vx_scalar  maxCount 
)

[Graph] Creates a min,max,loc node.

Parameters
[in]graphThe reference to create the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format.
[out]minValThe minimum value in the image, which corresponds to the type of the input.
[out]maxValThe maximum value in the image, which corresponds to the type of the input.
[out]minLoc[optional] The minimum VX_TYPE_COORDINATES2D locations. If the input image has several minimums, the kernel will return up to the capacity of the array.
[out]maxLoc[optional] The maximum VX_TYPE_COORDINATES2D locations. If the input image has several maximums, the kernel will return up to the capacity of the array.
[out]minCount[optional] The total number of detected minimums in image. Use a VX_TYPE_SIZE scalar.
[out]maxCount[optional] The total number of detected maximums in image. Use a VX_TYPE_SIZE scalar.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMinNode()

VX_API_ENTRY vx_node VX_API_CALL vxMinNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates a pixel-wise minimum kernel.

Parameters
[in]graphThe reference to the graph where to create the node.
[in]in1The first input image. Must be of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]in2The second input image. Must be of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[out]outThe output image which will hold the result of min and will have the same type and dimensions of the imput images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxMultiplyNode()

VX_API_ENTRY vx_node VX_API_CALL vxMultiplyNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_scalar  scale,
vx_enum  overflow_policy,
vx_enum  rounding_policy,
vx_image  out 
)

[Graph] Creates an pixelwise-multiplication node.

Parameters
[in]graphThe reference to the graph.
[in]in1An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]in2An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]scaleA non-negative VX_TYPE_FLOAT32 multiplied to each product before overflow handling.
[in]overflow_policyA VX_TYPE_ENUM of the vx_convert_policy_e enumeration.
[in]rounding_policyA VX_TYPE_ENUM of the vx_round_policy_e enumeration.
[out]outThe output image, a VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 image. Must have the same type and dimensions of the imput images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxNonLinearFilterNode()

VX_API_ENTRY vx_node VX_API_CALL vxNonLinearFilterNode ( vx_graph  graph,
vx_enum  function,
vx_image  input,
vx_matrix  mask,
vx_image  output 
)

[Graph] Creates a Non-linear Filter Node.

Parameters
[in]graphThe reference to the graph.
[in]functionThe non-linear filter function. See vx_non_linear_filter_e.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format.
[in]maskThe mask to be applied to the Non-linear function. VX_MATRIX_ORIGIN attribute is used to place the mask appropriately when computing the resulting image. See vxCreateMatrixFromPattern.
[out]outputThe output image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 format, which must have the same dimensions and type as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxNonMaxSuppressionNode()

VX_API_ENTRY vx_node VX_API_CALL vxNonMaxSuppressionNode ( vx_graph  graph,
vx_image  input,
vx_image  mask,
vx_int32  win_size,
vx_image  output 
)

[Graph] Creates a Non-Maxima Suppression node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 format.
[in]mask[optional] Constrict suppression to a ROI. The mask image is of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 and must have the same dimensions as the input image.
[in]win_sizeThe size of window over which to perform the localized non-maxima suppression. Must be odd, and less than or equal to the smallest dimension of the input image.
[out]outputThe output image, of the same type and size as the input, that has been non-maxima suppressed.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxNotNode()

VX_API_ENTRY vx_node VX_API_CALL vxNotNode ( vx_graph  graph,
vx_image  input,
vx_image  output 
)

[Graph] Creates a bitwise NOT node.

Parameters
[in]graphThe reference to the graph.
[in]inputA VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[out]outputThe VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 output image, which must have the same dimensions and type as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxOpticalFlowPyrLKNode()

VX_API_ENTRY vx_node VX_API_CALL vxOpticalFlowPyrLKNode ( vx_graph  graph,
vx_pyramid  old_images,
vx_pyramid  new_images,
vx_array  old_points,
vx_array  new_points_estimates,
vx_array  new_points,
vx_enum  termination,
vx_scalar  epsilon,
vx_scalar  num_iterations,
vx_scalar  use_initial_estimate,
vx_size  window_dimension 
)

[Graph] Creates a Lucas Kanade Tracking Node.

Parameters
[in]graphThe reference to the graph.
[in]old_imagesInput of first (old) image pyramid in VX_DF_IMAGE_U8.
[in]new_imagesInput of destination (new) image pyramid VX_DF_IMAGE_U8.
[in]old_pointsAn array of key points in a vx_array of VX_TYPE_KEYPOINT; those key points are defined at the old_images high resolution pyramid.
[in]new_points_estimatesAn array of estimation on what is the output key points in a vx_array of VX_TYPE_KEYPOINT; those keypoints are defined at the new_images high resolution pyramid.
[out]new_pointsAn output array of key points in a vx_array of VX_TYPE_KEYPOINT; those key points are defined at the new_images high resolution pyramid.
[in]terminationThe termination can be VX_TERM_CRITERIA_ITERATIONS or VX_TERM_CRITERIA_EPSILON or VX_TERM_CRITERIA_BOTH.
[in]epsilonThe vx_float32 error for terminating the algorithm.
[in]num_iterationsThe number of iterations. Use a VX_TYPE_UINT32 scalar.
[in]use_initial_estimateUse a VX_TYPE_BOOL scalar.
[in]window_dimensionThe size of the window on which to perform the algorithm. See VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxOrNode()

VX_API_ENTRY vx_node VX_API_CALL vxOrNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates a bitwise INCLUSIVE OR node.

Parameters
[in]graphThe reference to the graph.
[in]in1A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[in]in2A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[out]outThe VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 output image, which must have the same dimensions and type as the input images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxPhaseNode()

VX_API_ENTRY vx_node VX_API_CALL vxPhaseNode ( vx_graph  graph,
vx_image  grad_x,
vx_image  grad_y,
vx_image  orientation 
)

[Graph] Creates a Phase node.

Parameters
[in]graphThe reference to the graph.
[in]grad_xThe input x image. This must be in VX_DF_IMAGE_S16 format.
[in]grad_yThe input y image. This must be in VX_DF_IMAGE_S16 format.
[out]orientationThe phase image. This is in VX_DF_IMAGE_U8 format, and must have the same dimensions as the input images.
See also
VX_KERNEL_PHASE
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxRemapNode()

VX_API_ENTRY vx_node VX_API_CALL vxRemapNode ( vx_graph  graph,
vx_image  input,
vx_remap  table,
vx_enum  policy,
vx_image  output 
)

[Graph] Creates a Remap Node.

Parameters
[in]graphThe reference to the graph that will contain the node.
[in]inputThe input VX_DF_IMAGE_U8 image.
[in]tableThe remap table object.
[in]policyAn interpolation type from vx_interpolation_type_e. VX_INTERPOLATION_AREA is not supported.
[out]outputThe output VX_DF_IMAGE_U8 image with the same dimensions as the input image.
Note
The border modes VX_NODE_BORDER value VX_BORDER_UNDEFINED and VX_BORDER_CONSTANT are supported.
Returns
A vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxScalarOperationNode()

VX_API_ENTRY vx_node VX_API_CALL vxScalarOperationNode ( vx_graph  graph,
vx_enum  scalar_operation,
vx_scalar  a,
vx_scalar  b,
vx_scalar  output 
)

[Graph] Creates a scalar operation node.

Parameters
[in]graphThe reference to the graph.
[in]scalar_operationA VX_TYPE_ENUM of the vx_scalar_operation_e enumeration.
[in]aFirst scalar operand.
[in]bSecond scalar operand.
[out]outputResult of the scalar operation.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxScaleImageNode()

VX_API_ENTRY vx_node VX_API_CALL vxScaleImageNode ( vx_graph  graph,
vx_image  src,
vx_image  dst,
vx_enum  type 
)

[Graph] Creates a Scale Image Node.

Parameters
[in]graphThe reference to the graph.
[in]srcThe source image of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1.
[out]dstThe destination image of type VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1. The output type must be the same as that of the input image.
[in]typeThe interpolation type to use.
See also
vx_interpolation_type_e.
Note
The destination image must have a defined size and format. The border modes VX_NODE_BORDER value VX_BORDER_UNDEFINED, VX_BORDER_REPLICATE and VX_BORDER_CONSTANT are supported.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxSelectNode()

VX_API_ENTRY vx_node VX_API_CALL vxSelectNode ( vx_graph  graph,
vx_scalar  condition,
vx_reference  true_value,
vx_reference  false_value,
vx_reference  output 
)

[Graph] Selects one of two data objects depending on the the value of a condition (boolean scalar), and copies its data into another data object.

This node supports predicated execution flow within a graph. All the data objects passed to this kernel shall have the same object type and meta data. It is important to note that an implementation may optimize away the select and copy when virtual data objects are used.
If there is a kernel node that contribute only into virtual data objects during the graph execution due to certain data path being eliminated by not taken argument of select node, then the OpenVX implementation guarantees that there will not be any side effects to graph execution and node state.
If the path to a select node contains non-virtual objects, user nodes, or nodes with completion callbacks, then that path may not be "optimized out" because the callback must be executed and the non-virtual objects must be modified.

Parameters
[in]graphThe reference to the graph.
[in]conditionVX_TYPE_BOOL predicate variable.
[in]true_valueData object for true.
[in]false_valueData object for false.
[out]outputOutput data object.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxSobel3x3Node()

VX_API_ENTRY vx_node VX_API_CALL vxSobel3x3Node ( vx_graph  graph,
vx_image  input,
vx_image  output_x,
vx_image  output_y 
)

[Graph] Creates a Sobel3x3 node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 format.
[out]output_x[optional] The output gradient in the x direction in VX_DF_IMAGE_S16. Must have the same dimensions as the input image.
[out]output_y[optional] The output gradient in the y direction in VX_DF_IMAGE_S16. Must have the same dimensions as the input image.
See also
VX_KERNEL_SOBEL_3x3
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxSubtractNode()

VX_API_ENTRY vx_node VX_API_CALL vxSubtractNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_enum  policy,
vx_image  out 
)

[Graph] Creates an arithmetic subtraction node.

Parameters
[in]graphThe reference to the graph.
[in]in1An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16, the minuend.
[in]in2An input image, VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16, the subtrahend.
[in]policyA VX_TYPE_ENUM of the vx_convert_policy_e enumeration.
[out]outThe output image, a VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16 image, which must have the same dimensions as the input images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxTableLookupNode()

VX_API_ENTRY vx_node VX_API_CALL vxTableLookupNode ( vx_graph  graph,
vx_image  input,
vx_lut  lut,
vx_image  output 
)

[Graph] Creates a Table Lookup node. If a value from the input image is not present in the lookup table, the result is undefined.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input image in VX_DF_IMAGE_U8 or VX_DF_IMAGE_S16.
[in]lutThe LUT which is of type VX_TYPE_UINT8 if input image is VX_DF_IMAGE_U8 or VX_TYPE_INT16 if input image is VX_DF_IMAGE_S16.
[out]outputThe output image of the same size as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorAddNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorAddNode ( vx_graph  graph,
vx_tensor  input1,
vx_tensor  input2,
vx_enum  policy,
vx_tensor  output 
)

[Graph] Performs arithmetic addition on element values in the input tensor data.

Parameters
[in]graphThe handle to the graph.
[in]input1Input tensor data. Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8 and VX_TYPE_INT8, with fixed_point_position 0.
[in]input2Input tensor data. The dimensions and sizes of input2 match those of input1, unless the vx_tensor of one or more dimensions in input2 is 1. In this case, those dimensions are treated as if this tensor was expanded to match the size of the corresponding dimension of input1, and data was duplicated on all terms in that dimension. After this expansion, the dimensions will be equal. The data type must match the data type of Input1.
[in]policyA vx_convert_policy_e enumeration.
[out]outputThe output tensor data with the same dimensions as the input tensor data.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorConvertDepthNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorConvertDepthNode ( vx_graph  graph,
vx_tensor  input,
vx_enum  policy,
vx_scalar  norm,
vx_scalar  offset,
vx_tensor  output 
)

[Graph] Creates a bit-depth conversion node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input tensor. Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8 and VX_TYPE_INT8, with fixed_point_position 0.
[in]policyA VX_TYPE_ENUM of the vx_convert_policy_e enumeration.
[in]normA scalar containing a VX_TYPE_FLOAT32 of the normalization value.
[in]offsetA scalar containing a VX_TYPE_FLOAT32 of the offset value subtracted before normalization.
[out]outputThe output tensor. Implementations must support input tensor data type VX_TYPE_INT16. with fixed_point_position 8. And VX_TYPE_UINT8 with fixed_point_position 0.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxTensorMatrixMultiplyNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorMatrixMultiplyNode ( vx_graph  graph,
vx_tensor  input1,
vx_tensor  input2,
vx_tensor  input3,
const vx_tensor_matrix_multiply_params_t matrix_multiply_params,
vx_tensor  output 
)

[Graph] Creates a generalized matrix multiplication node.

Parameters
[in]graphThe reference to the graph.
[in]input1The first input 2D tensor of type VX_TYPE_INT16 with fixed_point_pos 8, or tensor data types VX_TYPE_UINT8 or VX_TYPE_INT8, with fixed_point_pos 0.
[in]input2The second 2D tensor. Must be in the same data type as input1.
[in]input3The third 2D tensor. Must be in the same data type as input1. [optional].
[in]matrix_multiply_paramsMatrix multiply parameters, see vx_tensor_matrix_multiply_params_t .
[out]outputThe output 2D tensor. Must be in the same data type as input1. Output dimension must agree the formula in the description.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorMultiplyNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorMultiplyNode ( vx_graph  graph,
vx_tensor  input1,
vx_tensor  input2,
vx_scalar  scale,
vx_enum  overflow_policy,
vx_enum  rounding_policy,
vx_tensor  output 
)

[Graph] Performs element wise multiplications on element values in the input tensor data with a scale.

Parameters
[in]graphThe handle to the graph.
[in]input1Input tensor data. Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8 and VX_TYPE_INT8, with fixed_point_position 0.
[in]input2Input tensor data. The dimensions and sizes of input2 match those of input1, unless the vx_tensor of one or more dimensions in input2 is 1. In this case, those dimensions are treated as if this tensor was expanded to match the size of the corresponding dimension of input1, and data was duplicated on all terms in that dimension. After this expansion, the dimensions will be equal. The data type must match the data type of Input1.
[in]scaleA non-negative VX_TYPE_FLOAT32 multiplied to each product before overflow handling.
[in]overflow_policyA vx_convert_policy_e enumeration.
[in]rounding_policyA vx_round_policy_e enumeration.
[out]outputThe output tensor data with the same dimensions as the input tensor data.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorSubtractNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorSubtractNode ( vx_graph  graph,
vx_tensor  input1,
vx_tensor  input2,
vx_enum  policy,
vx_tensor  output 
)

[Graph] Performs arithmetic subtraction on element values in the input tensor data.

Parameters
[in]graphThe handle to the graph.
[in]input1Input tensor data. Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8 and VX_TYPE_INT8, with fixed_point_position 0.
[in]input2Input tensor data. The dimensions and sizes of input2 match those of input1, unless the vx_tensor of one or more dimensions in input2 is 1. In this case, those dimensions are treated as if this tensor was expanded to match the size of the corresponding dimension of input1, and data was duplicated on all terms in that dimension. After this expansion, the dimensions will be equal. The data type must match the data type of Input1.
[in]policyA vx_convert_policy_e enumeration.
[out]outputThe output tensor data with the same dimensions as the input tensor data.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorTableLookupNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorTableLookupNode ( vx_graph  graph,
vx_tensor  input1,
vx_lut  lut,
vx_tensor  output 
)

[Graph] Performs LUT on element values in the input tensor data.

Parameters
[in]graphThe handle to the graph.
[in]input1Input tensor data. Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8, with fixed_point_position 0.
[in]lutThe look-up table to use, of type vx_lut. The elements of input1 are treated as unsigned integers to determine an index into the look-up table. The data type of the items in the look-up table must match that of the output tensor.
[out]outputThe output tensor data with the same dimensions as the input tensor data.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxTensorTransposeNode()

VX_API_ENTRY vx_node VX_API_CALL vxTensorTransposeNode ( vx_graph  graph,
vx_tensor  input,
vx_tensor  output,
vx_size  dimension1,
vx_size  dimension2 
)

[Graph] Performs transpose on the input tensor. The node transpose the tensor according to a specified 2 indexes in the tensor (0-based indexing)

Parameters
[in]graphThe handle to the graph.
[in]inputInput tensor data, Implementations must support input tensor data type VX_TYPE_INT16 with fixed_point_position 8, and tensor data types VX_TYPE_UINT8 and VX_TYPE_INT8, with fixed_point_position 0.
[out]outputoutput tensor data,
[in]dimension1Dimension index that is transposed with dim 2.
[in]dimension2Dimension index that is transposed with dim 1.
Returns
vx_node.
A node reference vx_node. Any possible errors preventing a successful creation should be checked using vxGetStatus.

◆ vxThresholdNode()

VX_API_ENTRY vx_node VX_API_CALL vxThresholdNode ( vx_graph  graph,
vx_image  input,
vx_threshold  thresh,
vx_image  output 
)

[Graph] Creates a Threshold node and returns a reference to it.

Parameters
[in]graphThe reference to the graph in which the node is created.
[in]inputThe input image. Only images with format VX_DF_IMAGE_U8 and VX_DF_IMAGE_S16 are supported.
[in]threshThe thresholding object that defines the parameters of the operation. The VX_THRESHOLD_INPUT_FORMAT must be the same as the input image format and the VX_THRESHOLD_OUTPUT_FORMAT must be the same as the output image format.
[out]outputThe output image, that will contain as pixel value true and false values defined by thresh. Images with format VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 are supported. The dimensions are the same as the input image.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxWarpAffineNode()

VX_API_ENTRY vx_node VX_API_CALL vxWarpAffineNode ( vx_graph  graph,
vx_image  input,
vx_matrix  matrix,
vx_enum  type,
vx_image  output 
)

[Graph] Creates an Affine Warp Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 image.
[in]matrixThe affine matrix. Must be 2x3 of type VX_TYPE_FLOAT32.
[in]typeThe interpolation type from vx_interpolation_type_e. VX_INTERPOLATION_AREA is not supported.
[out]outputThe output VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 image with the same format as the input image.
Note
The border modes VX_NODE_BORDER value VX_BORDER_UNDEFINED and VX_BORDER_CONSTANT are supported.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxWarpPerspectiveNode()

VX_API_ENTRY vx_node VX_API_CALL vxWarpPerspectiveNode ( vx_graph  graph,
vx_image  input,
vx_matrix  matrix,
vx_enum  type,
vx_image  output 
)

[Graph] Creates a Perspective Warp Node.

Parameters
[in]graphThe reference to the graph.
[in]inputThe input VX_DF_IMAGE_U8 image.
[in]matrixThe perspective matrix. Must be 3x3 of type VX_TYPE_FLOAT32.
[in]typeThe interpolation type from vx_interpolation_type_e. VX_INTERPOLATION_AREA is not supported.
[out]outputThe output VX_DF_IMAGE_U8 image.
Note
The border modes VX_NODE_BORDER value VX_BORDER_UNDEFINED and VX_BORDER_CONSTANT are supported.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxWeightedAverageNode()

VX_API_ENTRY vx_node VX_API_CALL vxWeightedAverageNode ( vx_graph  graph,
vx_image  img1,
vx_scalar  alpha,
vx_image  img2,
vx_image  output 
)

[Graph] Creates a image weighted average node.

Parameters
[in]graphThe reference to the graph.
[in]img1The first input VX_DF_IMAGE_U8 image.
[in]alphaThe input VX_TYPE_FLOAT32 scalar value with a value in the range of \( 0.0 \le \alpha \le 1.0 \).
[in]img2The second VX_DF_IMAGE_U8 image, which must have the same dimensions as the img1.
[out]outputThe output VX_DF_IMAGE_U8 image, which must have the same dimensions as the img1.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus

◆ vxXorNode()

VX_API_ENTRY vx_node VX_API_CALL vxXorNode ( vx_graph  graph,
vx_image  in1,
vx_image  in2,
vx_image  out 
)

[Graph] Creates a bitwise EXCLUSIVE OR node.

Parameters
[in]graphThe reference to the graph.
[in]in1A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[in]in2A VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 input image.
[out]outThe VX_DF_IMAGE_U8 or VX_DF_IMAGE_U1 output image, which must have the same dimensions and type as the input images.
Returns
vx_node.
Return values
vx_nodeA node reference. Any possible errors preventing a successful creation should be checked using vxGetStatus