VisionWorks Toolkit Reference

September 29, 2015 | 1.0 Release

 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
nvx.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012-2015, NVIDIA CORPORATION. All rights reserved.
3  *
4  * NVIDIA Corporation and its licensors retain all intellectual property
5  * and proprietary rights in and to this software, related documentation
6  * and any modifications thereto. Any use, reproduction, disclosure or
7  * distribution of this software and related documentation without an express
8  * license agreement from NVIDIA Corporation is strictly prohibited.
9  */
10 
16 #ifndef __NVX_H__
17 #define __NVX_H__
18 
19 //----------------------------------------------------------------------------
20 // Include
21 //----------------------------------------------------------------------------
22 
23 #include <VX/vx.h>
24 #include <VX/vxu.h>
25 
26 #include "nvx_export.h"
27 
28 //----------------------------------------------------------------------------
29 // Macros
30 //----------------------------------------------------------------------------
31 
32 #ifndef NVX_EXTERN_C
33 # ifdef __cplusplus
34 # define NVX_EXTERN_C extern "C"
35 # else
36 # define NVX_EXTERN_C
37 # endif
38 #endif
39 
40 #ifndef NVX_C_API
41  #define NVX_C_API NVX_EXTERN_C NVX_EXPORT
42 #endif
43 
44 #ifndef NVX_CXX_API
45  #define NVX_CXX_API NVX_EXPORT
46 #endif
47 
52 enum nvx_enum_e {
54 };
55 
56 
57 //----------------------------------------------------------------------------
58 // Framework : Version Information
59 //----------------------------------------------------------------------------
60 
65 typedef struct _nvx_version_info_t {
69  char visionworks_suffix_version[10];
75 
82 NVX_C_API void nvxGetVersionInfo(nvx_version_info_t *info);
83 
84 
85 //----------------------------------------------------------------------------
86 // Framework : User Kernel Extension
87 //----------------------------------------------------------------------------
88 
100 };
101 
114 NVX_C_API vx_status nvxSetKernelParameterMutability(vx_kernel kernel, vx_uint32 index, vx_enum mutability);
115 
116 //----------------------------------------------------------------------------
117 // Framework : Types Extensions
118 //----------------------------------------------------------------------------
119 
133 };
134 
142 };
143 
148 #define NVX_LIBRARY_NVIDIA (0x0)
149 
179 };
180 
181 //----------------------------------------------------------------------------
182 // Framework : Point Types
183 //----------------------------------------------------------------------------
184 
189 typedef struct _nvx_point2f_t {
192 } nvx_point2f_t;
193 
198 typedef struct _nvx_point3f_t {
202 } nvx_point3f_t;
203 
208 typedef struct _nvx_point4f_t {
213 } nvx_point4f_t;
214 
215 //----------------------------------------------------------------------------
216 // Framework : KeyPoint Types
217 //----------------------------------------------------------------------------
218 
223 typedef struct _nvx_keypointf_t {
232 
254 
259 
264 };
265 
266 //----------------------------------------------------------------------------
267 // Framework : Image Extensions
268 //----------------------------------------------------------------------------
269 
276  NVX_DF_IMAGE_F32 = VX_DF_IMAGE('F','0','3','2'),
277 
279  NVX_DF_IMAGE_2F32 = VX_DF_IMAGE('2','F','3','2'),
280 
285  NVX_DF_IMAGE_RGB16 = VX_DF_IMAGE('S','3','1','6'),
286 };
287 
303 NVX_C_API vx_image nvxCreateImageFromChannel(vx_image imgref, vx_channel_e channel);
304 
305 //----------------------------------------------------------------------------
306 // Framework : CUDA Interoperability
307 //----------------------------------------------------------------------------
308 
320 };
321 
329 };
330 
331 //----------------------------------------------------------------------------
332 // Framework : Context Extensions
333 //----------------------------------------------------------------------------
334 
357 };
358 
359 //----------------------------------------------------------------------------
360 // Framework : Resource control
361 //----------------------------------------------------------------------------
362 
368 {
373 };
374 
393 
394 //----------------------------------------------------------------------------
395 // Framework : Reference extension
396 //----------------------------------------------------------------------------
397 
421 
444 NVX_C_API vx_status nvxReleaseReferenceList(vx_reference ref_list[], vx_size num_refs);
445 
446 //----------------------------------------------------------------------------
447 // Framework : Graph Extension
448 //----------------------------------------------------------------------------
449 
473 
496 };
497 
527 NVX_C_API vx_graph nvxCreateStreamGraph(vx_context context);
528 
554 NVX_C_API vx_status nvxRegisterAutoAging(vx_graph graph, vx_delay delay);
555 
556 //----------------------------------------------------------------------------
557 // Primitive : Harris Track
558 //----------------------------------------------------------------------------
559 
590 NVX_C_API vx_node nvxHarrisTrackNode(vx_graph graph, vx_image input, vx_array output,
591  vx_image mask, vx_array tracked_points,
592  vx_float32 k, vx_float32 threshold, vx_uint32 cell_size,
593  vx_scalar num_corners);
594 
633 NVX_C_API vx_status nvxuHarrisTrack(vx_context context, vx_image input, vx_array output,
634  vx_image mask, vx_array tracked_points,
635  vx_float32 k, vx_float32 threshold, vx_uint32 cell_size,
636  vx_scalar num_corners);
637 
638 //----------------------------------------------------------------------------
639 // Primitive : FAST Track
640 //----------------------------------------------------------------------------
641 
673 NVX_C_API vx_node nvxFastTrackNode(vx_graph graph, vx_image input, vx_array output,
674  vx_image mask, vx_array tracked_points,
675  vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size,
676  vx_scalar num_corners);
677 
717 NVX_C_API vx_status nvxuFastTrack(vx_context context, vx_image input, vx_array output,
718  vx_image mask, vx_array tracked_points,
719  vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size,
720  vx_scalar num_corners);
721 
722 //----------------------------------------------------------------------------
723 // Primitive : Semi-Global Matching
724 //----------------------------------------------------------------------------
725 
747 };
748 
770  vx_image left,
771  vx_image right,
772  vx_image disparity,
773  vx_int32 minD,
774  vx_int32 maxD,
775  vx_int32 P1,
776  vx_int32 P2,
777  vx_int32 sad,
778  vx_int32 clip,
779  vx_int32 max_diff,
780  vx_int32 uniqueness,
781  vx_enum scanlines_mask);
782 
804  vx_image left,
805  vx_image right,
806  vx_image disparity,
807  vx_int32 minD,
808  vx_int32 maxD,
809  vx_int32 P1,
810  vx_int32 P2,
811  vx_int32 sad,
812  vx_int32 clip,
813  vx_int32 max_diff,
814  vx_int32 uniqueness,
815  vx_enum scanlines_mask);
816 
817 //----------------------------------------------------------------------------
818 // Primitive : Copy Image
819 //----------------------------------------------------------------------------
820 
835 NVX_C_API vx_node nvxCopyImageNode(vx_graph graph,
836  vx_image src,
837  vx_image dst);
838 
859 NVX_C_API vx_status nvxuCopyImage(vx_context context,
860  vx_image src,
861  vx_image dst);
862 
863 //----------------------------------------------------------------------------
864 // Primitive : Flip Image
865 //----------------------------------------------------------------------------
866 
872 {
876 };
877 
893 NVX_C_API vx_node nvxFlipImageNode(vx_graph graph, vx_image input, vx_image output, vx_enum flip_mode);
894 
916 NVX_C_API vx_status nvxuFlipImage(vx_context context, vx_image input, vx_image output, vx_enum flip_mode);
917 
918 //----------------------------------------------------------------------------
919 // Primitive : Hough Circles
920 //----------------------------------------------------------------------------
921 
964 NVX_C_API vx_node nvxHoughCirclesNode(vx_graph graph,
965  vx_image edges, vx_image dx, vx_image dy,
966  vx_array circles, vx_scalar s_num_detections,
967  vx_float32 dp, vx_float32 minDist,
968  vx_uint32 minRadius, vx_uint32 maxRadius,
969  vx_uint32 acc_threshold);
970 
1021 NVX_C_API vx_status nvxuHoughCircles(vx_context context,
1022  vx_image edges, vx_image dx, vx_image dy,
1023  vx_array circles, vx_scalar s_num_detections,
1024  vx_float32 dp, vx_float32 minDist,
1025  vx_uint32 minRadius, vx_uint32 maxRadius,
1026  vx_uint32 acc_threshold);
1027 
1028 //----------------------------------------------------------------------------
1029 // Primitive : Hough Lines
1030 //----------------------------------------------------------------------------
1031 
1056 NVX_C_API vx_node nvxHoughLinesNode(vx_graph graph, vx_image input, vx_array output,
1057  vx_float32 rho, vx_float32 theta, vx_uint32 threshold,
1058  vx_scalar num_lines);
1059 
1092 NVX_C_API vx_status nvxuHoughLines(vx_context context, vx_image input, vx_array output,
1093  vx_float32 rho, vx_float32 theta, vx_uint32 threshold,
1094  vx_scalar num_lines);
1095 
1123 NVX_C_API vx_node nvxHoughSegmentsNode(vx_graph graph, vx_image input, vx_array output,
1124  vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap,
1125  vx_scalar num_segments);
1126 
1162 NVX_C_API vx_status nvxuHoughSegments(vx_context context, vx_image input, vx_array output,
1163  vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap,
1164  vx_scalar num_segments);
1165 
1166 //----------------------------------------------------------------------------
1167 // Primitive : Scharr3x3
1168 //----------------------------------------------------------------------------
1169 
1185 NVX_C_API vx_node nvxScharr3x3Node(vx_graph graph, vx_image input, vx_image grad_x, vx_image grad_y);
1186 
1210 NVX_C_API vx_status nvxuScharr3x3(vx_context context, vx_image input, vx_image grad_x, vx_image grad_y);
1211 
1212 //----------------------------------------------------------------------------
1213 // Primitive : Laplacian
1214 //----------------------------------------------------------------------------
1215 
1228 NVX_C_API vx_node nvxLaplacian3x3Node(vx_graph graph, vx_image input, vx_image output);
1229 
1250 NVX_C_API vx_status nvxuLaplacian3x3(vx_context context, vx_image input, vx_image output);
1251 
1252 //----------------------------------------------------------------------------
1253 // Primitive : Median Flow
1254 //----------------------------------------------------------------------------
1255 
1280 NVX_C_API vx_node nvxMedianFlowNode(vx_graph graph, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out,
1281  vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh);
1282 
1315 NVX_C_API vx_status nvxuMedianFlow(vx_context context, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out,
1316  vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh);
1317 //----------------------------------------------------------------------------
1318 // Primitive : Stereo Block Matching
1319 //----------------------------------------------------------------------------
1320 
1340 NVX_C_API vx_node nvxStereoBlockMatchingNode(vx_graph graph, vx_image left, vx_image right, vx_image disp, vx_uint32 winSize, vx_uint32 maxDisparity);
1341 
1369 NVX_C_API vx_status nvxuStereoBlockMatching(vx_context context, vx_image left, vx_image right, vx_image disp, vx_uint32 winSize, vx_uint32 maxDisparity);
1370 
1371 #endif
struct _vx_image * vx_image
An opaque reference to an image.
Definition: vx_types.h:186
vx_status nvxuFlipImage(vx_context context, vx_image input, vx_image output, vx_enum flip_mode)
[Immediate] Flips the input image.
vx_status nvxuHoughCircles(vx_context context, vx_image edges, vx_image dx, vx_image dy, vx_array circles, vx_scalar s_num_detections, vx_float32 dp, vx_float32 minDist, vx_uint32 minRadius, vx_uint32 maxRadius, vx_uint32 acc_threshold)
[Immediate] Detects circles in a binary image.
struct _vx_delay * vx_delay
The delay object. This is like a ring buffer of objects that is maintained by the OpenVX implementati...
Definition: vx_types.h:230
vx_bool
A Boolean value. This allows 0 to be FALSE, as it is in C, and any non-zero to be TRUE...
Definition: vx_types.h:292
aggregate cost from left to right diagonally starting from the bottom.
Definition: nvx.h:739
vx_node nvxHarrisTrackNode(vx_graph graph, vx_image input, vx_array output, vx_image mask, vx_array tracked_points, vx_float32 k, vx_float32 threshold, vx_uint32 cell_size, vx_scalar num_corners)
[Graph] Detects and tracks Harris corners for the input image.
Any device.
Definition: nvx.h:369
nvx_accessor_e
Extended memory accessors.
Definition: nvx.h:313
A floating value for vendor-defined struct base index.
Definition: vx_types.h:348
Defines a 4D point (float coordinates).
Definition: nvx.h:208
Indicates that the CUDA-capable GPU is not supported.
Definition: nvx.h:141
vx_float32 y
Holds the y coordinate.
Definition: nvx.h:225
Specifies Laplacian 3 x 3 Kernel.
Definition: nvx.h:174
Specifies Median Flow Kernel.
Definition: nvx.h:176
NVIDIA Corporation.
Definition: vx_vendors.h:40
nvx_type_e
Defines additional types.
Definition: nvx.h:124
struct _vx_array * vx_array
The Array Object. Array is a strongly-typed container for other data structures.
Definition: vx_types.h:279
vx_status nvxSetNodeTargetDevice(vx_node node, nvx_device_type_e device)
Sets the target device type for the node.
Specifies Hough Lines Kernel.
Definition: nvx.h:166
A Change of the parameter meta-data implies a node re-initialization.
Definition: nvx.h:97
size_t vx_size
A wrapper of size_t to keep the naming convention uniform.
Definition: vx_types.h:166
vx_node nvxFastTrackNode(vx_graph graph, vx_image input, vx_array output, vx_image mask, vx_array tracked_points, vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size, vx_scalar num_corners)
[Graph] Detects and tracks corners using the FAST algorithm.
void nvxGetVersionInfo(nvx_version_info_t *info)
Gets information about VisionWorks library version.
Defines a 2D point (float coordinates).
Definition: nvx.h:189
VisionWorks library version information.
Definition: nvx.h:65
A floating value used for bound checking the VisionWorks object types.
Definition: nvx.h:132
int32_t vx_enum
Sets the standard enumeration type size to be a fixed quantity.
Definition: vx_types.h:161
int32_t vx_int32
A 32-bit signed value.
Definition: vx_types.h:120
Vertical flipping of the image.
Definition: nvx.h:874
vx_status nvxuMedianFlow(vx_context context, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out, vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh)
[Immediate] Computes median flow.
nvx_keypoint_directive_e
Defines directives that control primitives behavior with keypoint data type.
Definition: nvx.h:248
nvx_scanline_e
Defines scan line's directions used during cost aggregation step.
Definition: nvx.h:730
Use default behavior.
Definition: nvx.h:263
nvx_import_type_e
Extended import type.
Definition: nvx.h:326
WO with CUDA pointer.
Definition: nvx.h:317
vx_float32 scale
Holds the scale initialized to 0 by corner detectors.
Definition: nvx.h:227
A Change of the parameter meta-data or value implies a node re-initialization.
Definition: nvx.h:99
nvx_mutability_e
Defines the mutability state of custom kernel parameter.
Definition: nvx.h:93
vx_uint32 openvx_patch_version
Patch version of OpenVX standard implemented by VisionWorks library.
Definition: nvx.h:73
float vx_float32
A 32-bit float value.
Definition: vx_types.h:138
vx_node nvxMedianFlowNode(vx_graph graph, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out, vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh)
[Graph] Computes median flow.
vx_uint32 visionworks_minor_version
Minor version of VisionWorks library.
Definition: nvx.h:67
vx_status nvxuHoughSegments(vx_context context, vx_image input, vx_array output, vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap, vx_scalar num_segments)
[Immediate] Finds line segments in a binary image using the probabilistic Hough transform.
vx_uint32 openvx_major_version
Major version of OpenVX standard implemented by VisionWorks library.
Definition: nvx.h:71
A single plane of 48 bit pixels as 3 interleaved 16 bit signed integers of R then G then B data...
Definition: nvx.h:285
vx_node nvxFlipImageNode(vx_graph graph, vx_image input, vx_image output, vx_enum flip_mode)
[Graph] Flips the input image.
Specifies FAST Track Kernel.
Definition: nvx.h:158
aggregate cost from four directions forming a cross.
Definition: nvx.h:741
vx_enum vx_status
A formal status type with known fixed size.
Definition: vx_types.h:421
vx_status nvxuScharr3x3(vx_context context, vx_image input, vx_image grad_x, vx_image grad_y)
[Immediate] Applies Scharr 3 x 3 operator.
vx_status nvxuHarrisTrack(vx_context context, vx_image input, vx_array output, vx_image mask, vx_array tracked_points, vx_float32 k, vx_float32 threshold, vx_uint32 cell_size, vx_scalar num_corners)
[Immediate] Detects and tracks Harris corners for the input image.
#define VX_ENUM_BASE(vendor, id)
Defines the manner in which to combine the Vendor and Object IDs to get the base value of the enumera...
struct _vx_context * vx_context
An opaque reference to the implementation context.
Definition: vx_types.h:222
aggregate cost from right to left diagonally starting from the bottom.
Definition: nvx.h:737
Enables keypoint's error calculation by optical flow and similar primitives.
Definition: nvx.h:258
struct _vx_reference * vx_reference
A generic opaque reference to any object within OpenVX.
Definition: vx_types.h:154
vx_float32 orientation
Holds the orientation initialized to 0 by corner detectors.
Definition: nvx.h:228
vx_float32 y
The Y coordinate.
Definition: nvx.h:191
vx_uint32 visionworks_major_version
Major version of VisionWorks library.
Definition: nvx.h:66
vx_node nvxLaplacian3x3Node(vx_graph graph, vx_image input, vx_image output)
[Graph] Creates a Laplacian filter node.
vx_float32 z
The Z coordinate.
Definition: nvx.h:201
vx_int32 tracking_status
Holds tracking status. Zero indicates a lost point. Initialized to 1 by corner detectors.
Definition: nvx.h:229
nvx_kernel_e
Defines a list of extended vision kernels.
Definition: nvx.h:154
aggregate cost from left to right diagonally starting from the top.
Definition: nvx.h:732
#define NVX_LIBRARY_NVIDIA
The extended set of kernels provided by NVIDIA.
Definition: nvx.h:148
Specifies Hough Circles Kernel.
Definition: nvx.h:170
Horizontal flipping of the image.
Definition: nvx.h:873
vx_status nvxuSemiGlobalMatching(vx_context context, vx_image left, vx_image right, vx_image disparity, vx_int32 minD, vx_int32 maxD, vx_int32 P1, vx_int32 P2, vx_int32 sad, vx_int32 clip, vx_int32 max_diff, vx_int32 uniqueness, vx_enum scanlines_mask)
[Immediate] evaluate disparity given 2 stereo images using the SGM algorithm.
vx_node nvxScharr3x3Node(vx_graph graph, vx_image input, vx_image grad_x, vx_image grad_y)
[Graph] Applies Scharr 3 x 3 operator.
vx_float32 error
Holds a tracking method-specific error. Initialized to 0 by corner detectors.
Definition: nvx.h:230
Specifies Scharr 3 x 3 Kernel.
Definition: nvx.h:172
vx_float32 x
The X coordinate.
Definition: nvx.h:209
The memory import enumeration.
Definition: vx_types.h:557
A nvx_point3f_t.
Definition: nvx.h:126
RW with CUDA pointer.
Definition: nvx.h:319
vx_float32 x
The X coordinate.
Definition: nvx.h:199
A nvx_keypointf_t.
Definition: nvx.h:128
A vx_context.
Definition: vx_types.h:357
GPU device.
Definition: nvx.h:372
A floating value for comparison between structs and objects.
Definition: nvx.h:130
vx_node nvxCopyImageNode(vx_graph graph, vx_image src, vx_image dst)
[Graph] Copies data from one image to another.
vx_node nvxHoughSegmentsNode(vx_graph graph, vx_image input, vx_array output, vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap, vx_scalar num_segments)
[Graph] Finds line segments in a binary image using the probabilistic Hough transform.
vx_status nvxuStereoBlockMatching(vx_context context, vx_image left, vx_image right, vx_image disp, vx_uint32 winSize, vx_uint32 maxDisparity)
[Immediate] This primitive computes a dense disparity map for a given stereo pair.
Directive Values.
Definition: vx_types.h:546
vx_float32 y
The Y coordinate.
Definition: nvx.h:200
aggregate cost from right to left diagonally starting from the top.
Definition: nvx.h:734
vx_status nvxRegisterAutoAging(vx_graph graph, vx_delay delay)
Registers a delay for auto-aging.
nvx_context_attribute_e
The extended context attributes list.
Definition: nvx.h:339
A Change of the parameter does not imply a node re-initialization.
Definition: nvx.h:95
A nvx_point4f_t.
Definition: nvx.h:127
An accessor flag type.
Definition: vx_types.h:560
struct _vx_kernel * vx_kernel
An opaque reference to the descriptor of a kernel.
Definition: vx_types.h:194
vx_node nvxStereoBlockMatchingNode(vx_graph graph, vx_image left, vx_image right, vx_image disp, vx_uint32 winSize, vx_uint32 maxDisparity)
[Graph] This primitive computes a dense disparity map for a given stereo pair.
The CUDA import memory type.
Definition: nvx.h:328
Specifies Hough Segments Kernel.
Definition: nvx.h:168
Specifies Flip Image Kernel.
Definition: nvx.h:160
nvx_status_e
Defines additional error codes.
Definition: nvx.h:139
aggregate cost from right to left horizontally.
Definition: nvx.h:736
vx_image nvxCreateImageFromChannel(vx_image imgref, vx_channel_e channel)
Creates an image from a single channel of another image.
#define VX_DF_IMAGE(a, b, c, d)
Converts a set of four chars into a uint32_t container of a VX_DF_IMAGE code.
vx_status nvxuCopyImage(vx_context context, vx_image src, vx_image dst)
[Immediate] Copies data from one image to another.
vx_channel_e
The channel enumerations for channel extractions.
Definition: vx_types.h:1009
Parameter mutability.
Definition: nvx.h:53
vx_float32 y
The Y coordinate.
Definition: nvx.h:210
vx_uint32 openvx_minor_version
Minor version of OpenVX standard implemented by VisionWorks library.
Definition: nvx.h:72
The top level OpenVX Header.
A floating value for vendor defined object base index.
Definition: vx_types.h:378
Defines a 3D point (float coordinates).
Definition: nvx.h:198
aggregate cost over all scan lines.
Definition: nvx.h:746
A single plane of vx_float32 data.
Definition: nvx.h:276
Sets the graph verification options.
Definition: nvx.h:472
vx_node nvxHoughLinesNode(vx_graph graph, vx_image input, vx_array output, vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_scalar num_lines)
[Graph] Finds lines on image using standard Hough transform.
Simultaneous horizontal and vertical flipping of the image.
Definition: nvx.h:875
vx_float32 z
The Z coordinate.
Definition: nvx.h:211
vx_float32 strength
Holds the strength of the keypoint. Its definition is specific to the corner detector.
Definition: nvx.h:226
vx_node nvxSemiGlobalMatchingNode(vx_graph graph, vx_image left, vx_image right, vx_image disparity, vx_int32 minD, vx_int32 maxD, vx_int32 P1, vx_int32 P2, vx_int32 sad, vx_int32 clip, vx_int32 max_diff, vx_int32 uniqueness, vx_enum scanlines_mask)
[Graph] evaluate disparity given 2 stereo images using the SGM algorithm.
nvx_df_image_e
Defines additional image formats.
Definition: nvx.h:274
Specifies Harris Track Kernel.
Definition: nvx.h:156
nvx_graph_attribute_e
The extended graph attributes list.
Definition: nvx.h:454
CPU device.
Definition: nvx.h:371
The OpenVX Utility Library.
Preferred target device for the immediate primitive execution mode (use a nvx_device_type_e).
Definition: nvx.h:356
Informs if graph verification is needed before graph execution.
Definition: nvx.h:495
vx_status nvxuFastTrack(vx_context context, vx_image input, vx_array output, vx_image mask, vx_array tracked_points, vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size, vx_scalar num_corners)
[Immediate] Detects and tracks corners using the FAST algorithm.
uint32_t vx_uint32
A 32-bit unsigned value.
Definition: vx_types.h:100
Indicates that no CUDA-capable GPU was found.
Definition: nvx.h:140
aggregate cost from left to right horizontally.
Definition: nvx.h:731
vx_float32 x
Holds the x coordinate.
Definition: nvx.h:224
vx_status nvxSetKernelParameterMutability(vx_kernel kernel, vx_uint32 index, vx_enum mutability)
Allows users to set the mutability of the custom kernel. By default, kernel parameters are set to NVX...
#define VX_KERNEL_BASE(vendor, lib)
Defines the manner in which to combine the Vendor and Library IDs to get the base value of the enumer...
Specifies Copy Image Kernel.
Definition: nvx.h:162
aggregate cost from top to bottom vertically.
Definition: nvx.h:733
Specifies Stereo Block Matching Kernel.
Definition: nvx.h:178
A nvx_point2f_t.
Definition: nvx.h:125
vx_float32 w
The W coordinate.
Definition: nvx.h:212
nvx_enum_e
Defines the additional set of supported enumerations.
Definition: nvx.h:52
Defines a keypoint data structure.
Definition: nvx.h:223
nvx_device_type_e
Defines types of devices that can execute vision functions.
Definition: nvx.h:367
struct _vx_graph * vx_graph
An opaque reference to a graph.
Definition: vx_types.h:215
A single plane of vx_float32[2] data (eg.
Definition: nvx.h:279
vx_status nvxuHoughLines(vx_context context, vx_image input, vx_array output, vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_scalar num_lines)
[Immediate] Finds lines on image using standard Hough transform.
struct _vx_node * vx_node
An opaque reference to a kernel node.
Definition: vx_types.h:208
vx_node nvxHoughCirclesNode(vx_graph graph, vx_image edges, vx_image dx, vx_image dy, vx_array circles, vx_scalar s_num_detections, vx_float32 dp, vx_float32 minDist, vx_uint32 minRadius, vx_uint32 maxRadius, vx_uint32 acc_threshold)
[Graph] Detects circles in a binary image.
Specifies Semi Global Matching Kernel.
Definition: nvx.h:164
vx_graph nvxCreateStreamGraph(vx_context context)
Creates an empty graph as a node stream.
struct _vx_scalar * vx_scalar
An opaque reference to a scalar.
Definition: vx_types.h:179
A vx_graph.
Definition: vx_types.h:358
vx_status nvxReleaseReferenceList(vx_reference ref_list[], vx_size num_refs)
Releases a list of references to OpenVX objects.
aggregate cost from bottom to top vertically.
Definition: nvx.h:738
nvx_flip_mode_e
Defines modes for flip image operation.
Definition: nvx.h:871
Disables keypoint's error calculation by optical flow and similar primitives.
Definition: nvx.h:253
vx_status nvxuLaplacian3x3(vx_context context, vx_image input, vx_image output)
[Immediate] Applies a Laplacian operator to the input image.
vx_status nvxRetainReference(vx_reference ref)
Increments the reference counter of an object.
RO with CUDA pointer.
Definition: nvx.h:315
vx_uint32 visionworks_patch_version
Patch version of VisionWorks library.
Definition: nvx.h:68
vx_float32 x
The X coordinate.
Definition: nvx.h:190