extract_peaks()

MAYAFLUX_API std::vector< Keypoint > MayaFlux::Kinesis::Vision::extract_peaks	(	std::span< const float >	response,
		uint32_t	w,
		uint32_t	h,
		float	threshold,
		uint32_t	nms_radius
	)

Extract peaks from a response map via non-maximum suppression.

A pixel is a peak if its response exceeds threshold and it is the strict maximum within a square window of half-size nms_radius. Ties are broken in favour of the pixel with the lower raster index.

Returned Keypoints are sorted by descending response.

Parameters

response	Response map span, size must be w * h, values in [0, 1].
w	Image width in pixels.
h	Image height in pixels.
threshold	Minimum response value to consider. In [0, 1].
nms_radius	Non-maximum suppression half-window size in pixels.

Returns

Keypoints sorted by descending response.

Definition at line 197 of file Harris.cpp.

{
    const auto n = static_cast<size_t>(w) * h;
    const auto r = static_cast<int32_t>(nms_radius);
 
    std::vector<Keypoint> keypoints;
 
    for (uint32_t py = 0; py < h; ++py) {
        for (uint32_t px = 0; px < w; ++px) {
            const size_t idx = static_cast<size_t>(py) * w + px;
            const float val = response[idx];
 
            if (val < threshold)
                continue;
 
            bool is_max = true;
            for (int32_t dy = -r; dy <= r && is_max; ++dy) {
                const int32_t ny = static_cast<int32_t>(py) + dy;
                if (ny < 0 || ny >= static_cast<int32_t>(h))
                    continue;
                for (int32_t dx = -r; dx <= r && is_max; ++dx) {
                    if (dx == 0 && dy == 0)
                        continue;
                    const int32_t nx = static_cast<int32_t>(px) + dx;
                    if (nx < 0 || nx >= static_cast<int32_t>(w))
                        continue;
                    const size_t ni = static_cast<size_t>(ny) * w + nx;
                    if (response[ni] >= val)
                        is_max = false;
                }
            }
 
            if (!is_max)
                continue;
 
            keypoints.push_back({
                .position = {
                    (static_cast<float>(px) + 0.5F) / static_cast<float>(w),
                    (static_cast<float>(py) + 0.5F) / static_cast<float>(h) },
                .response = val,
                .scale = 1.0F,
                .angle = 0.0F,
            });
        }
    }
 
    std::ranges::sort(keypoints, [](const Keypoint& a, const Keypoint& b) {
        return a.response > b.response;
    });
 
    return keypoints;
}

References a, b, h, px, py, and threshold.

Referenced by MayaFlux::Yantra::FeatureExtractor< InputType, OutputType >::extract_implementation(), and MayaFlux::Kinesis::Vision::VisionExecutor::run().

Here is the caller graph for this function: