rgba_to_gray() [1/2]

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

Convert RGBA to luminance gray using BT.601 coefficients.

Output is one float per pixel. Alpha channel is discarded. Coefficients: R*0.299 + G*0.587 + B*0.114

Parameters

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

Definition at line 18 of file PixelOps.cpp.

{
    const size_t n = static_cast<size_t>(w) * h;
 
    P::for_each(P::par_unseq,
        std::views::iota(uint32_t { 0 }, h).begin(),
        std::views::iota(uint32_t { 0 }, h).end(),
        [&](uint32_t row) {
            const float* src_row = rgba.data() + static_cast<size_t>(row) * w * 4;
            float* dst_row = dst.data() + static_cast<size_t>(row) * w;
 
#ifdef MAYAFLUX_ARCH_X64
            uint32_t px = 0;
            for (; px + 8 <= w; px += 8) {
                __m128 a0 = _mm_loadu_ps(src_row + px * 4);
                __m128 a1 = _mm_loadu_ps(src_row + px * 4 + 4);
                __m128 a2 = _mm_loadu_ps(src_row + px * 4 + 8);
                __m128 a3 = _mm_loadu_ps(src_row + px * 4 + 12);
                _MM_TRANSPOSE4_PS(a0, a1, a2, a3);
                __m128 lo = _mm_fmadd_ps(a0, _mm_set1_ps(0.299F),
                    _mm_fmadd_ps(a1, _mm_set1_ps(0.587F),
                        _mm_mul_ps(a2, _mm_set1_ps(0.114F))));
 
                __m128 b0 = _mm_loadu_ps(src_row + px * 4 + 16);
                __m128 b1 = _mm_loadu_ps(src_row + px * 4 + 20);
                __m128 b2 = _mm_loadu_ps(src_row + px * 4 + 24);
                __m128 b3 = _mm_loadu_ps(src_row + px * 4 + 28);
                _MM_TRANSPOSE4_PS(b0, b1, b2, b3);
                __m128 hi = _mm_fmadd_ps(b0, _mm_set1_ps(0.299F),
                    _mm_fmadd_ps(b1, _mm_set1_ps(0.587F),
                        _mm_mul_ps(b2, _mm_set1_ps(0.114F))));
 
                _mm256_storeu_ps(dst_row + px, _mm256_set_m128(hi, lo));
            }
            for (; px < w; ++px) {
                const size_t p = px * 4;
                dst_row[px] = src_row[p] * 0.299F
                    + src_row[p + 1] * 0.587F
                    + src_row[p + 2] * 0.114F;
            }
 
#elif defined(MAYAFLUX_ARCH_ARM64)
        const float32x4_t k_r = vdupq_n_f32(0.299F);
        const float32x4_t k_g = vdupq_n_f32(0.587F);
        const float32x4_t k_b = vdupq_n_f32(0.114F);
        uint32_t px = 0;
        for (; px + 4 <= w; px += 4) {
            float32x4x4_t p = vld4q_f32(src_row + px * 4);
            vst1q_f32(dst_row + px,
                vmlaq_f32(vmlaq_f32(vmulq_f32(p.val[0], k_r), p.val[1], k_g), p.val[2], k_b));
        }
        for (; px < w; ++px) {
            const size_t p = px * 4;
            dst_row[px] = src_row[p] * 0.299F
                + src_row[p + 1] * 0.587F
                + src_row[p + 2] * 0.114F;
        }
 
#else
        for (uint32_t px = 0; px < w; ++px) {
            const size_t p = px * 4;
            dst_row[px] = src_row[p] * 0.299F
                + src_row[p + 1] * 0.587F
                + src_row[p + 2] * 0.114F;
        }
#endif
        });
}

References h, hi, and lo.

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

Here is the caller graph for this function: