threshold_adaptive() [1/2]

MAYAFLUX_API void MayaFlux::Kinesis::Vision::threshold_adaptive	(	std::span< const float >	gray,
		std::span< float >	dst,
		uint32_t	w,
		uint32_t	h,
		uint32_t	block_size,
		float	offset
	)

Adaptive threshold writing into caller-supplied buffer.

Each pixel is thresholded against the mean of its block_size x block_size neighbourhood minus offset. Pixels at the border use a clamped neighbourhood.

Parameters

gray	Input span, size must be w * h.
dst	Output span, size must be w * h.
w	Image width in pixels.
h	Image height in pixels.
block_size	Neighbourhood size in pixels. Must be odd and >= 3.
offset	Subtracted from local mean before comparison.

Definition at line 238 of file PixelOps.cpp.

{
    const size_t n = static_cast<size_t>(w) * h;
    const auto half = static_cast<int32_t>(block_size / 2);
 
    std::for_each(std::execution::par_unseq,
        std::views::iota(size_t { 0 }, n).begin(),
        std::views::iota(size_t { 0 }, n).end(),
        [&](size_t idx) {
            const auto px = static_cast<int32_t>(idx % w);
            const auto py = static_cast<int32_t>(idx / w);
 
            float sum = 0.0F;
            int32_t count = 0;
 
            for (int32_t dy = -half; dy <= half; ++dy) {
                const int32_t ny = std::clamp(py + dy, 0, static_cast<int32_t>(h) - 1);
                for (int32_t dx = -half; dx <= half; ++dx) {
                    const int32_t nx = std::clamp(px + dx, 0, static_cast<int32_t>(w) - 1);
                    sum += gray[static_cast<size_t>(ny) * w + nx];
                    ++count;
                }
            }
 
            const float mean = sum / static_cast<float>(count);
            dst[idx] = gray[idx] >= (mean - offset) ? 1.0F : 0.0F;
        });
}

References count, dst, h, offset, px, and py.

Referenced by MayaFlux::Kinesis::Vision::VisionExecutor::run(), and threshold_adaptive().

Here is the caller graph for this function: