VisionWorks Toolkit Reference

December 18, 2015 | 1.2 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[12];
75 
80 typedef struct _nvx_module_version_t {
84  char suffix[12];
86 
93 NVX_C_API void nvxGetVersionInfo(nvx_version_info_t *info);
94 
95 
96 //----------------------------------------------------------------------------
97 // Framework : User Kernel Extension
98 //----------------------------------------------------------------------------
99 
111 };
112 
125 NVX_C_API vx_status nvxSetKernelParameterMutability(vx_kernel kernel, vx_uint32 index, vx_enum mutability);
126 
127 //----------------------------------------------------------------------------
128 // Framework : Types Extensions
129 //----------------------------------------------------------------------------
130 
143 
146 };
147 
155 };
156 
161 #define NVX_LIBRARY_NVIDIA (0x0)
162 
202 };
203 
204 //----------------------------------------------------------------------------
205 // Framework : Point Types
206 //----------------------------------------------------------------------------
207 
212 typedef struct _nvx_point2f_t {
215 } nvx_point2f_t;
216 
221 typedef struct _nvx_point3f_t {
225 } nvx_point3f_t;
226 
231 typedef struct _nvx_point4f_t {
236 } nvx_point4f_t;
237 
238 //----------------------------------------------------------------------------
239 // Framework : KeyPoint Types
240 //----------------------------------------------------------------------------
241 
246 typedef struct _nvx_keypointf_t {
255 
256 //----------------------------------------------------------------------------
257 // Framework : Image Extensions
258 //----------------------------------------------------------------------------
259 
266  NVX_DF_IMAGE_F32 = VX_DF_IMAGE('F','0','3','2'),
267 
269  NVX_DF_IMAGE_2F32 = VX_DF_IMAGE('2','F','3','2'),
270 
272  NVX_DF_IMAGE_2S16 = VX_DF_IMAGE('2','S','1','6'),
273 
278  NVX_DF_IMAGE_RGB16 = VX_DF_IMAGE('S','3','1','6'),
279 };
280 
296 NVX_C_API vx_image nvxCreateImageFromChannel(vx_image imgref, vx_enum channel);
297 
308 #define NVX_MAP_NO_PIXEL_GAPS (1 << 0)
309 
335 NVX_C_API vx_status nvxMapImagePatch(vx_image image,
336  const vx_rectangle_t *rect,
337  vx_uint32 plane_index,
339  void **ptr,
340  vx_enum usage,
341  vx_enum memory_type,
342  vx_uint32 flags);
343 
356 NVX_C_API vx_status nvxUnmapImagePatch(vx_image image,
357  const vx_rectangle_t *rect,
358  vx_uint32 plane_index,
359  void *ptr,
360  vx_enum memory_type);
361 
362 //----------------------------------------------------------------------------
363 // Framework : CUDA Interoperability
364 //----------------------------------------------------------------------------
365 
377 };
378 
386 };
387 
388 //----------------------------------------------------------------------------
389 // Framework : Context Extensions
390 //----------------------------------------------------------------------------
391 
414 
420 };
421 
422 //----------------------------------------------------------------------------
423 // Framework : Resource control
424 //----------------------------------------------------------------------------
425 
431 {
436 };
437 
455 NVX_C_API vx_status nvxSetNodeTargetDevice(vx_node node, vx_enum device);
456 
457 //----------------------------------------------------------------------------
458 // Framework : Reference extension
459 //----------------------------------------------------------------------------
460 
484 
507 NVX_C_API vx_status nvxReleaseReferenceList(vx_reference ref_list[], vx_size num_refs);
508 
509 //----------------------------------------------------------------------------
510 // Framework : Graph Extension
511 //----------------------------------------------------------------------------
512 
538 
561 };
562 
591 
605 };
606 
636 NVX_C_API vx_graph nvxCreateStreamGraph(vx_context context);
637 
663 NVX_C_API vx_status nvxRegisterAutoAging(vx_graph graph, vx_delay delay);
664 
665 //----------------------------------------------------------------------------
666 // Framework : Remap Extensions
667 //----------------------------------------------------------------------------
668 
683 NVX_C_API vx_status nvxMapRemapPatch(vx_remap remap,
684  vx_rectangle_t *rect,
686  void **ptr,
687  vx_enum usage);
688 
698 NVX_C_API vx_status nvxUnmapRemapPatch(vx_remap remap,
699  void *ptr);
700 
701 //----------------------------------------------------------------------------
702 // Framework : Node Extensions
703 //----------------------------------------------------------------------------
704 
721 };
722 
723 //----------------------------------------------------------------------------
724 // Primitive : Harris Track
725 //----------------------------------------------------------------------------
726 
757 NVX_C_API vx_node nvxHarrisTrackNode(vx_graph graph, vx_image input, vx_array output,
758  vx_image mask, vx_array tracked_points,
759  vx_float32 k, vx_float32 threshold, vx_uint32 cell_size,
760  vx_scalar num_corners);
761 
800 NVX_C_API vx_status nvxuHarrisTrack(vx_context context, vx_image input, vx_array output,
801  vx_image mask, vx_array tracked_points,
802  vx_float32 k, vx_float32 threshold, vx_uint32 cell_size,
803  vx_scalar num_corners);
804 
805 //----------------------------------------------------------------------------
806 // Primitive : FAST Track
807 //----------------------------------------------------------------------------
808 
840 NVX_C_API vx_node nvxFastTrackNode(vx_graph graph, vx_image input, vx_array output,
841  vx_image mask, vx_array tracked_points,
842  vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size,
843  vx_scalar num_corners);
844 
884 NVX_C_API vx_status nvxuFastTrack(vx_context context, vx_image input, vx_array output,
885  vx_image mask, vx_array tracked_points,
886  vx_uint32 type, vx_uint32 threshold, vx_uint32 cell_size,
887  vx_scalar num_corners);
888 
889 //----------------------------------------------------------------------------
890 // Primitive : Semi-Global Matching
891 //----------------------------------------------------------------------------
892 
913 
915 };
916 
938  vx_image left,
939  vx_image right,
940  vx_image disparity,
941  vx_int32 minD,
942  vx_int32 maxD,
943  vx_int32 P1,
944  vx_int32 P2,
945  vx_int32 sad,
946  vx_int32 clip,
947  vx_int32 max_diff,
948  vx_int32 uniqueness,
949  vx_enum scanlines_mask);
950 
972  vx_image left,
973  vx_image right,
974  vx_image disparity,
975  vx_int32 minD,
976  vx_int32 maxD,
977  vx_int32 P1,
978  vx_int32 P2,
979  vx_int32 sad,
980  vx_int32 clip,
981  vx_int32 max_diff,
982  vx_int32 uniqueness,
983  vx_enum scanlines_mask);
984 
985 //----------------------------------------------------------------------------
986 // Primitive : Copy Image
987 //----------------------------------------------------------------------------
988 
1003 NVX_C_API vx_node nvxCopyImageNode(vx_graph graph,
1004  vx_image src,
1005  vx_image dst);
1006 
1027 NVX_C_API vx_status nvxuCopyImage(vx_context context,
1028  vx_image src,
1029  vx_image dst);
1030 
1031 //----------------------------------------------------------------------------
1032 // Primitive : Flip Image
1033 //----------------------------------------------------------------------------
1034 
1040 {
1044 };
1045 
1061 NVX_C_API vx_node nvxFlipImageNode(vx_graph graph, vx_image input, vx_image output, vx_enum flip_mode);
1062 
1084 NVX_C_API vx_status nvxuFlipImage(vx_context context, vx_image input, vx_image output, vx_enum flip_mode);
1085 
1086 //----------------------------------------------------------------------------
1087 // Primitive : Hough Circles
1088 //----------------------------------------------------------------------------
1089 
1133 NVX_C_API vx_node nvxHoughCirclesNode(vx_graph graph,
1134  vx_image edges, vx_image dx, vx_image dy,
1135  vx_array circles, vx_scalar s_num_detections,
1136  vx_float32 dp, vx_float32 minDist,
1137  vx_uint32 minRadius, vx_uint32 maxRadius,
1138  vx_uint32 acc_threshold);
1139 
1191 NVX_C_API vx_status nvxuHoughCircles(vx_context context,
1192  vx_image edges, vx_image dx, vx_image dy,
1193  vx_array circles, vx_scalar s_num_detections,
1194  vx_float32 dp, vx_float32 minDist,
1195  vx_uint32 minRadius, vx_uint32 maxRadius,
1196  vx_uint32 acc_threshold);
1197 
1198 //----------------------------------------------------------------------------
1199 // Primitive : Hough Lines
1200 //----------------------------------------------------------------------------
1201 
1226 NVX_C_API vx_node nvxHoughLinesNode(vx_graph graph, vx_image input, vx_array output,
1227  vx_float32 rho, vx_float32 theta, vx_uint32 threshold,
1228  vx_scalar num_lines);
1229 
1262 NVX_C_API vx_status nvxuHoughLines(vx_context context, vx_image input, vx_array output,
1263  vx_float32 rho, vx_float32 theta, vx_uint32 threshold,
1264  vx_scalar num_lines);
1265 
1293 NVX_C_API vx_node nvxHoughSegmentsNode(vx_graph graph, vx_image input, vx_array output,
1294  vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap,
1295  vx_scalar num_segments);
1296 
1332 NVX_C_API vx_status nvxuHoughSegments(vx_context context, vx_image input, vx_array output,
1333  vx_float32 rho, vx_float32 theta, vx_uint32 threshold, vx_uint32 minLineLength, vx_uint32 maxLineGap,
1334  vx_scalar num_segments);
1335 
1336 //----------------------------------------------------------------------------
1337 // Primitive : Scharr3x3
1338 //----------------------------------------------------------------------------
1339 
1355 NVX_C_API vx_node nvxScharr3x3Node(vx_graph graph, vx_image input, vx_image grad_x, vx_image grad_y);
1356 
1380 NVX_C_API vx_status nvxuScharr3x3(vx_context context, vx_image input, vx_image grad_x, vx_image grad_y);
1381 
1382 //----------------------------------------------------------------------------
1383 // Primitive : Laplacian
1384 //----------------------------------------------------------------------------
1385 
1398 NVX_C_API vx_node nvxLaplacian3x3Node(vx_graph graph, vx_image input, vx_image output);
1399 
1420 NVX_C_API vx_status nvxuLaplacian3x3(vx_context context, vx_image input, vx_image output);
1421 
1422 //----------------------------------------------------------------------------
1423 // Primitive : Median Flow
1424 //----------------------------------------------------------------------------
1425 
1450 NVX_C_API vx_node nvxMedianFlowNode(vx_graph graph, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out,
1451  vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh);
1452 
1485 NVX_C_API vx_status nvxuMedianFlow(vx_context context, vx_array prev_pts, vx_array next_pts, vx_array pts_fb, vx_array out,
1486  vx_bool estimate_scale, vx_bool filter_flow_by_err, vx_float32 error_fb_thresh);
1487 //----------------------------------------------------------------------------
1488 // Primitive : Stereo Block Matching
1489 //----------------------------------------------------------------------------
1490 
1510 NVX_C_API vx_node nvxStereoBlockMatchingNode(vx_graph graph, vx_image left, vx_image right, vx_image disp,
1511  vx_uint32 winSize, vx_uint32 maxDisparity);
1512 
1540 NVX_C_API vx_status nvxuStereoBlockMatching(vx_context context, vx_image left, vx_image right, vx_image disp,
1541  vx_uint32 winSize, vx_uint32 maxDisparity);
1542 
1543 //----------------------------------------------------------------------------
1544 // Primitive : Find Homography
1545 //----------------------------------------------------------------------------
1546 
1558 };
1559 
1583 NVX_C_API vx_node nvxFindHomographyNode(vx_graph graph, vx_array srcPoints, vx_array dstPoints, vx_matrix homography,
1584  vx_enum method, vx_float32 threshold, vx_array inliers);
1585 
1610 NVX_C_API vx_status nvxuFindHomography(vx_context context, vx_array srcPoints, vx_array dstPoints, vx_matrix homography,
1611  vx_enum method, vx_float32 threshold, vx_array inliers);
1612 
1613 //----------------------------------------------------------------------------
1614 // Primitive : Create Motion Field
1615 //----------------------------------------------------------------------------
1616 
1668 NVX_C_API vx_node nvxCreateMotionFieldNode(vx_graph graph,
1669  vx_image ref_image, vx_image cur_image,
1670  vx_image anchor, vx_image bias,
1671  vx_image best_mv0, vx_image best_mv1,
1672  vx_image sad_table,
1673  vx_int32 blockSize,
1674  vx_int32 searchWindowWidth, vx_int32 searchWindowHeight,
1675  vx_float32 biasWeight,
1676  vx_int32 mvDivFactor);
1677 
1737 NVX_C_API vx_status nvxuCreateMotionField(vx_context context,
1738  vx_image ref_image, vx_image cur_image,
1739  vx_image anchor, vx_image bias,
1740  vx_image best_mv0, vx_image best_mv1,
1741  vx_image sad_table,
1742  vx_int32 blockSize,
1743  vx_int32 searchWindowWidth, vx_int32 searchWindowHeight,
1744  vx_float32 biasWeight,
1745  vx_int32 mvDivFactor);
1746 
1747 //----------------------------------------------------------------------------
1748 // Primitive : Refine Motion Field
1749 //----------------------------------------------------------------------------
1750 
1777 NVX_C_API vx_node nvxRefineMotionFieldNode(vx_graph graph,
1778  vx_image in_mv0, vx_image in_mv1,
1779  vx_image sad_table,
1780  vx_image out_mv0, vx_image out_mv1,
1781  vx_int32 searchWindowWidth, vx_int32 searchWindowHeight,
1782  vx_int32 numIterations,
1783  vx_float32 smoothnessFactor,
1784  vx_int32 mvDivFactor);
1785 
1820 NVX_C_API vx_status nvxuRefineMotionField(vx_context context,
1821  vx_image in_mv0, vx_image in_mv1,
1822  vx_image sad_table,
1823  vx_image out_mv0, vx_image out_mv1,
1824  vx_int32 searchWindowWidth, vx_int32 searchWindowHeight,
1825  vx_int32 numIterations,
1826  vx_float32 smoothnessFactor,
1827  vx_int32 mvDivFactor);
1828 
1829 //----------------------------------------------------------------------------
1830 // Primitive : Partition Motion Field
1831 //----------------------------------------------------------------------------
1832 
1856  vx_image ref_image, vx_image cur_image,
1857  vx_image in_mv_0, vx_image in_mv_1,
1858  vx_image out_mv_0, vx_image out_mv_1,
1859  vx_float32 smoothnessFactor,
1860  vx_int32 mvDivFactor);
1861 
1893  vx_image ref_image, vx_image cur_image,
1894  vx_image in_mv_0, vx_image in_mv_1,
1895  vx_image out_mv_0, vx_image out_mv_1,
1896  vx_float32 smoothnessFactor,
1897  vx_int32 mvDivFactor);
1898 
1899 //----------------------------------------------------------------------------
1900 // Primitive : Multiply by Scalar
1901 //----------------------------------------------------------------------------
1902 
1919 NVX_C_API vx_node nvxMultiplyByScalarNode(vx_graph graph,
1920  vx_image src, vx_image dst,
1921  vx_float32 alpha);
1922 
1945 NVX_C_API vx_status nvxuMultiplyByScalar(vx_context context,
1946  vx_image src, vx_image dst,
1947  vx_float32 alpha);
1948 
1949 #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.
nvx_find_homography_method_e
Method used to compute a homography matrix.
Definition: nvx.h:1551
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:906
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.
vx_status nvxMapRemapPatch(vx_remap remap, vx_rectangle_t *rect, vx_imagepatch_addressing_t *addr, void **ptr, vx_enum usage)
Maps a rectangular patch (subset) of a remap object.
Any device.
Definition: nvx.h:432
nvx_accessor_e
Extended memory accessors.
Definition: nvx.h:370
A floating value for vendor-defined struct base index.
Definition: vx_types.h:348
A regular method using all the points.
Definition: nvx.h:1553
Defines a 4D point (float coordinates).
Definition: nvx.h:231
Indicates that the CUDA-capable GPU is not supported.
Definition: nvx.h:154
vx_float32 y
Holds the y coordinate.
Definition: nvx.h:248
Specifies Laplacian 3 x 3 Kernel.
Definition: nvx.h:187
Specifies Median Flow Kernel.
Definition: nvx.h:189
NVIDIA Corporation.
Definition: vx_vendors.h:40
nvx_type_e
Defines additional types.
Definition: nvx.h:135
struct _vx_array * vx_array
The Array Object. Array is a strongly-typed container for other data structures.
Definition: vx_types.h:279
Specifies Hough Lines Kernel.
Definition: nvx.h:179
A Change of the parameter meta-data implies a node re-initialization.
Definition: nvx.h:108
vx_status nvxUnmapImagePatch(vx_image image, const vx_rectangle_t *rect, vx_uint32 plane_index, void *ptr, vx_enum memory_type)
Unmaps a mapped patch (subset) of an image.
Gets the CUDA stream object associated with the current node.
Definition: nvx.h:720
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:212
VisionWorks library version information.
Definition: nvx.h:65
A floating value used for bound checking the VisionWorks object types.
Definition: nvx.h:145
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
nvx_node_attribute_e
The extended node attributes list.
Definition: nvx.h:709
Vertical flipping of the image.
Definition: nvx.h:1042
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_scanline_e
Defines scan line's directions used during cost aggregation step.
Definition: nvx.h:897
nvx_import_type_e
Extended import type.
Definition: nvx.h:383
WO with CUDA pointer.
Definition: nvx.h:374
vx_float32 scale
Holds the scale initialized to 0 by corner detectors.
Definition: nvx.h:250
Disables keypoint's error calculation by optical flow and similar primitives.
Definition: nvx.h:582
A Change of the parameter meta-data or value implies a node re-initialization.
Definition: nvx.h:110
nvx_mutability_e
Defines the mutability state of custom kernel parameter.
Definition: nvx.h:104
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 nvxMapImagePatch(vx_image image, const vx_rectangle_t *rect, vx_uint32 plane_index, vx_imagepatch_addressing_t *addr, void **ptr, vx_enum usage, vx_enum memory_type, vx_uint32 flags)
Maps a rectangular patch (subset) of an image from a single plane.
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:278
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:171
Aggregate cost from four directions forming a cross.
Definition: nvx.h:909
vx_node nvxCreateMotionFieldNode(vx_graph graph, vx_image ref_image, vx_image cur_image, vx_image anchor, vx_image bias, vx_image best_mv0, vx_image best_mv1, vx_image sad_table, vx_int32 blockSize, vx_int32 searchWindowWidth, vx_int32 searchWindowHeight, vx_float32 biasWeight, vx_int32 mvDivFactor)
[Graph] Creates initial motion field from a current image into reference image.
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:904
vx_status nvxuPartitionMotionField(vx_context context, vx_image ref_image, vx_image cur_image, vx_image in_mv_0, vx_image in_mv_1, vx_image out_mv_0, vx_image out_mv_1, vx_float32 smoothnessFactor, vx_int32 mvDivFactor)
[Immediate] Partitions motion vector field for blocks onto motion vector field into quarter sized blo...
vx_status nvxuFindHomography(vx_context context, vx_array srcPoints, vx_array dstPoints, vx_matrix homography, vx_enum method, vx_float32 threshold, vx_array inliers)
[Immediate] Computes homography matrix.
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:251
vx_node nvxMultiplyByScalarNode(vx_graph graph, vx_image src, vx_image dst, vx_float32 alpha)
[Graph] Multiplies an input image by scalar and optionally converts it to another data type...
vx_float32 y
The Y coordinate.
Definition: nvx.h:214
vx_uint32 visionworks_major_version
Major version of VisionWorks library.
Definition: nvx.h:66
VisionWorks module version.
Definition: nvx.h:80
Uses default behavior for keypoint's error calculation.
Definition: nvx.h:590
ID of the CUDA device that was selected as current prior to vx_context object creation (use an int pa...
Definition: nvx.h:419
vx_node nvxFindHomographyNode(vx_graph graph, vx_array srcPoints, vx_array dstPoints, vx_matrix homography, vx_enum method, vx_float32 threshold, vx_array inliers)
[Graph] Computes homography matrix.
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:224
vx_int32 tracking_status
Holds tracking status. Zero indicates a lost point. Initialized to 1 by corner detectors.
Definition: nvx.h:252
nvx_kernel_e
Defines a list of extended vision kernels.
Definition: nvx.h:167
aggregate cost from left to right diagonally starting from the top.
Definition: nvx.h:899
#define NVX_LIBRARY_NVIDIA
The extended set of kernels provided by NVIDIA.
Definition: nvx.h:161
Specifies Hough Circles Kernel.
Definition: nvx.h:183
Horizontal flipping of the image.
Definition: nvx.h:1041
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:253
Specifies Scharr 3 x 3 Kernel.
Definition: nvx.h:185
vx_float32 x
The X coordinate.
Definition: nvx.h:232
The memory import enumeration.
Definition: vx_types.h:557
A nvx_point3f_t.
Definition: nvx.h:137
RW with CUDA pointer.
Definition: nvx.h:376
The addressing image patch structure is used by the Host only to address pixels in an image patch...
Definition: vx_types.h:1329
vx_float32 x
The X coordinate.
Definition: nvx.h:222
A nvx_keypointf_t.
Definition: nvx.h:139
vx_node nvxRefineMotionFieldNode(vx_graph graph, vx_image in_mv0, vx_image in_mv1, vx_image sad_table, vx_image out_mv0, vx_image out_mv1, vx_int32 searchWindowWidth, vx_int32 searchWindowHeight, vx_int32 numIterations, vx_float32 smoothnessFactor, vx_int32 mvDivFactor)
[Graph] Iteratively refines motion field by applying the motion vectors to a center block in a 3x3 bl...
A vx_context.
Definition: vx_types.h:357
GPU device.
Definition: nvx.h:435
#define VX_ATTRIBUTE_BASE(vendor, object)
Defines the manner in which to combine the Vendor and Object IDs to get the base value of the enumera...
A floating value for comparison between structs and objects.
Definition: nvx.h:142
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
Specifies Find Homography Kernel.
Definition: nvx.h:193
vx_float32 y
The Y coordinate.
Definition: nvx.h:223
aggregate cost from right to left diagonally starting from the top.
Definition: nvx.h:901
vx_status nvxRegisterAutoAging(vx_graph graph, vx_delay delay)
Registers a delay for auto-aging.
Enables keypoint's error calculation by optical flow and similar primitives.
Definition: nvx.h:586
nvx_context_attribute_e
The extended context attributes list.
Definition: nvx.h:396
A Change of the parameter does not imply a node re-initialization.
Definition: nvx.h:106
vx_status nvxSetNodeTargetDevice(vx_node node, vx_enum device)
Sets the target device type for the node.
A nvx_point4f_t.
Definition: nvx.h:138
An accessor flag type.
Definition: vx_types.h:560
vx_status nvxUnmapRemapPatch(vx_remap remap, void *ptr)
Unmaps a mapped patch (subset) of a remap object.
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.
A single plane of vx_int16[2] data (eg.
Definition: nvx.h:272
The CUDA import memory type.
Definition: nvx.h:385
Specifies Create Motion Field Kernel.
Definition: nvx.h:195
Specifies Hough Segments Kernel.
Definition: nvx.h:181
Specifies Flip Image Kernel.
Definition: nvx.h:173
nvx_status_e
Defines additional error codes.
Definition: nvx.h:152
aggregate cost from right to left horizontally.
Definition: nvx.h:903
The rectangle data structure that is shared with the users.
Definition: vx_types.h:1422
vx_uint32 minor
Minor version component.
Definition: nvx.h:82
#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_node nvxPartitionMotionFieldNode(vx_graph graph, vx_image ref_image, vx_image cur_image, vx_image in_mv_0, vx_image in_mv_1, vx_image out_mv_0, vx_image out_mv_1, vx_float32 smoothnessFactor, vx_int32 mvDivFactor)
[Graph] Partitions motion vector field for blocks onto motion vector field into quarter sized blocks ...
Parameter mutability.
Definition: nvx.h:53
Use default behavior for performance measurement.
Definition: nvx.h:604
Least-Median robust method.
Definition: nvx.h:1557
vx_float32 y
The Y coordinate.
Definition: nvx.h:233
vx_uint32 openvx_minor_version
Minor version of OpenVX standard implemented by VisionWorks library.
Definition: nvx.h:72
vx_image nvxCreateImageFromChannel(vx_image imgref, vx_enum channel)
Creates an image from a single channel of another image.
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:221
aggregate cost over all scan lines.
Definition: nvx.h:914
A single plane of vx_float32 data.
Definition: nvx.h:266
Sets the graph verification options.
Definition: nvx.h:537
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:1043
vx_float32 z
The Z coordinate.
Definition: nvx.h:234
vx_float32 strength
Holds the strength of the keypoint. Its definition is specific to the corner detector.
Definition: nvx.h:249
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:264
Specifies Harris Track Kernel.
Definition: nvx.h:169
Enables performance measurement.
Definition: nvx.h:600
nvx_graph_attribute_e
The extended graph attributes list.
Definition: nvx.h:517
CPU device.
Definition: nvx.h:434
The OpenVX Utility Library.
vx_uint32 patch
Patch version component.
Definition: nvx.h:83
Preferred target device for the immediate primitive execution mode (use a nvx_device_type_e).
Definition: nvx.h:413
A vx_node.
Definition: vx_types.h:359
Informs if graph verification is needed before graph execution.
Definition: nvx.h:560
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.
RANSAC-based robust method.
Definition: nvx.h:1555
struct _vx_remap * vx_remap
The remap table Object. A remap table contains per-pixel mapping of output pixels to input pixels...
Definition: vx_types.h:274
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:153
aggregate cost from left to right horizontally.
Definition: nvx.h:898
Specifies Multiply by Scalar Kernel.
Definition: nvx.h:201
vx_float32 x
Holds the x coordinate.
Definition: nvx.h:247
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:175
aggregate cost from top to bottom vertically.
Definition: nvx.h:900
Specifies Stereo Block Matching Kernel.
Definition: nvx.h:191
A nvx_point2f_t.
Definition: nvx.h:136
vx_float32 w
The W coordinate.
Definition: nvx.h:235
vx_uint32 major
Major version component.
Definition: nvx.h:81
nvx_enum_e
Defines the additional set of supported enumerations.
Definition: nvx.h:52
Defines a keypoint data structure.
Definition: nvx.h:246
Disables performance measurement.
Definition: nvx.h:595
nvx_device_type_e
Defines types of devices that can execute vision functions.
Definition: nvx.h:430
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:269
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 Refine Motion Field Kernel.
Definition: nvx.h:197
nvx_directive_e
Defines directives that control different features for graph / immediate processing.
Definition: nvx.h:577
Specifies Semi Global Matching Kernel.
Definition: nvx.h:177
Specifies Partition Motion Field Kernel.
Definition: nvx.h:199
vx_graph nvxCreateStreamGraph(vx_context context)
Creates an empty graph as a node stream.
struct _vx_matrix * vx_matrix
The Matrix Object. An MxN matrix of some unit type.
Definition: vx_types.h:249
struct _vx_scalar * vx_scalar
An opaque reference to a scalar.
Definition: vx_types.h:179
vx_status nvxuRefineMotionField(vx_context context, vx_image in_mv0, vx_image in_mv1, vx_image sad_table, vx_image out_mv0, vx_image out_mv1, vx_int32 searchWindowWidth, vx_int32 searchWindowHeight, vx_int32 numIterations, vx_float32 smoothnessFactor, vx_int32 mvDivFactor)
[Immediate] Iteratively refines motion field by applying the motion vectors to a center block in a 3x...
vx_status nvxuMultiplyByScalar(vx_context context, vx_image src, vx_image dst, vx_float32 alpha)
[Immediate] Multiplies an input image by scalar and optionally converts it to another data type...
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:905
vx_status nvxuCreateMotionField(vx_context context, vx_image ref_image, vx_image cur_image, vx_image anchor, vx_image bias, vx_image best_mv0, vx_image best_mv1, vx_image sad_table, vx_int32 blockSize, vx_int32 searchWindowWidth, vx_int32 searchWindowHeight, vx_float32 biasWeight, vx_int32 mvDivFactor)
[Immediate] Creates initial motion field from a current image into reference image.
nvx_flip_mode_e
Defines modes for flip image operation.
Definition: nvx.h:1039
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:372
vx_uint32 visionworks_patch_version
Patch version of VisionWorks library.
Definition: nvx.h:68
vx_float32 x
The X coordinate.
Definition: nvx.h:213