harris_response() [2/2]

MAYAFLUX_API std::vector< float > MayaFlux::Kinesis::Vision::harris_response	(	std::span< const float >	gray,
		uint32_t	w,
		uint32_t	h,
		float	k = 0.04F,
		float	sigma = 1.0F
	)

Compute the Harris corner response map.

For each pixel computes R = det(M) - k * trace(M)^2 where M is the structure tensor accumulated over a sigma-weighted window. Negative responses are clamped to 0. Output is normalised to [0, 1] by the observed peak response.

Structure tensor gradients are computed via a 3x3 Sobel operator. The tensor is smoothed with a Gaussian of standard deviation sigma before computing det and trace.

Parameters

gray	Single-channel float span, size must be w * h.
w	Image width in pixels.
h	Image height in pixels.
k	Harris sensitivity parameter. Typical range [0.04, 0.06].
sigma	Gaussian smoothing sigma for structure tensor. Must be > 0.

Returns

Response map float vector of length w * h, values in [0, 1].

Definition at line 19 of file Harris.cpp.

{
    const size_t n = static_cast<size_t>(w) * h;
 
    auto grad = sobel(gray, w, h);
 
    std::vector<float> ixx(n), iyy(n), ixy(n);
 
    P::for_each(P::par_unseq,
        std::views::iota(size_t { 0 }, n).begin(),
        std::views::iota(size_t { 0 }, n).end(),
        [&](size_t i) {
            const float dx = grad.dx[i];
            const float dy = grad.dy[i];
            ixx[i] = dx * dx;
            iyy[i] = dy * dy;
            ixy[i] = dx * dy;
        });
 
    auto sxx = gaussian_blur(ixx, w, h, sigma);
    auto syy = gaussian_blur(iyy, w, h, sigma);
    auto sxy = gaussian_blur(ixy, w, h, sigma);
 
    std::vector<float> response(n);
 
    P::for_each(P::par_unseq,
        std::views::iota(size_t { 0 }, n).begin(),
        std::views::iota(size_t { 0 }, n).end(),
        [&](size_t i) {
            const float det = sxx[i] * syy[i] - sxy[i] * sxy[i];
            const float trace = sxx[i] + syy[i];
            response[i] = std::max(0.0F, det - k * trace * trace);
        });
 
    const float peak = *std::ranges::max_element(response);
    if (peak > 0.0F) {
        const float inv = 1.0F / peak;
        P::transform(P::par_unseq,
            response.begin(), response.end(), response.begin(),
            [inv](float v) { return v * inv; });
    }
 
    return response;
}

References gaussian_blur(), h, k, MayaFlux::peak(), sigma, and sobel().

Referenced by MayaFlux::Kinesis::Vision::VisionExecutor::run().

Here is the call graph for this function:

Here is the caller graph for this function: