blurGaussianMappedImpl()

template<int hRadius, int vRadius, typename RGB_T, typename AlphaT>

FL_OPTIMIZE_FUNCTION void fl::gfx::blurGaussianMappedImpl	(	CanvasMapped< RGB_T > &	canvas,
		AlphaT	alpha )

Definition at line 1212 of file blur.cpp.hpp.

                                                                                    {
    const int w = canvas.width;
    const int h = canvas.height;
    if (w <= 0 || h <= 0)
        return;
 
    // Fast path: rectangular XYMap → delegate to optimized Canvas blur.
    if (canvas.xymap->isRectangularGrid()) {
        Canvas<RGB_T> rect(canvas.pixels, w, h);
        blurGaussianImpl<hRadius, vRadius>(rect, alpha);
        return;
    }
 
    // Slow path: non-rectangular XYMap → per-pixel gather/scatter.
    using P = blur_detail::pixel_ops<RGB_T>;
    using acc_t = fl::conditional_t<sizeof(typename RGB_T::fp) == 1, u16, u32>;
 
    const bool applyAlpha = !(alpha == blur_detail::alpha_identity<AlphaT>());
 
    // Handle no-blur case.
    if (hRadius == 0 && vRadius == 0) {
        if (applyAlpha) {
            for (int y = 0; y < h; ++y) {
                for (int x = 0; x < w; ++x) {
                    RGB_T &p = canvas.at(x, y);
                    P ops;
                    p = ops.make(ops.ch(p.r), ops.ch(p.g), ops.ch(p.b), alpha);
                }
            }
        }
        return;
    }
 
    fl::span<RGB_T> padbuf = blur_detail::get_padbuf<RGB_T>(
        blur_detail::compute_pad_size<hRadius, vRadius, RGB_T>(w, h));
    RGB_T *pad = padbuf.data();
 
    // ── Horizontal pass: gather row via XYMap, convolve, scatter back ──
    if (hRadius > 0) {
        FL_BUILTIN_MEMSET(pad, 0, hRadius * sizeof(RGB_T));
        FL_BUILTIN_MEMSET(pad + hRadius + w, 0, hRadius * sizeof(RGB_T));
 
        for (int y = 0; y < h; ++y) {
            for (int x = 0; x < w; ++x)
                pad[hRadius + x] = canvas.at(x, y);
 
            constexpr int shift = 2 * hRadius;
            for (int x = 0; x < w; ++x) {
                acc_t r, g, b;
                blur_detail::interior_row<hRadius, RGB_T, acc_t>::apply(pad, hRadius + x, r, g, b);
                RGB_T result;
                if (vRadius == 0 && applyAlpha)
                    result = P().make(static_cast<acc_t>(r >> shift),
                                     static_cast<acc_t>(g >> shift),
                                     static_cast<acc_t>(b >> shift), alpha);
                else
                    result = P().make(static_cast<acc_t>(r >> shift),
                                     static_cast<acc_t>(g >> shift),
                                     static_cast<acc_t>(b >> shift));
                canvas.at(x, y) = result;
            }
        }
    }
 
    // ── Vertical pass: gather column via XYMap, convolve, scatter back ──
    if (vRadius > 0) {
        FL_BUILTIN_MEMSET(pad, 0, vRadius * sizeof(RGB_T));
        FL_BUILTIN_MEMSET(pad + vRadius + h, 0, vRadius * sizeof(RGB_T));
 
        for (int x = 0; x < w; ++x) {
            for (int y = 0; y < h; ++y)
                pad[vRadius + y] = canvas.at(x, y);
 
            constexpr int shift = 2 * vRadius;
            for (int y = 0; y < h; ++y) {
                acc_t r, g, b;
                blur_detail::interior_row<vRadius, RGB_T, acc_t>::apply(pad, vRadius + y, r, g, b);
                RGB_T result;
                if (applyAlpha)
                    result = P().make(static_cast<acc_t>(r >> shift),
                                     static_cast<acc_t>(g >> shift),
                                     static_cast<acc_t>(b >> shift), alpha);
                else
                    result = P().make(static_cast<acc_t>(r >> shift),
                                     static_cast<acc_t>(g >> shift),
                                     static_cast<acc_t>(b >> shift));
                canvas.at(x, y) = result;
            }
        }
    }
}

References fl::gfx::blur_detail::alpha_identity(), blurGaussianImpl(), fl::gfx::blur_detail::compute_pad_size(), fl::span< T, Extent >::data(), FL_BUILTIN_MEMSET, fl::FL_NO_EXCEPT, fl::g, fl::gfx::blur_detail::get_padbuf(), fl::P(), fl::x, and fl::y.

Referenced by blurGaussian(), and blurGaussian().

Here is the call graph for this function:

Here is the caller graph for this function: