nvx.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2016, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA Corporation is strictly prohibited.
 */

#ifndef NVX_H
#define NVX_H

//----------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------

#include <VX/vx.h>
#include <VX/vxu.h>
#include <NVX/nvx_api_macros.h>

//----------------------------------------------------------------------------
// Framework : Version Information
//----------------------------------------------------------------------------

typedef struct _nvx_version_info_t {
    vx_uint32 visionworks_major_version;  
    vx_uint32 visionworks_minor_version;  
    vx_uint32 visionworks_patch_version;  
    char visionworks_suffix_version[12];  
    vx_uint32 openvx_major_version;       
    vx_uint32 openvx_minor_version;       
    vx_uint32 openvx_patch_version;       
} nvx_version_info_t;

typedef struct _nvx_module_version_t {
    vx_uint32 major;  
    vx_uint32 minor;  
    vx_uint32 patch;  
    char suffix[12];  
} nvx_module_version_t;

NVX_C_API void nvxGetVersionInfo(nvx_version_info_t *info);


//----------------------------------------------------------------------------
// Framework : User Kernel Extension
//----------------------------------------------------------------------------

enum nvx_enum_e {
    NVX_ENUM_MUTABILITY  = 0x00, 
};

enum nvx_mutability_e {
    NVX_MUTABLE_INIT = VX_ENUM_BASE(VX_ID_NVIDIA, NVX_ENUM_MUTABILITY) + 0x0,
    NVX_METADATA_IMMUTABLE_INIT = VX_ENUM_BASE(VX_ID_NVIDIA, NVX_ENUM_MUTABILITY) + 0x1,
    NVX_IMMUTABLE_INIT = VX_ENUM_BASE(VX_ID_NVIDIA, NVX_ENUM_MUTABILITY) + 0x2,
};

NVX_C_API vx_status nvxSetKernelParameterMutability(vx_kernel kernel, vx_uint32 index, vx_enum mutability);

//----------------------------------------------------------------------------
// Framework : Types Extensions
//----------------------------------------------------------------------------

enum nvx_type_e {
    NVX_TYPE_POINT2F = VX_TYPE_VENDOR_STRUCT_START,     
    NVX_TYPE_POINT3F,                                   
    NVX_TYPE_POINT4F,                                   
    NVX_TYPE_KEYPOINTF,                                 
    NVX_TYPE_STRUCT_MAX,

    NVX_TYPE_OBJECT_MAX = VX_TYPE_VENDOR_OBJECT_START,
};

enum nvx_status_e {
    NVX_ERROR_NO_CUDA_GPU          = -1000, 
    NVX_ERROR_UNSUPPORTED_CUDA_GPU = -1001, 
    NVX_ERROR_CUDA_FAILURE         = -1002, 
};

#define NVX_LIBRARY_NVIDIA (0x0)

enum nvx_kernel_e {
    NVX_KERNEL_HARRIS_TRACK = VX_KERNEL_BASE(VX_ID_NVIDIA, NVX_LIBRARY_NVIDIA),
    NVX_KERNEL_FAST_TRACK,
    NVX_KERNEL_FLIP_IMAGE,
    NVX_KERNEL_COPY_IMAGE,
    NVX_KERNEL_SEMI_GLOBAL_MATCHING,
    NVX_KERNEL_HOUGH_LINES,
    NVX_KERNEL_HOUGH_SEGMENTS,
    NVX_KERNEL_HOUGH_CIRCLES,
    NVX_KERNEL_SCHARR_3x3,
    NVX_KERNEL_LAPLACIAN_3x3,
    NVX_KERNEL_MEDIAN_FLOW,
    NVX_KERNEL_STEREO_BLOCK_MATCHING,
    NVX_KERNEL_FIND_HOMOGRAPHY,
    NVX_KERNEL_CREATE_MOTION_FIELD,
    NVX_KERNEL_REFINE_MOTION_FIELD,
    NVX_KERNEL_PARTITION_MOTION_FIELD,
    NVX_KERNEL_MULTIPLY_BY_SCALAR,
};

//----------------------------------------------------------------------------
// Framework : Point Types
//----------------------------------------------------------------------------

typedef struct _nvx_point2f_t {
    vx_float32 x;   
    vx_float32 y;   
} nvx_point2f_t;

typedef struct _nvx_point3f_t {
    vx_float32 x;   
    vx_float32 y;   
    vx_float32 z;   
} nvx_point3f_t;

typedef struct _nvx_point4f_t {
    vx_float32 x;   
    vx_float32 y;   
    vx_float32 z;   
    vx_float32 w;   
} nvx_point4f_t;

//----------------------------------------------------------------------------
// Framework : KeyPoint Types
//----------------------------------------------------------------------------

typedef struct _nvx_keypointf_t {
    vx_float32 x;               
    vx_float32 y;               
    vx_float32 strength;        
    vx_float32 scale;           
    vx_float32 orientation;     
    vx_int32 tracking_status;   
    vx_float32 error;           
} nvx_keypointf_t;

//----------------------------------------------------------------------------
// Framework : Image Extensions
//----------------------------------------------------------------------------

enum nvx_df_image_e {
    NVX_DF_IMAGE_F32   = VX_DF_IMAGE('F','0','3','2'),

    NVX_DF_IMAGE_2F32   = VX_DF_IMAGE('2','F','3','2'),

    NVX_DF_IMAGE_2S16   = VX_DF_IMAGE('2','S','1','6'),

    NVX_DF_IMAGE_RGB16 = VX_DF_IMAGE('S','3','1','6'),
};

NVX_C_API vx_image nvxCreateImageFromChannel(vx_image imgref, vx_enum channel);

#define NVX_MAP_NO_PIXEL_GAPS               (1 << 0)

NVX_C_API 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);

NVX_C_API vx_status nvxUnmapImagePatch(vx_image image,
                                       const vx_rectangle_t *rect,
                                       vx_uint32 plane_index,
                                       void *ptr,
                                       vx_enum memory_type);

//----------------------------------------------------------------------------
// Framework : CUDA Interoperability
//----------------------------------------------------------------------------

enum nvx_accessor_e {
    NVX_READ_ONLY_CUDA = VX_ENUM_BASE(VX_ID_NVIDIA, VX_ENUM_ACCESSOR) + 0x0,
    NVX_WRITE_ONLY_CUDA = VX_ENUM_BASE(VX_ID_NVIDIA, VX_ENUM_ACCESSOR) + 0x1,
    NVX_READ_AND_WRITE_CUDA = VX_ENUM_BASE(VX_ID_NVIDIA, VX_ENUM_ACCESSOR) + 0x2,
};

enum nvx_import_type_e {
    NVX_IMPORT_TYPE_CUDA = VX_ENUM_BASE(VX_ID_NVIDIA, VX_ENUM_IMPORT_MEM) + 0x0,
    NVX_IMPORT_TYPE_CUDA_ARRAY,
};

//----------------------------------------------------------------------------
// Framework : Context Extensions
//----------------------------------------------------------------------------

enum nvx_context_attribute_e {
    NVX_CONTEXT_ATTRIBUTE_IMMEDIATE_TARGET_DEVICE = VX_ENUM_BASE(VX_ID_NVIDIA, VX_TYPE_CONTEXT) + 0x0,

    NVX_CONTEXT_ATTRIBUTE_INITIAL_CUDA_DEVICE_ID,
};

//----------------------------------------------------------------------------
// Framework : Resource control
//----------------------------------------------------------------------------

enum nvx_device_type_e
{
    NVX_DEVICE_ANY  = 0x0, 
    NVX_DEVICE_CPU  = 0x1, 
    NVX_DEVICE_GPU  = 0x2, 
};

NVX_C_API vx_status nvxSetNodeTargetDevice(vx_node node, vx_enum device);

//----------------------------------------------------------------------------
// Framework : Reference extension
//----------------------------------------------------------------------------

NVX_C_API vx_status nvxRetainReference(vx_reference ref);

NVX_C_API vx_status nvxReleaseReferenceList(vx_reference ref_list[], vx_size num_refs);

//----------------------------------------------------------------------------
// Framework : Graph Extension
//----------------------------------------------------------------------------

enum nvx_graph_attribute_e {
    NVX_GRAPH_VERIFY_OPTIONS = VX_ENUM_BASE(VX_ID_NVIDIA, VX_TYPE_GRAPH) + 0x0,

    NVX_GRAPH_VERIFY_NEEDED = VX_ENUM_BASE(VX_ID_NVIDIA, VX_TYPE_GRAPH) + 0x1,
};

enum nvx_directive_e {
    NVX_DIRECTIVE_KEYPOINT_ERROR_DISABLE = VX_ENUM_BASE(VX_ID_NVIDIA, VX_ENUM_DIRECTIVE) + 0x0,
    NVX_DIRECTIVE_KEYPOINT_ERROR_ENABLE,
    NVX_DIRECTIVE_KEYPOINT_ERROR_DEFAULT,

    NVX_DIRECTIVE_PERFORMANCE_DISABLE,
    NVX_DIRECTIVE_PERFORMANCE_ENABLE,
    NVX_DIRECTIVE_PERFORMANCE_DEFAULT,
};

NVX_C_API vx_graph nvxCreateStreamGraph(vx_context context);

NVX_C_API vx_status nvxRegisterAutoAging(vx_graph graph, vx_delay delay);

//----------------------------------------------------------------------------
// Framework : Remap Extensions
//----------------------------------------------------------------------------

NVX_C_API vx_status nvxMapRemapPatch(vx_remap remap,
                                     vx_rectangle_t *rect,
                                     vx_imagepatch_addressing_t *addr,
                                     void **ptr,
                                     vx_enum usage);

NVX_C_API vx_status nvxUnmapRemapPatch(vx_remap remap,
                                       void *ptr);

//----------------------------------------------------------------------------
// Framework : Node Extensions
//----------------------------------------------------------------------------

enum nvx_node_attribute_e {
    NVX_NODE_ATTRIBUTE_CUDA_STREAM = VX_ATTRIBUTE_BASE(VX_ID_NVIDIA, VX_TYPE_NODE) + 0x0,
};

//----------------------------------------------------------------------------
// Primitive : Harris Track
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : FAST Track
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Semi-Global Matching
//----------------------------------------------------------------------------

enum nvx_scanline_e {
    NVX_SCANLINE_LEFT_RIGHT            = 1 << 0,    
    NVX_SCANLINE_TOP_LEFT_BOTTOM_RIGHT = 1 << 1,    
    NVX_SCANLINE_TOP_BOTTOM            = 1 << 2,    
    NVX_SCANLINE_TOP_RIGHT_BOTTOM_LEFT = 1 << 3,    
    NVX_SCANLINE_RIGHT_LEFT            = 1 << 4,    
    NVX_SCANLINE_BOTTOM_RIGHT_TOP_LEFT = 1 << 5,    
    NVX_SCANLINE_BOTTOM_TOP            = 1 << 6,    
    NVX_SCANLINE_BOTTOM_LEFT_TOP_RIGHT = 1 << 7,    
    NVX_SCANLINE_CROSS = NVX_SCANLINE_LEFT_RIGHT |
                         NVX_SCANLINE_RIGHT_LEFT |
                         NVX_SCANLINE_TOP_BOTTOM |
                         NVX_SCANLINE_BOTTOM_TOP,

    NVX_SCANLINE_ALL                   = 0xFF       
};

enum nvx_sgm_flags_e {
    NVX_SGM_FILTER_TOP_AREA            = 1 << 0     
};

NVX_C_API 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,
                                            vx_enum  flags);

NVX_C_API 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,
                                           vx_enum  flags);

//----------------------------------------------------------------------------
// Primitive : Copy Image
//----------------------------------------------------------------------------

NVX_C_API vx_node nvxCopyImageNode(vx_graph graph,
                                   vx_image src,
                                   vx_image dst);

NVX_C_API vx_status nvxuCopyImage(vx_context context,
                                  vx_image src,
                                  vx_image dst);

//----------------------------------------------------------------------------
// Primitive : Flip Image
//----------------------------------------------------------------------------

enum nvx_flip_mode_e
{
    NVX_FLIP_HORIZONTAL,    
    NVX_FLIP_VERTICAL,      
    NVX_FLIP_BOTH           
};

NVX_C_API vx_node nvxFlipImageNode(vx_graph graph, vx_image input, vx_image output, vx_enum flip_mode);

NVX_C_API vx_status nvxuFlipImage(vx_context context, vx_image input, vx_image output, vx_enum flip_mode);

//----------------------------------------------------------------------------
// Primitive : Hough Circles
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Hough Lines
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Scharr3x3
//----------------------------------------------------------------------------

NVX_C_API vx_node nvxScharr3x3Node(vx_graph graph, vx_image input, vx_image grad_x, vx_image grad_y);

NVX_C_API vx_status nvxuScharr3x3(vx_context context, vx_image input, vx_image grad_x, vx_image grad_y);

//----------------------------------------------------------------------------
// Primitive : Laplacian
//----------------------------------------------------------------------------

NVX_C_API vx_node nvxLaplacian3x3Node(vx_graph graph, vx_image input, vx_image output);

NVX_C_API vx_status nvxuLaplacian3x3(vx_context context, vx_image input, vx_image output);

//----------------------------------------------------------------------------
// Primitive : Median Flow
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);
//----------------------------------------------------------------------------
// Primitive : Stereo Block Matching
//----------------------------------------------------------------------------

NVX_C_API vx_node nvxStereoBlockMatchingNode(vx_graph graph, vx_image left, vx_image right, vx_image disp,
                                             vx_uint32 winSize, vx_uint32 maxDisparity);

NVX_C_API vx_status nvxuStereoBlockMatching(vx_context context, vx_image left, vx_image right, vx_image disp,
                                            vx_uint32 winSize, vx_uint32 maxDisparity);

//----------------------------------------------------------------------------
// Primitive : Find Homography
//----------------------------------------------------------------------------

enum nvx_find_homography_method_e {
    NVX_FIND_HOMOGRAPHY_METHOD_USE_ALL_POINTS = 0x0,
    NVX_FIND_HOMOGRAPHY_METHOD_RANSAC = 0x1,
    NVX_FIND_HOMOGRAPHY_METHOD_LMEDS = 0x2,
};

NVX_C_API vx_node nvxFindHomographyNode(vx_graph graph, vx_array srcPoints, vx_array dstPoints, vx_matrix homography,
                                        vx_enum method, vx_float32 threshold,
                                        vx_int32 maxEstimateIters, vx_int32 maxRefineIters,
                                        vx_float32 confidence, vx_float32 outlierRatio,
                                        vx_array inliers);

NVX_C_API vx_status nvxuFindHomography(vx_context context, vx_array srcPoints, vx_array dstPoints, vx_matrix homography,
                                       vx_enum method, vx_float32 threshold,
                                       vx_int32 maxEstimateIters,  vx_int32 maxRefineIters,
                                       vx_float32 confidence, vx_float32 outlierRatio,
                                       vx_array inliers);

//----------------------------------------------------------------------------
// Primitive : Create Motion Field
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Refine Motion Field
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Partition Motion Field
//----------------------------------------------------------------------------

NVX_C_API 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);

NVX_C_API 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);

//----------------------------------------------------------------------------
// Primitive : Multiply by Scalar
//----------------------------------------------------------------------------

NVX_C_API vx_node nvxMultiplyByScalarNode(vx_graph graph,
                                          vx_image src, vx_image dst,
                                          vx_float32 alpha);

NVX_C_API vx_status nvxuMultiplyByScalar(vx_context context,
                                         vx_image src, vx_image dst,
                                         vx_float32 alpha);

#endif