【原创源码】高斯模糊算法

简qt

高斯模糊高效实现方案分享

轻量自研算法，技术交流为主，欢迎理性探讨。

核心亮点

1. 底层纯算法架构：基于GDIPlus模块高斯模糊核心逻辑，代码轻量化且可扩展性强
2. 极致性能表现：针对1920×1080分辨率图片处理，单次高斯模糊耗时仅1.7431769秒。

求求给点支持和精币，不喜勿喷。

要gdiplus模块，且要先初始化

.版本 2

.程序集变量 线程_高斯_参数, 整数型, , "0"
.程序集变量 线程_高斯_句柄, 整数型, , "0"
.程序集变量 线程_核权重X, 整数型, , "0"
.程序集变量 线程_核权重Y, 整数型, , "0"
.程序集变量 线程_核指针X, 整数型
.程序集变量 线程_核指针Y, 整数型
.程序集变量 线程_核尺寸X, 整数型
.程序集变量 线程_核尺寸Y, 整数型
.程序集变量 线程_临时指针, 整数型
.程序集变量 线程_宽, 整数型
.程序集变量 线程_高, 整数型
.程序集变量 线程_行偏移, 整数型, , "0"
.程序集变量 线程_列偏移, 整数型, , "0"
.版本 2
.支持库 spec
.支持库 EThread

.子程序 高斯模糊, 字节集, 公开, 未名·https://bbs.ijingyi.com/?757710
.参数 图片, 字节集, , 返回的字节集图片格式，Gdiplus常量“图像格式_xxx”
.参数 图片格式, 文本型, 可空
.参数 标准差_小, 小数型, 可空
.参数 标准差_大, 小数型, 可空
.参数 高斯核X, 整数型, 可空
.参数 高斯核Y, 整数型, 可空
.参数 精度, 整数型, 可空, 权重放大倍数（默认4096，越小越快但精度越低，建议1024~8192）
.局部变量 局_位图, GP位图
.局部变量 局_新位图, GP位图
.局部变量 局_矩形, 矩形L
.局部变量 局_锁定区, 矩形L
.局部变量 局_位数据, 位图数据
.局部变量 局_sigmaX, 小数型
.局部变量 局_sigmaY, 小数型
.局部变量 局_i, 整数型
.局部变量 局_j, 整数型
.局部变量 局_权重总和, 整数型
.局部变量 局_临时缓冲区, 字节集
.局部变量 局_行, 整数型
.局部变量 局_列, 整数型
.局部变量 局_源行首, 整数型
.局部变量 局_目标行首, 整数型
.局部变量 局_核指针, 整数型
.局部变量 局_权重, 整数型
.局部变量 局_源指针, 整数型
.局部变量 局_蓝, 整数型
.局部变量 局_绿, 整数型
.局部变量 局_红, 整数型
.局部变量 局_阿尔法, 整数型
.局部变量 局_蓝和, 整数型
.局部变量 局_绿和, 整数型
.局部变量 局_红和, 整数型
.局部变量 局_结果, 字节集
.局部变量 局_expFactor, 双精度小数型
.局部变量 局_权重0, 整数型
.局部变量 局_核半径X, 整数型
.局部变量 局_核半径Y, 整数型
.局部变量 局_精度, 整数型
.局部变量 局_右移位, 整数型
.局部变量 局_线程数, 整数型
.局部变量 局_核心数, 整数型
.局部变量 局_CPU信息, 类_CPU信息
.局部变量 局_使用多线程, 逻辑型
.局部变量 局_每块行数, 整数型
.局部变量 局_起始行, 整数型
.局部变量 局_结束行, 整数型
.局部变量 局_行jz, 整数型

.如果 (是否为空 (精度))
    局_精度 ＝ 4096
    局_右移位 ＝ 12
.否则
    局_精度 ＝ 精度
    局_i ＝ 局_精度
    .判断循环首 (局_i ＞ 1)
        局_i ＝ 局_i ÷ 2
        局_右移位 ＝ 局_右移位 ＋ 1
    .判断循环尾 ()
.如果结束
局_位图.创建自字节集 (图片, )
.如果真 (局_位图.取指针 () ＝ 0)
    返回 ({  })
.如果真结束

线程_宽 ＝ 局_位图.取宽度 ()
线程_高 ＝ 局_位图.取高度 ()

.如果真 (局_位图.取像素格式 () ≠ #像素格式_32bppARGB)
    局_矩形.宽度 ＝ 线程_宽
    局_矩形.高度 ＝ 线程_高
    局_位图.复制部分I (局_矩形, #像素格式_32bppARGB, 局_新位图)
    局_位图.销毁 ()
    局_位图 ＝ 局_新位图
    局_新位图.置指针 (0)
.如果真结束

局_锁定区.宽度 ＝ 线程_宽
局_锁定区.高度 ＝ 线程_高
.如果真 (局_位图.锁定数据 (局_锁定区, #图像锁定模式_读 ＋ #图像锁定模式_写, #像素格式_32bppARGB, 局_位数据) ＝ 假)
    局_位图.销毁 ()
    返回 ({  })
.如果真结束
.如果真 (是否为空 (高斯核X))
    线程_核尺寸X ＝ 高斯核X
.如果真结束
.如果真 (是否为空 (高斯核Y))
    线程_核尺寸Y ＝ 线程_核尺寸X
    线程_核尺寸Y ＝ 高斯核Y
.如果真结束
.如果真 (是否为空 (标准差_小))
    局_sigmaX ＝ 标准差_小
.如果真结束
.如果真 (是否为空 (标准差_大))
    局_sigmaY ＝ 局_sigmaX
    局_sigmaY ＝ 标准差_大
.如果真结束
.如果 (线程_核尺寸X ≤ 0)
    .如果 (局_sigmaX ＞ 0)
        线程_核尺寸X ＝ 取整 (局_sigmaX × 6 ＋ 0.999999)
        .如果真 (线程_核尺寸X ％ 2 ＝ 0)
            线程_核尺寸X ＝ 线程_核尺寸X ＋ 1
        .如果真结束

    .否则
        线程_核尺寸X ＝ 5
    .如果结束

.否则
    .如果 (局_sigmaX ≤ 0)
        局_sigmaX ＝ (线程_核尺寸X － 1) ÷ 6
    .否则

    .如果结束

.如果结束
.如果 (线程_核尺寸Y ≤ 0)
    .如果 (局_sigmaY ＞ 0)
        线程_核尺寸Y ＝ 取整 (局_sigmaY × 6 ＋ 0.999999)
        .如果真 (线程_核尺寸Y ％ 2 ＝ 0)
            线程_核尺寸Y ＝ 线程_核尺寸Y ＋ 1
        .如果真结束

    .否则
        线程_核尺寸Y ＝ 线程_核尺寸X
    .如果结束

.否则
    .如果 (局_sigmaY ≤ 0)
        局_sigmaY ＝ (线程_核尺寸Y － 1) ÷ 6
    .否则

    .如果结束

.如果结束

局_核半径X ＝ (线程_核尺寸X － 1) ÷ 2
局_核半径Y ＝ (线程_核尺寸Y － 1) ÷ 2

重定义数组 (线程_核权重X, 假, 线程_核尺寸X)
.如果 (局_sigmaX ＞ 0)
    局_expFactor ＝ 1 ÷ (2 × 局_sigmaX × 局_sigmaX)
    局_权重0 ＝ 取整 (局_精度 × 求次方 (#e, 0))
    线程_核权重X [局_核半径X ＋ 1] ＝ 局_权重0
    局_权重总和 ＝ 局_权重0
    .变量循环首 (1, 局_核半径X, 1, 局_i)
        线程_核权重X [局_核半径X ＋ 1 ＋ 局_i] ＝ 取整 (线程_核权重X [局_核半径X ＋ 1 ＋ 局_i － 1] × 求次方 (#e, －(2 × 局_i － 1) × 局_expFactor))
        线程_核权重X [局_核半径X ＋ 1 － 局_i] ＝ 线程_核权重X [局_核半径X ＋ 1 ＋ 局_i]
        局_权重总和 ＝ 局_权重总和 ＋ 线程_核权重X [局_核半径X ＋ 1 ＋ 局_i] × 2
    .变量循环尾 ()
.否则
    .变量循环首 (1, 线程_核尺寸X, 1, 局_j)
        线程_核权重X [局_j] ＝ 局_精度 ÷ 线程_核尺寸X
    .变量循环尾 ()
    局_权重总和 ＝ 局_精度
.如果结束

' 归一化
.如果 (局_权重总和 ≠ 局_精度)
    .变量循环首 (1, 线程_核尺寸X, 1, 局_j)
        线程_核权重X [局_j] ＝ 线程_核权重X [局_j] × 局_精度 ÷ 局_权重总和
    .变量循环尾 ()
.否则

.如果结束
重定义数组 (线程_核权重Y, 假, 线程_核尺寸Y)
.如果 (局_sigmaY ＞ 0)
    局_expFactor ＝ 1 ÷ (2 × 局_sigmaY × 局_sigmaY)
    局_权重0 ＝ 取整 (局_精度 × 求次方 (#e, 0))
    线程_核权重Y [局_核半径Y ＋ 1] ＝ 局_权重0
    局_权重总和 ＝ 局_权重0
    .变量循环首 (1, 局_核半径Y, 1, 局_i)
        线程_核权重Y [局_核半径Y ＋ 1 ＋ 局_i] ＝ 取整 (线程_核权重Y [局_核半径Y ＋ 1 ＋ 局_i － 1] × 求次方 (#e, －(2 × 局_i － 1) × 局_expFactor))
        线程_核权重Y [局_核半径Y ＋ 1 － 局_i] ＝ 线程_核权重Y [局_核半径Y ＋ 1 ＋ 局_i]
        局_权重总和 ＝ 局_权重总和 ＋ 线程_核权重Y [局_核半径Y ＋ 1 ＋ 局_i] × 2
    .变量循环尾 ()
.否则
    .变量循环首 (1, 线程_核尺寸Y, 1, 局_j)
        线程_核权重Y [局_j] ＝ 局_精度 ÷ 线程_核尺寸Y
    .变量循环尾 ()
    局_权重总和 ＝ 局_精度
.如果结束

.如果 (局_权重总和 ≠ 局_精度)
    .变量循环首 (1, 线程_核尺寸Y, 1, 局_j)
        线程_核权重Y [局_j] ＝ 线程_核权重Y [局_j] × 局_精度 ÷ 局_权重总和
    .变量循环尾 ()
.否则

.如果结束

线程_核指针X ＝ 取变量数据地址 (线程_核权重X)
线程_核指针Y ＝ 取变量数据地址 (线程_核权重Y)

重定义数组 (线程_行偏移, 假, 线程_核尺寸Y)
重定义数组 (线程_列偏移, 假, 线程_核尺寸X)
.变量循环首 (0, 线程_核尺寸Y － 1, 1, 局_i)
    线程_行偏移 [局_i ＋ 1] ＝ (局_i － 局_核半径Y) × 线程_宽 × 4
.变量循环尾 ()
.变量循环首 (0, 线程_核尺寸X － 1, 1, 局_i)
    线程_列偏移 [局_i ＋ 1] ＝ (局_i － 局_核半径X) × 4
.变量循环尾 ()

局_临时缓冲区 ＝ 取空白字节集 (线程_高 × 线程_宽 × 4)
线程_临时指针 ＝ 取变量数据地址 (局_临时缓冲区)

.如果 (线程_宽 × 线程_高 ＞ 1048576)
    局_核心数 ＝ 局_CPU信息.取核心数 ()
    .如果真 (局_核心数 ＞ 1)
        局_使用多线程 ＝ 真
        局_线程数 ＝ 局_核心数
        .如果真 (局_线程数 ＞ 8)
            局_线程数 ＝ 8
        .如果真结束

    .如果真结束

.否则

.如果结束

.如果 (局_使用多线程)
    局_每块行数 ＝ (线程_高 ＋ 局_线程数 － 1) ÷ 局_线程数
    重定义数组 (线程_高斯_参数, 假, 局_线程数, 7)
    重定义数组 (线程_高斯_句柄, 假, 局_线程数)
    .计次循环首 (局_线程数, 局_i)
        局_起始行 ＝ (局_i － 1) × 局_每块行数
        局_结束行 ＝ 局_起始行 ＋ 局_每块行数 － 1
        .如果真 (局_起始行 ≥ 线程_高)
            到循环尾 ()
        .如果真结束
        .如果真 (局_结束行 ≥ 线程_高)
            局_结束行 ＝ 线程_高 － 1
        .如果真结束
        线程_高斯_参数 [局_i] [1] ＝ 局_位数据.像素数据
        线程_高斯_参数 [局_i] [2] ＝ 局_位数据.跨步
        线程_高斯_参数 [局_i] [3] ＝ 局_起始行
        线程_高斯_参数 [局_i] [4] ＝ 局_结束行
        线程_高斯_参数 [局_i] [5] ＝ 局_核半径X
        线程_高斯_参数 [局_i] [6] ＝ 线程_核尺寸X
        线程_高斯_参数 [局_i] [7] ＝ 局_右移位
        启动线程 (&_线程处理_横向卷积, 局_i, 线程_高斯_句柄 [局_i])
    .计次循环尾 ()
    .计次循环首 (局_线程数, 局_i)
        .如果真 (线程_高斯_句柄 [局_i] ≠ 0)
            等待线程 (线程_高斯_句柄 [局_i], -1)
            关闭线程句柄 (线程_高斯_句柄 [局_i])
        .如果真结束

    .计次循环尾 ()

    局_每块行数 ＝ (线程_高 ＋ 局_线程数 － 1) ÷ 局_线程数
    重定义数组 (线程_高斯_参数, 假, 局_线程数, 7)
    .计次循环首 (局_线程数, 局_i)
        局_起始行 ＝ (局_i － 1) × 局_每块行数
        局_结束行 ＝ 局_起始行 ＋ 局_每块行数 － 1
        .如果真 (局_起始行 ≥ 线程_高)
            到循环尾 ()
        .如果真结束
        .如果真 (局_结束行 ≥ 线程_高)
            局_结束行 ＝ 线程_高 － 1
        .如果真结束
        线程_高斯_参数 [局_i] [1] ＝ 局_位数据.像素数据
        线程_高斯_参数 [局_i] [2] ＝ 局_位数据.跨步
        线程_高斯_参数 [局_i] [3] ＝ 局_起始行
        线程_高斯_参数 [局_i] [4] ＝ 局_结束行
        线程_高斯_参数 [局_i] [5] ＝ 局_核半径Y
        线程_高斯_参数 [局_i] [6] ＝ 线程_核尺寸Y
        线程_高斯_参数 [局_i] [7] ＝ 局_右移位
        启动线程 (&_线程处理_纵向卷积, 局_i, 线程_高斯_句柄 [局_i])
    .计次循环尾 ()
    .计次循环首 (局_线程数, 局_i)
        .如果真 (线程_高斯_句柄 [局_i] ≠ 0)
            等待线程 (线程_高斯_句柄 [局_i], -1)
            关闭线程句柄 (线程_高斯_句柄 [局_i])
        .如果真结束

    .计次循环尾 ()
.否则

    .变量循环首 (0, 线程_高 － 1, 1, 局_行)
        局_源行首 ＝ 局_位数据.像素数据 ＋ 局_行 × 局_位数据.跨步
        局_目标行首 ＝ 线程_临时指针 ＋ 局_行 × 线程_宽 × 4

        ' 左边界区
        .变量循环首 (0, 局_核半径X － 1, 1, 局_列)
            局_核指针 ＝ 线程_核指针X
            局_蓝和 ＝ 0
            局_绿和 ＝ 0
            局_红和 ＝ 0
            .变量循环首 (0, 线程_核尺寸X － 1, 1, 局_i)
                局_权重 ＝ 指针到整数 (局_核指针)
                局_核指针 ＝ 局_核指针 ＋ 4
                .如果 (局_列 ＋ 局_i ＜ 局_核半径X)
                    局_源指针 ＝ 局_源行首
                .否则
                    局_源指针 ＝ 局_源行首 ＋ (局_列 ＋ 局_i － 局_核半径X) × 4
                .如果结束
                局_蓝 ＝ 指针到字节 (局_源指针)
                局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
            .变量循环尾 ()
            局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
            写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
        .变量循环尾 ()

        ' 中间安全区
        .变量循环首 (局_核半径X, 线程_宽 － 局_核半径X － 1, 1, 局_列)
            局_核指针 ＝ 线程_核指针X
            局_源指针 ＝ 局_源行首 ＋ (局_列 － 局_核半径X) × 4
            局_蓝和 ＝ 0
            局_绿和 ＝ 0
            局_红和 ＝ 0
            .变量循环首 (0, 线程_核尺寸X － 1, 1, 局_i)
                局_权重 ＝ 指针到整数 (局_核指针)
                局_核指针 ＝ 局_核指针 ＋ 4
                局_蓝 ＝ 指针到字节 (局_源指针)
                局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                局_源指针 ＝ 局_源指针 ＋ 4
            .变量循环尾 ()
            局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
            写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
        .变量循环尾 ()

        ' 右边界区
        .变量循环首 (线程_宽 － 局_核半径X, 线程_宽 － 1, 1, 局_列)
            局_核指针 ＝ 线程_核指针X
            局_蓝和 ＝ 0
            局_绿和 ＝ 0
            局_红和 ＝ 0
            .变量循环首 (0, 线程_核尺寸X － 1, 1, 局_i)
                局_权重 ＝ 指针到整数 (局_核指针)
                局_核指针 ＝ 局_核指针 ＋ 4
                .如果 (局_列 ＋ 局_i － 局_核半径X ≥ 线程_宽)
                    局_源指针 ＝ 局_源行首 ＋ (线程_宽 － 1) × 4
                .否则
                    局_源指针 ＝ 局_源行首 ＋ (局_列 ＋ 局_i － 局_核半径X) × 4
                .如果结束
                局_蓝 ＝ 指针到字节 (局_源指针)
                局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
            .变量循环尾 ()
            局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
            写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
        .变量循环尾 ()
    .变量循环尾 ()
    .变量循环首 (0, 线程_高 － 1, 1, 局_行)
        局_目标行首 ＝ 局_位数据.像素数据 ＋ 局_行 × 局_位数据.跨步
        局_源行首 ＝ 线程_临时指针 ＋ 局_行 × 线程_宽 × 4

        ' 上边界区
        .如果 (局_行 ＜ 局_核半径Y)
            .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
                局_核指针 ＝ 线程_核指针Y
                局_蓝和 ＝ 0
                局_绿和 ＝ 0
                局_红和 ＝ 0
                .变量循环首 (0, 线程_核尺寸Y － 1, 1, 局_i)
                    局_权重 ＝ 指针到整数 (局_核指针)
                    局_核指针 ＝ 局_核指针 ＋ 4
                    .如果 (局_行 ＋ 局_i － 局_核半径Y ＜ 0)
                        局_源指针 ＝ 线程_临时指针 ＋ 局_列 × 4
                    .否则
                        局_源指针 ＝ 线程_临时指针 ＋ (局_行 ＋ 局_i － 局_核半径Y) × 线程_宽 × 4 ＋ 局_列 × 4
                    .如果结束
                    局_蓝 ＝ 指针到字节 (局_源指针)
                    局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                    局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                    局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                    局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                    局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                .变量循环尾 ()
                局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
                写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
            .变量循环尾 ()
        .否则
            .如果 (局_行 ＞ 线程_高 － 局_核半径Y － 1)
                ' 下边界区
                .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
                    局_核指针 ＝ 线程_核指针Y
                    局_蓝和 ＝ 0
                    局_绿和 ＝ 0
                    局_红和 ＝ 0
                    .变量循环首 (0, 线程_核尺寸Y － 1, 1, 局_i)
                        局_权重 ＝ 指针到整数 (局_核指针)
                        局_核指针 ＝ 局_核指针 ＋ 4
                        .如果 (局_行 ＋ 局_i － 局_核半径Y ≥ 线程_高)
                            局_源指针 ＝ 线程_临时指针 ＋ (线程_高 － 1) × 线程_宽 × 4 ＋ 局_列 × 4
                        .否则
                            局_源指针 ＝ 线程_临时指针 ＋ (局_行 ＋ 局_i － 局_核半径Y) × 线程_宽 × 4 ＋ 局_列 × 4
                        .如果结束
                        局_蓝 ＝ 指针到字节 (局_源指针)
                        局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                        局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                        局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                        局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                        局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                    .变量循环尾 ()
                    局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
                    写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
                .变量循环尾 ()
            .否则
                ' 中间安全区
                局_行jz ＝ 线程_临时指针 ＋ (局_行 － 局_核半径Y) × 线程_宽 × 4
                .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
                    局_核指针 ＝ 线程_核指针Y
                    局_源指针 ＝ 局_行jz ＋ 局_列 × 4
                    局_蓝和 ＝ 0
                    局_绿和 ＝ 0
                    局_红和 ＝ 0
                    .变量循环首 (0, 线程_核尺寸Y － 1, 1, 局_i)
                        局_权重 ＝ 指针到整数 (局_核指针)
                        局_核指针 ＝ 局_核指针 ＋ 4
                        局_蓝 ＝ 指针到字节 (局_源指针)
                        局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                        局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                        局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                        局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                        局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                        局_源指针 ＝ 局_源指针 ＋ 线程_宽 × 4
                    .变量循环尾 ()
                    局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
                    写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
                    写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
                .变量循环尾 ()
            .如果结束

        .如果结束

    .变量循环尾 ()
.如果结束
局_位图.解锁数据 (局_位数据)
局_结果 ＝ 局_位图.保存到字节集 (图片格式, )
局_位图.销毁 ()
返回 (局_结果)

.子程序 _线程处理_横向卷积
.参数 线程索引, 整数型
.局部变量 局_像素jz, 整数型
.局部变量 局_跨步, 整数型
.局部变量 局_起始行, 整数型
.局部变量 局_结束行, 整数型
.局部变量 局_核半径, 整数型
.局部变量 局_核尺寸, 整数型
.局部变量 局_右移位, 整数型
.局部变量 局_行, 整数型
.局部变量 局_列, 整数型
.局部变量 局_源行首, 整数型
.局部变量 局_目标行首, 整数型
.局部变量 局_核指针, 整数型
.局部变量 局_权重, 整数型
.局部变量 局_源指针, 整数型
.局部变量 局_蓝, 整数型
.局部变量 局_绿, 整数型
.局部变量 局_红, 整数型
.局部变量 局_阿尔法, 整数型
.局部变量 局_蓝和, 整数型
.局部变量 局_绿和, 整数型
.局部变量 局_红和, 整数型
.局部变量 局_i, 整数型

局_像素jz ＝ 线程_高斯_参数 [线程索引] [1]
局_跨步 ＝ 线程_高斯_参数 [线程索引] [2]
局_起始行 ＝ 线程_高斯_参数 [线程索引] [3]
局_结束行 ＝ 线程_高斯_参数 [线程索引] [4]
局_核半径 ＝ 线程_高斯_参数 [线程索引] [5]
局_核尺寸 ＝ 线程_高斯_参数 [线程索引] [6]
局_右移位 ＝ 线程_高斯_参数 [线程索引] [7]

.变量循环首 (局_起始行, 局_结束行, 1, 局_行)
    局_源行首 ＝ 局_像素jz ＋ 局_行 × 局_跨步
    局_目标行首 ＝ 线程_临时指针 ＋ 局_行 × 线程_宽 × 4

    ' 左边界区
    .变量循环首 (0, 局_核半径 － 1, 1, 局_列)
        局_核指针 ＝ 线程_核指针X
        局_蓝和 ＝ 0
        局_绿和 ＝ 0
        局_红和 ＝ 0
        .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
            局_权重 ＝ 指针到整数 (局_核指针)
            局_核指针 ＝ 局_核指针 ＋ 4
            .如果 (局_列 ＋ 局_i ＜ 局_核半径)
                局_源指针 ＝ 局_源行首
            .否则
                局_源指针 ＝ 局_源行首 ＋ (局_列 ＋ 局_i － 局_核半径) × 4
            .如果结束
            局_蓝 ＝ 指针到字节 (局_源指针)
            局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
            局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
            局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
            局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
            局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
        .变量循环尾 ()
        局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
        写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
    .变量循环尾 ()

    ' 中间安全区
    .变量循环首 (局_核半径, 线程_宽 － 局_核半径 － 1, 1, 局_列)
        局_核指针 ＝ 线程_核指针X
        局_源指针 ＝ 局_源行首 ＋ (局_列 － 局_核半径) × 4
        局_蓝和 ＝ 0
        局_绿和 ＝ 0
        局_红和 ＝ 0
        .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
            局_权重 ＝ 指针到整数 (局_核指针)
            局_核指针 ＝ 局_核指针 ＋ 4
            局_蓝 ＝ 指针到字节 (局_源指针)
            局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
            局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
            局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
            局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
            局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
            局_源指针 ＝ 局_源指针 ＋ 4
        .变量循环尾 ()
        局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
        写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
    .变量循环尾 ()

    ' 右边界区
    .变量循环首 (线程_宽 － 局_核半径, 线程_宽 － 1, 1, 局_列)
        局_核指针 ＝ 线程_核指针X
        局_蓝和 ＝ 0
        局_绿和 ＝ 0
        局_红和 ＝ 0
        .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
            局_权重 ＝ 指针到整数 (局_核指针)
            局_核指针 ＝ 局_核指针 ＋ 4
            .如果 (局_列 ＋ 局_i － 局_核半径 ≥ 线程_宽)
                局_源指针 ＝ 局_源行首 ＋ (线程_宽 － 1) × 4
            .否则
                局_源指针 ＝ 局_源行首 ＋ (局_列 ＋ 局_i － 局_核半径) × 4
            .如果结束
            局_蓝 ＝ 指针到字节 (局_源指针)
            局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
            局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
            局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
            局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
            局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
        .变量循环尾 ()
        局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
        写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
        写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
    .变量循环尾 ()
.变量循环尾 ()

.子程序 _线程处理_纵向卷积
.参数 线程索引, 整数型
.局部变量 局_像素jz, 整数型
.局部变量 局_跨步, 整数型
.局部变量 局_起始行, 整数型
.局部变量 局_结束行, 整数型
.局部变量 局_核半径, 整数型
.局部变量 局_核尺寸, 整数型
.局部变量 局_右移位, 整数型
.局部变量 局_行, 整数型
.局部变量 局_列, 整数型
.局部变量 局_目标行首, 整数型
.局部变量 局_源行首, 整数型
.局部变量 局_核指针, 整数型
.局部变量 局_权重, 整数型
.局部变量 局_源指针, 整数型
.局部变量 局_蓝, 整数型
.局部变量 局_绿, 整数型
.局部变量 局_红, 整数型
.局部变量 局_阿尔法, 整数型
.局部变量 局_蓝和, 整数型
.局部变量 局_绿和, 整数型
.局部变量 局_红和, 整数型
.局部变量 局_i, 整数型
.局部变量 局_行jz, 整数型

局_像素jz ＝ 线程_高斯_参数 [线程索引] [1]
局_跨步 ＝ 线程_高斯_参数 [线程索引] [2]
局_起始行 ＝ 线程_高斯_参数 [线程索引] [3]
局_结束行 ＝ 线程_高斯_参数 [线程索引] [4]
局_核半径 ＝ 线程_高斯_参数 [线程索引] [5]
局_核尺寸 ＝ 线程_高斯_参数 [线程索引] [6]
局_右移位 ＝ 线程_高斯_参数 [线程索引] [7]

.变量循环首 (局_起始行, 局_结束行, 1, 局_行)
    局_目标行首 ＝ 局_像素jz ＋ 局_行 × 局_跨步
    局_源行首 ＝ 线程_临时指针 ＋ 局_行 × 线程_宽 × 4

    ' 上边界区
    .如果 (局_行 ＜ 局_核半径)
        .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
            局_核指针 ＝ 线程_核指针Y
            局_蓝和 ＝ 0
            局_绿和 ＝ 0
            局_红和 ＝ 0
            .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
                局_权重 ＝ 指针到整数 (局_核指针)
                局_核指针 ＝ 局_核指针 ＋ 4
                .如果 (局_行 ＋ 局_i － 局_核半径 ＜ 0)
                    局_源指针 ＝ 线程_临时指针 ＋ 局_列 × 4
                .否则
                    局_源指针 ＝ 线程_临时指针 ＋ (局_行 ＋ 局_i － 局_核半径) × 线程_宽 × 4 ＋ 局_列 × 4
                .如果结束
                局_蓝 ＝ 指针到字节 (局_源指针)
                局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
            .变量循环尾 ()
            局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
            写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
            写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
        .变量循环尾 ()
    .否则
        .如果 (局_行 ＞ 线程_高 － 局_核半径 － 1)
            ' 下边界区
            .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
                局_核指针 ＝ 线程_核指针Y
                局_蓝和 ＝ 0
                局_绿和 ＝ 0
                局_红和 ＝ 0
                .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
                    局_权重 ＝ 指针到整数 (局_核指针)
                    局_核指针 ＝ 局_核指针 ＋ 4
                    .如果 (局_行 ＋ 局_i － 局_核半径 ≥ 线程_高)
                        局_源指针 ＝ 线程_临时指针 ＋ (线程_高 － 1) × 线程_宽 × 4 ＋ 局_列 × 4
                    .否则
                        局_源指针 ＝ 线程_临时指针 ＋ (局_行 ＋ 局_i － 局_核半径) × 线程_宽 × 4 ＋ 局_列 × 4
                    .如果结束
                    局_蓝 ＝ 指针到字节 (局_源指针)
                    局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                    局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                    局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                    局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                    局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                .变量循环尾 ()
                局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
                写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
            .变量循环尾 ()
        .否则
            ' 中间安全区
            局_行jz ＝ 线程_临时指针 ＋ (局_行 － 局_核半径) × 线程_宽 × 4
            .变量循环首 (0, 线程_宽 － 1, 1, 局_列)
                局_核指针 ＝ 线程_核指针Y
                局_源指针 ＝ 局_行jz ＋ 局_列 × 4
                局_蓝和 ＝ 0
                局_绿和 ＝ 0
                局_红和 ＝ 0
                .变量循环首 (0, 局_核尺寸 － 1, 1, 局_i)
                    局_权重 ＝ 指针到整数 (局_核指针)
                    局_核指针 ＝ 局_核指针 ＋ 4
                    局_蓝 ＝ 指针到字节 (局_源指针)
                    局_绿 ＝ 指针到字节 (局_源指针 ＋ 1)
                    局_红 ＝ 指针到字节 (局_源指针 ＋ 2)
                    局_蓝和 ＝ 局_蓝和 ＋ 局_蓝 × 局_权重
                    局_绿和 ＝ 局_绿和 ＋ 局_绿 × 局_权重
                    局_红和 ＝ 局_红和 ＋ 局_红 × 局_权重
                    局_源指针 ＝ 局_源指针 ＋ 线程_宽 × 4
                .变量循环尾 ()
                局_阿尔法 ＝ 指针到字节 (局_源行首 ＋ 局_列 × 4 ＋ 3)
                写内存字节 (局_目标行首 ＋ 局_列 × 4, 右移 (局_蓝和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 1, 右移 (局_绿和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 2, 右移 (局_红和, 局_右移位))
                写内存字节 (局_目标行首 ＋ 局_列 × 4 ＋ 3, 局_阿尔法)
            .变量循环尾 ()
        .如果结束

    .如果结束

.变量循环尾 ()

[/md][/md]

hehz977

祝大家新年快乐.感谢分享

简qt

opphk 发表于 2026-2-16 21:01
新年了还在卷

新年快乐
我没用任何眷恋等，无所谓。

opphk

新年了还在卷