filter_vertical_planes()

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

Fused vertical separable filter over N planes.

Same contract as filter_horizontal_planes but operates vertically.

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 345 of file ImageFilter.cpp.

{
    constexpr size_t Unroll = 4;
 
    const auto half = static_cast<int32_t>(kernel.size() / 2);
    const auto ih = static_cast<int32_t>(h);
    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 auto py = static_cast<int32_t>(row);
            const bool border = (py < half || py >= ih - half);
            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];
                d_ptr[i] = dst[i] + row_off;
            }
 
#ifdef MAYAFLUX_ARCH_X64
            int32_t px = 0;
            if (!border) {
                for (; px + 8 <= iw; 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 size_t off = static_cast<size_t>(py + k) * w
                                + static_cast<size_t>(px);
                            const __m256 kv = _mm256_set1_ps(kdata[static_cast<size_t>(k + half)]);
                            acc0 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 0] + off), kv, acc0);
                            acc1 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 1] + off), kv, acc1);
                            acc2 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 2] + off), kv, acc2);
                            acc3 = _mm256_fmadd_ps(_mm256_loadu_ps(s_ptr[i + 3] + off), 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) {
                            const size_t off = static_cast<size_t>(py + k) * w
                                + static_cast<size_t>(px);
                            acc = _mm256_fmadd_ps(
                                _mm256_loadu_ps(s_ptr[i] + off),
                                _mm256_set1_ps(kdata[static_cast<size_t>(k + half)]),
                                acc);
                        }
                        _mm256_storeu_ps(d_ptr[i] + px, acc);
                    }
                }
            }
            for (; px < iw; ++px) {
                for (size_t i = 0; i < n; ++i) {
                    float acc = 0.0F;
                    for (int32_t k = -half; k <= half; ++k) {
                        const int32_t ny = border ? std::clamp(py + k, 0, ih - 1) : py + k;
                        const size_t off = static_cast<size_t>(ny) * w + static_cast<size_t>(px);
                        acc += s_ptr[i][off] * kdata[static_cast<size_t>(k + half)];
                    }
                    d_ptr[i][px] = acc;
                }
            }
 
#elif defined(MAYAFLUX_ARCH_ARM64)
        int32_t px = 0;
        if (!border) {
            for (; px + 4 <= iw; 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 size_t off = static_cast<size_t>(py + k) * w
                            + static_cast<size_t>(px);
                        const float32x4_t kv = vdupq_n_f32(kdata[static_cast<size_t>(k + half)]);
                        acc0 = vmlaq_f32(acc0, vld1q_f32(s_ptr[i + 0] + off), kv);
                        acc1 = vmlaq_f32(acc1, vld1q_f32(s_ptr[i + 1] + off), kv);
                        acc2 = vmlaq_f32(acc2, vld1q_f32(s_ptr[i + 2] + off), kv);
                        acc3 = vmlaq_f32(acc3, vld1q_f32(s_ptr[i + 3] + off), 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) {
                        const size_t off = static_cast<size_t>(py + k) * w
                            + static_cast<size_t>(px);
                        acc = vmlaq_f32(acc,
                            vld1q_f32(s_ptr[i] + off),
                            vdupq_n_f32(kdata[static_cast<size_t>(k + half)]));
                    }
                    vst1q_f32(d_ptr[i] + px, acc);
                }
            }
        }
        for (; px < iw; ++px) {
            for (size_t i = 0; i < n; ++i) {
                float acc = 0.0F;
                for (int32_t k = -half; k <= half; ++k) {
                    const int32_t ny = border ? std::clamp(py + k, 0, ih - 1) : py + k;
                    const size_t off = static_cast<size_t>(ny) * w + static_cast<size_t>(px);
                    acc += s_ptr[i][off] * kdata[static_cast<size_t>(k + half)];
                }
                d_ptr[i][px] = acc;
            }
        }
 
#else
        for (int32_t px = 0; px < iw; ++px) {
            for (size_t i = 0; i < n; ++i) {
                float acc = 0.0F;
                for (int32_t k = -half; k <= half; ++k) {
                    const int32_t ny = std::clamp(py + k, 0, ih - 1);
                    const size_t off = static_cast<size_t>(ny) * w + static_cast<size_t>(px);
                    acc += s_ptr[i][off] * 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: