private void SampleForm_Load(object sender, EventArgs e)
{
#region Corner Tracking Initialization
uint width = 1024, height = 1024;
UIntPtr max_keypoint_count = (UIntPtr)10000; // maximum number of keypoints to track
float harris_strength_thresh = 0.0005f; // minimum corner strength to keep a corner
float harris_min_distance = 5.0f; // radial L2 distance for non-max suppression
float harris_sensitivity = 0.04f; // multiplier k in det(A) - k * trace(A)^2
int harris_gradient_size = 3; // window size for gradient computation
int harris_block_size = 3; // block window size for Harris corner score
UIntPtr lk_pyramid_levels = (UIntPtr)6; // number of pyramid levels for optical flow
float lk_pyramid_scale = VX.SCALE_PYRAMID_HALF; // pyramid levels scale by factor of two
TerminationCriteria lk_termination = TerminationCriteria.Both; // iteration termination criteria (eps & iterations)
float lk_epsilon = 0.01f; // convergence criterion
uint lk_num_iterations = 5; // maximum number of iterations
bool lk_use_initial_estimate = false; // don't use initial estimate
uint lk_window_dimension = 6; // window size for evaluation
float trackable_kp_ratio_thr = 0.8f; // threshold for the ration of tracked keypoints to all
// Create the OpenVX context and make sure the returned context is valid.
_Context = VX.CreateContext();
// Create OpenVX image object for input RGB image.
_ImageInput = VX.CreateImage(_Context, width, height, DfImage.Rgb);
// OpenVX optical flow functionality requires image pyramids for the current
// and the previous image. It also requires keypoints that correspond
// to the previous pyramid and will output updated keypoints into
// another keypoint array. To be able to toggle between the current and
// the previous buffers, you need to use OpenVX delay objects and vxAgeDelay().
// Create OpenVX pyramid and array object exemplars and create OpenVX delay
// objects for both to hold two of each. Note that the exemplar objects are not
// needed once the delay objects are created.
using (Pyramid pyramid = VX.CreatePyramid(_Context, lk_pyramid_levels, lk_pyramid_scale, width, height, DfImage.U8))
_PyramidDelay = VX.CreateDelay(_Context, pyramid, (UIntPtr)2);
using (OpenVX.Array keypoints = VX.CreateArray(_Context, OpenVX.Type.Keypoint, max_keypoint_count))
_KeypointsDelay = VX.CreateDelay(_Context, keypoints, (UIntPtr)2);
// An object from a delay slot can be accessed using vxGetReferenceFromDelay API.
// You need to use index = 0 for the current object and index = -1 for the previous object.
_PyramidCurrent = VX.GetReferenceFromDelay(_PyramidDelay, 0);
_PyramidPrevious = VX.GetReferenceFromDelay(_PyramidDelay, -1);
_KeypointsCurrent = VX.GetReferenceFromDelay(_KeypointsDelay, 0);
_KeypointsPrevious = VX.GetReferenceFromDelay(_KeypointsDelay, -1);
// Harris and optical flow algorithms require their own graph objects.
// The Harris graph needs to extract gray scale image out of input RGB,
// compute an initial set of keypoints, and compute an initial pyramid for use
// by the optical flow graph.
Graph graphHarris = VX.CreateGraph(_Context);
Graph graphTrack = VX.CreateGraph(_Context);
// Harris and pyramid computation expect input to be an 8-bit image.
// Given that input is an RGB image, it is best to extract a gray image
// from RGB image, which requires two steps:
// - perform RGB to IYUV color conversion
// - extract Y channel from IYUV image
// This requires two intermediate OpenVX image objects. Since you don't
// need to access these objects from the application, they can be virtual
// objects that can be created using the vxCreateVirtualImage API.
OpenVX.Image harris_yuv_image = VX.CreateVirtualImage(graphHarris, width, height, DfImage.Iyuv);
OpenVX.Image harris_gray_image = VX.CreateVirtualImage(graphHarris, width, height, DfImage.U8);
OpenVX.Image opticalflow_yuv_image = VX.CreateVirtualImage(graphTrack, width, height, DfImage.Iyuv);
OpenVX.Image opticalflow_gray_image = VX.CreateVirtualImage(graphTrack, width, height, DfImage.U8);
// The Harris corner detector and optical flow nodes (see "VX/vx_nodes.h")
// need several scalar objects as parameters.
Scalar strength_thresh = VX.CreateScalar(_Context, ref harris_strength_thresh);
Scalar min_distance = VX.CreateScalar(_Context, ref harris_min_distance);
Scalar sensitivity = VX.CreateScalar(_Context, ref harris_sensitivity);
Scalar epsilon = VX.CreateScalar(_Context, ref lk_epsilon);
Scalar num_iterations = VX.CreateScalar(_Context, ref lk_num_iterations);
Scalar use_initial_estimate = VX.CreateScalar(_Context, ref lk_use_initial_estimate);
// Now all the objects have been created for building the graphs.
// First, build a graph that performs Harris corner detection and initial pyramid computation.
// See "VX/vx_nodes.h" for APIs how to add nodes into a graph.
Node[] nodesHarris = new Node[] {
VX.ColorConvertNode(graphHarris, _ImageInput, harris_yuv_image),
VX.ChannelExtractNode(graphHarris, harris_yuv_image, Channel.ChannelY, harris_gray_image),
VX.GaussianPyramidNode(graphHarris, harris_gray_image, _PyramidCurrent),
VX.HarrisCornersNode(graphHarris, harris_gray_image, strength_thresh, min_distance, sensitivity, harris_gradient_size, harris_block_size, _KeypointsCurrent, Reference.Null)
};
VX.Release(nodesHarris);
VX.VerifyGraph(graphHarris);
// Now, build a graph that computes image pyramid for the next frame,
// and tracks features using optical flow.
Node[] nodesTrack = new Node[] {
VX.ColorConvertNode(graphTrack, _ImageInput, opticalflow_yuv_image),
VX.ChannelExtractNode(graphTrack, opticalflow_yuv_image, Channel.ChannelY, opticalflow_gray_image),
VX.GaussianPyramidNode(graphTrack, opticalflow_gray_image, _PyramidCurrent),
VX.OpticalFlowPyrLKNode(graphTrack, _PyramidPrevious, _PyramidCurrent, _KeypointsPrevious, _KeypointsPrevious, _KeypointsCurrent,
lk_termination, epsilon, num_iterations,
use_initial_estimate, (UIntPtr)lk_window_dimension
)
};
VX.Release(nodesTrack);
VX.VerifyGraph(graphTrack);
_GraphHarris = graphHarris;
_GraphTrack = graphTrack;
#endregion
}