rgba_to_hsv() [1/2]

MAYAFLUX_API void MayaFlux::Kinesis::Vision::rgba_to_hsv	(	std::span< const float >	rgba,
		std::span< float >	dst,
		uint32_t	w,
		uint32_t	h
	)

Convert RGBA to HSV writing into caller-supplied buffer.

Output is interleaved HSV, 3 floats per pixel. H in [0, 1], S and V in [0, 1]. Alpha channel is discarded.

Parameters

rgba	Interleaved RGBA span, size must be w * h * 4.
dst	Output span, size must be w * h * 3.
w	Image width in pixels.
h	Image height in pixels.

Definition at line 94 of file PixelOps.cpp.

{
    const size_t n = static_cast<size_t>(w) * h;
    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 r = rgba[i * 4];
            const float g = rgba[i * 4 + 1];
            const float b = rgba[i * 4 + 2];
 
            const float cmax = std::max({ r, g, b });
            const float cmin = std::min({ r, g, b });
            const float delta = cmax - cmin;
 
            float h_val = 0.0F;
            if (delta > 0.0F) {
                if (cmax == r) {
                    h_val = std::fmod((g - b) / delta, 6.0F);
                } else if (cmax == g) {
                    h_val = (b - r) / delta + 2.0F;
                } else {
                    h_val = (r - g) / delta + 4.0F;
                }
                h_val /= 6.0F;
                if (h_val < 0.0F)
                    h_val += 1.0F;
            }
 
            dst[i * 3] = h_val;
            dst[i * 3 + 1] = cmax > 0.0F ? delta / cmax : 0.0F;
            dst[i * 3 + 2] = cmax;
        });
}

References b, and h.

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

Here is the caller graph for this function: