我来帮你拆解这个问题的核心，并给出更规范的实现思路：

一、伪影的根本原因 #

你的问题本质上是卷积核归一化错误加上8位整数运算的截断误差共同导致的：

1. 核总和偏差：你最初使用的5x5高斯核，整数形式的总和是256（计算一下：1+4+6+4+1=16，4+16+24+16+4=64，6+24+36+24+6=96，总和16+64+96+64+16=256）。但你却用255作为分母，导致整个核的总和是256/255 ≈ 1.0039——这意味着每个像素的颜色值会被轻微放大。当这种放大经过多次累积（尤其是边缘或颜色过渡区域），就会让8位通道（0-255）的数值被频繁截断到255，进而出现偏色伪影（你提到的蓝调伪影可能是蓝色通道在计算中累积偏差更明显）。

2. 中间整数截断：你的pxPlus和pxMultNum函数在每一步运算后都直接截断到8位整数，这会丢失大量浮点精度。比如一个像素值乘以0.0039（1/255）后取整，可能直接变成0，多次累积后误差会被放大，进一步加剧伪影。

你后来把中心元素改成35，让核总和变成255，除以255后总和正好为1，这确实能解决归一化问题，但这是修改了标准高斯核的权重，属于临时 workaround，不是最优解。

二、更规范的解决方式 #

1. 严格保证卷积核归一化到总和为1 #

标准的5x5高斯核整数总和是256，所以正确的做法是用256作为分母，这样核的浮点总和正好是1，从根源上避免过度放大像素值：

gblurMatrix :: [[Double]]
gblurMatrix = [[1/256, 4/256, 6/256, 4/256, 1/256],
               [4/256, 16/256, 24/256, 16/256, 4/256],
               [6/256, 24/256, 36/256, 24/256, 6/256],
               [4/256, 16/256, 24/256, 16/256, 4/256],
               [1/256, 4/256, 6/256, 4/256, 1/256]]

2. 使用高精度中间运算，避免分步截断 #

不要在每一步乘法和加法后就截断到8位整数，应该先用Double或Float累积所有通道的总和，最后再进行一次归一化和取整。这样能最大程度减少精度损失：

blur :: Image PixelRGBA8 -> Image PixelRGBA8
blur img@Image {..} = generateImage blurrer imageWidth imageHeight
  where
    blurrer x y
      | x < offset || x >= imageWidth - offset || y < offset || y >= imageHeight - offset =
          -- 这里可以替换为更自然的边界处理，比如镜像边缘像素
          pixelAt img (clamp x 0 (imageWidth-1)) (clamp y 0 (imageHeight-1))
      | otherwise =
          let accumulate :: Int -> Int -> (Double, Double, Double) -> (Double, Double, Double)
              accumulate i j (rSum, gSum, bSum)
                | i >= matrixLength = (rSum, gSum, bSum)
                | j >= matrixLength = accumulate (i+1) 0 (rSum, gSum, bSum)
                | otherwise =
                    let px = pixelAt img (x + j - offset) (y + i - offset)
                        coeff = gblurMatrix !! i !! j
                        r = fromIntegral $ pixelRed px
                        g = fromIntegral $ pixelGreen px
                        b = fromIntegral $ pixelBlue px
                    in accumulate i (j+1) (rSum + r*coeff, gSum + g*coeff, bSum + b*coeff)
              (finalR, finalG, finalB) = accumulate 0 0 (0, 0, 0)
              clampPixel n = max 0 $ min 255 $ round n
          in PixelRGBA8 (clampPixel finalR) (clampPixel finalG) (clampPixel finalB) 255
    gblurMatrix = [[1/256,4/256,6/256,4/256,1/256],
                   [4/256,16/256,24/256,16/256,4/256],
                   [6/256,24/256,36/256,24/256,6/256],
                   [4/256,16/256,24/256,16/256,4/256],
                   [1/256,4/256,6/256,4/256,1/256]]
    matrixLength = length gblurMatrix
    offset = matrixLength `div` 2
    clamp val minVal maxVal = max minVal $ min maxVal val

3. 优化边界处理逻辑 #

你当前的边界直接返回白色，会导致图像边缘出现生硬的白色边框。更自然的做法是：

• 重复边缘像素：把超出边界的坐标 clamp 到图像边缘（如上面代码所示）
• 镜像边缘像素：对超出边界的坐标做镜像映射，比如x < offset时用offset - x作为横坐标
• 填充黑色/透明：根据需求填充固定颜色

4. 利用JuicyPixels的抽象简化代码 #

JuicyPixels提供了pixelMap、traverse等函数，可以让你更简洁地处理像素。比如可以用列表推导式来遍历卷积核的所有元素，替代手动递归：

-- 替代accumulate的简化写法
let kernelPixels = [ (pixelAt img (x + j - offset) (y + i - offset), gblurMatrix !! i !! j)
                   | i <- [0..matrixLength-1], j <- [0..matrixLength-1] ]
    (rSum, gSum, bSum) = foldl' (\(r,g,b) (px, coeff) ->
                                  let r' = fromIntegral (pixelRed px) * coeff
                                      g' = fromIntegral (pixelGreen px) * coeff
                                      b' = fromIntegral (pixelBlue px) * coeff
                                  in (r + r', g + g', b + b')) (0,0,0) kernelPixels

这样代码更易读，也减少了递归出错的可能。

内容的提问来源于stack exchange，提问作者Vadim