threshold_otsu() [2/2]

MAYAFLUX_API void MayaFlux::Kinesis::Vision::threshold_otsu	(	std::span< const float >	gray,
		std::span< float >	dst
	)

Otsu threshold writing into caller-supplied buffer.

Finds the optimal global threshold by maximising inter-class variance, then applies it.

Parameters

gray	Input span, size must be w * h.
dst	Output span, size must be w * h.

Definition at line 299 of file PixelOps.cpp.

{
    constexpr int32_t bins = 256;
    std::array<float, bins> hist {};
 
    for (float v : gray)
        hist[static_cast<int32_t>(std::clamp(v, 0.0F, 1.0F) * (bins - 1))]++;
 
    const auto total = static_cast<float>(gray.size());
    for (auto& h : hist)
        h /= total;
 
    float sum_all = 0.0F;
    for (int32_t i = 0; i < bins; ++i)
        sum_all += static_cast<float>(i) * hist[i];
 
    float sum_bg = 0.0F;
    float w_bg = 0.0F;
    float best_var = 0.0F;
    int32_t best_t = 0;
 
    for (int32_t t = 0; t < bins; ++t) {
        w_bg += hist[t];
        if (w_bg == 0.0F)
            continue;
 
        const float w_fg = 1.0F - w_bg;
        if (w_fg == 0.0F)
            break;
 
        sum_bg += static_cast<float>(t) * hist[t];
 
        const float mean_bg = sum_bg / w_bg;
        const float mean_fg = (sum_all - sum_bg) / w_fg;
        const float diff = mean_fg - mean_bg;
        const float var = w_bg * w_fg * diff * diff;
 
        if (var > best_var) {
            best_var = var;
            best_t = t;
        }
    }
 
    const float t_norm = static_cast<float>(best_t) / static_cast<float>(bins - 1);
    threshold(gray, dst, t_norm);
}

References h, and threshold.

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

Here is the caller graph for this function: