gray_to_rgba() [1/2]

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

Global threshold writing into caller-supplied buffer.

Parameters

gray	Input span, size must be w * h.
dst	Output span, size must be w * h.
value	Threshold value in [0, 1].

Definition at line 118 of file PixelOps.cpp.

{
    const size_t n = static_cast<size_t>(w) * h;
 
    std::for_each(std::execution::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 = gray.data() + static_cast<size_t>(row) * w;
            float* dst_row = dst.data() + static_cast<size_t>(row) * w * 4;
 
#ifdef MAYAFLUX_ARCH_X64
            // broadcasts each gray scalar into [g,g,g,1] using shuffle
            // process 2 pixels per iteration to get 8 floats = 1 AVX store
            const __m256 alpha_mask = _mm256_set_ps(1.0F, 0.0F, 0.0F, 0.0F,
                1.0F, 0.0F, 0.0F, 0.0F);
            uint32_t px = 0;
            for (; px + 2 <= w; px += 2) {
                const float g0 = src_row[px];
                const float g1 = src_row[px + 1];
                // [g0 g0 g0 1 g1 g1 g1 1]
                __m256 v = _mm256_set_ps(1.0F, g1, g1, g1, 1.0F, g0, g0, g0);
                _mm256_storeu_ps(dst_row + px * 4, v);
            }
            for (; px < w; ++px) {
                const float v = src_row[px];
                dst_row[px * 4] = dst_row[px * 4 + 1] = dst_row[px * 4 + 2] = v;
                dst_row[px * 4 + 3] = 1.0F;
            }
 
#elif defined(MAYAFLUX_ARCH_ARM64)
        const float32x4_t alpha = vdupq_n_f32(1.0F);
        uint32_t px = 0;
        for (; px + 4 <= w; px += 4) {
            float32x4_t g = vld1q_f32(src_row + px);
            float32x4_t lo = vzip1q_f32(g, g); // g0 g0 g1 g1
            float32x4_t hi = vzip2q_f32(g, g); // g2 g2 g3 g3
            float32x4x2_t p01 = vzipq_f32(lo, vdupq_lane_f32(vget_low_f32(alpha), 0));
 
            float32x4x4_t rgba;
            rgba.val[0] = g;
            rgba.val[1] = g;
            rgba.val[2] = g;
            rgba.val[3] = alpha;
            vst4q_f32(dst_row + px * 4, rgba);
            (void)lo;
            (void)hi;
            (void)p01;
        }
        for (; px < w; ++px) {
            const float v = src_row[px];
            dst_row[px * 4] = v;
            dst_row[px * 4 + 1] = v;
            dst_row[px * 4 + 2] = v;
            dst_row[px * 4 + 3] = 1.0F;
        }
 
#else
        for (uint32_t px = 0; px < w; ++px) {
            const float v = src_row[px];
            dst_row[px * 4] = v;
            dst_row[px * 4 + 1] = v;
            dst_row[px * 4 + 2] = v;
            dst_row[px * 4 + 3] = 1.0F;
        }
#endif
        });
}

References alpha, dst, h, and px.

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

Here is the caller graph for this function: