filter_horizontal_planes()

MAYAFLUX_API void MayaFlux::Kinesis::Vision::filter_horizontal_planes	(	std::span< const float *const >	src,
		std::span< float *const >	dst,
		uint32_t	w,
		uint32_t	h,
		std::span< const float >	kernel
	)

Fused horizontal separable filter over N planes.

Applies kernel horizontally to all source planes simultaneously. One row scan reads all N sources and writes all N destinations. N is src.size(); src.size() must equal dst.size().

No aliasing between any src pointer and any dst pointer.

Parameters

src	Source plane pointers, each pointing to w * h floats.
dst	Destination plane pointers, each pointing to w * h floats.
w	Image width in pixels.
h	Image height in pixels.
kernel	1D kernel. Length must be odd.

Definition at line 201 of file ImageFilter.cpp.

{
    constexpr size_t Unroll = 4;
 
    const auto half = static_cast<int32_t>(kernel.size() / 2);
    const auto iw = static_cast<int32_t>(w);
    const float* kdata = kernel.data();
    const size_t n = src.size();
 
    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 size_t row_off = static_cast<size_t>(row) * w;
 
            const float* s_ptr[32];
            float* d_ptr[32];
            for (size_t i = 0; i < n; ++i) {
                s_ptr[i] = src[i] + row_off;
                d_ptr[i] = dst[i] + row_off;
            }
 
            // left border
            for (size_t i = 0; i < n; ++i) {
                for (int32_t px = 0; px < std::min(half, iw); ++px) {
                    float acc = 0.0F;
                    for (int32_t k = -half; k <= half; ++k) {
                        acc += s_ptr[i][std::clamp(px + k, 0, iw - 1)]
                            * kdata[static_cast<size_t>(k + half)];
                    }
                    d_ptr[i][px] = acc;
                }
            }
 
            const int32_t interior_end = iw - half;
 
#ifdef MAYAFLUX_ARCH_X64
            int32_t px = half;
            for (; px + 8 <= interior_end; px += 8) {
                size_t i = 0;
                for (; i + Unroll - 1 < n; i += Unroll) {
                    __m256 acc0 = _mm256_setzero_ps();
                    __m256 acc1 = _mm256_setzero_ps();
                    __m256 acc2 = _mm256_setzero_ps();
                    __m256 acc3 = _mm256_setzero_ps();
                    for (int32_t k = -half; k <= half; ++k) {
                        const __m256 kv = _mm256_set1_ps(kdata[static_cast<size_t>(k + half)]);
                        acc0 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 0] + px + k), kv, acc0);
                        acc1 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 1] + px + k), kv, acc1);
                        acc2 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 2] + px + k), kv, acc2);
                        acc3 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 3] + px + k), kv, acc3);
                    }
                    _mm256_storeu_ps(d_ptr[i + 0] + px, acc0);
                    _mm256_storeu_ps(d_ptr[i + 1] + px, acc1);
                    _mm256_storeu_ps(d_ptr[i + 2] + px, acc2);
                    _mm256_storeu_ps(d_ptr[i + 3] + px, acc3);
                }
                for (; i < n; ++i) {
                    __m256 acc = _mm256_setzero_ps();
                    for (int32_t k = -half; k <= half; ++k) {
                        acc = _mm256_fmadd_ps(
                            _mm256_loadu_ps(s_ptr[i] + px + k),
                            _mm256_set1_ps(kdata[static_cast<size_t>(k + half)]),
                            acc);
                    }
                    _mm256_storeu_ps(d_ptr[i] + px, acc);
                }
            }
            // right border + scalar tail
            for (size_t i = 0; i < n; ++i) {
                for (int32_t px2 = px; px2 < iw; ++px2) {
                    float acc = 0.0F;
                    for (int32_t k = -half; k <= half; ++k) {
                        acc += s_ptr[i][std::clamp(px2 + k, 0, iw - 1)]
                            * kdata[static_cast<size_t>(k + half)];
                    }
                    d_ptr[i][px2] = acc;
                }
            }
 
#elif defined(MAYAFLUX_ARCH_ARM64)
        int32_t px = half;
        for (; px + 4 <= interior_end; px += 4) {
            size_t i = 0;
            for (; i + Unroll - 1 < n; i += Unroll) {
                float32x4_t acc0 = vdupq_n_f32(0.0F);
                float32x4_t acc1 = vdupq_n_f32(0.0F);
                float32x4_t acc2 = vdupq_n_f32(0.0F);
                float32x4_t acc3 = vdupq_n_f32(0.0F);
                for (int32_t k = -half; k <= half; ++k) {
                    const float32x4_t kv = vdupq_n_f32(kdata[static_cast<size_t>(k + half)]);
                    acc0 = vmlaq_f32(acc0, vld1q_f32(s_ptr[i + 0] + px + k), kv);
                    acc1 = vmlaq_f32(acc1, vld1q_f32(s_ptr[i + 1] + px + k), kv);
                    acc2 = vmlaq_f32(acc2, vld1q_f32(s_ptr[i + 2] + px + k), kv);
                    acc3 = vmlaq_f32(acc3, vld1q_f32(s_ptr[i + 3] + px + k), kv);
                }
                vst1q_f32(d_ptr[i + 0] + px, acc0);
                vst1q_f32(d_ptr[i + 1] + px, acc1);
                vst1q_f32(d_ptr[i + 2] + px, acc2);
                vst1q_f32(d_ptr[i + 3] + px, acc3);
            }
            for (; i < n; ++i) {
                float32x4_t acc = vdupq_n_f32(0.0F);
                for (int32_t k = -half; k <= half; ++k)
                    acc = vmlaq_f32(acc,
                        vld1q_f32(s_ptr[i] + px + k),
                        vdupq_n_f32(kdata[static_cast<size_t>(k + half)]));
                vst1q_f32(d_ptr[i] + px, acc);
            }
        }
        for (size_t i = 0; i < n; ++i) {
            for (int32_t px2 = px; px2 < iw; ++px2) {
                float acc = 0.0F;
                for (int32_t k = -half; k <= half; ++k)
                    acc += s_ptr[i][std::clamp(px2 + k, 0, iw - 1)]
                        * kdata[static_cast<size_t>(k + half)];
                d_ptr[i][px2] = acc;
            }
        }
 
#else
        for (size_t i = 0; i < n; ++i) {
            for (int32_t px = half; px < interior_end; ++px) {
                float acc = 0.0F;
                for (int32_t k = -half; k <= half; ++k)
                    acc += s_ptr[i][px + k] * kdata[static_cast<size_t>(k + half)];
                d_ptr[i][px] = acc;
            }
            for (int32_t px = interior_end; px < iw; ++px) {
                float acc = 0.0F;
                for (int32_t k = -half; k <= half; ++k)
                    acc += s_ptr[i][std::clamp(px + k, 0, iw - 1)]
                        * kdata[static_cast<size_t>(k + half)];
                d_ptr[i][px] = acc;
            }
        }
#endif
        });
}

References h, and k.

Referenced by harris_response().

Here is the caller graph for this function: