track_keypoints() [1/2]

MAYAFLUX_API std::vector< TrackResult > MayaFlux::Kinesis::Vision::track_keypoints	(	std::span< const float >	prev_gray,
		std::span< const float >	curr_gray,
		std::span< const float >	grad_dx,
		std::span< const float >	grad_dy,
		uint32_t	w,
		uint32_t	h,
		std::span< const glm::vec2 >	prev_points,
		uint32_t	window_radius = 7,
		uint32_t	max_iterations = 20,
		float	eigen_threshold = 1e-4F,
		float	error_threshold = 0.3F,
		float	forward_backward_threshold = 0.0F
	)

Track keypoints using a pre-computed Sobel gradient of prev_gray.

Identical to the four-parameter overload but accepts caller-supplied dx and dy of the previous frame, avoiding recomputation when the gradient is already cached. dx and dy must be the Sobel gradient of prev_gray at the same w x h resolution.

Parameters

prev_gray	Previous frame, single-channel float, size w * h.
curr_gray	Current frame, single-channel float, size w * h.
grad_dx	Horizontal Sobel gradient of prev_gray, size w * h.
grad_dy	Vertical Sobel gradient of prev_gray, size w * h.
w	Image width in pixels.
h	Image height in pixels.
prev_points	Points to track in normalised [0, 1] coordinates.
window_radius	Half-size of the tracking patch in pixels.
max_iterations	Maximum Newton-Raphson iterations per point.
eigen_threshold	Minimum eigenvalue for structure tensor validity.
error_threshold	Maximum residual error to accept a track.
forward_backward_threshold	Maximum return error in pixels; zero disables the check.

Returns

TrackResult per input point, same order.

Definition at line 192 of file OpticalFlow.cpp.

{
    const size_t np = prev_points.size();
    std::vector<TrackResult> results(np);
    std::vector<float> curr_dx;
    std::vector<float> curr_dy;
    if (forward_backward_threshold > 0.0F) {
        auto grad = sobel(curr_gray, w, h);
        curr_dx = std::move(grad.dx);
        curr_dy = std::move(grad.dy);
    }
 
    std::for_each(std::execution::par_unseq,
        std::views::iota(size_t { 0 }, np).begin(),
        std::views::iota(size_t { 0 }, np).end(),
        [&](size_t i) {
            auto result = lk_point(
                prev_gray, curr_gray,
                grad_dx, grad_dy,
                w, h,
                prev_points[i],
                window_radius,
                max_iterations,
                eigen_threshold,
                error_threshold);
 
            if (forward_backward_threshold > 0.0F && result.tracked) {
                const auto reverse = lk_point(
                    curr_gray, prev_gray,
                    curr_dx, curr_dy,
                    w, h,
                    result.position,
                    window_radius,
                    max_iterations,
                    eigen_threshold,
                    error_threshold);
                const glm::vec2 error_px = (reverse.position - prev_points[i])
                    * glm::vec2(static_cast<float>(w), static_cast<float>(h));
                if (!reverse.tracked || glm::length(error_px) > forward_backward_threshold) {
                    result.position = prev_points[i];
                    result.error = 1.0F;
                    result.tracked = false;
                }
            }
            result.previous = prev_points[i];
            results[i] = result;
        });
 
    return results;
}

References h, and sobel().

Here is the call graph for this function: