基于System.Drawing优化法线贴图生成效率的技术咨询

Sobel算法生成法线贴图的性能瓶颈通常来自频繁的GetPixel/SetPixel调用，而Bitmap LockBits通过直接操作位图内存块的方式，避免了GDI+的用户态/内核态切换开销，能大幅提升运算效率。Color Matrix仅适用于单像素的颜色变换，无法处理Sobel所需的邻域像素卷积计算，因此不适合用于该场景。

下面给出完整的C#实现代码，包含内存锁定、梯度计算、法线转换的核心逻辑：

using System.Drawing;
using System.Drawing.Imaging;

public static Bitmap GenerateNormalMap(Bitmap diffuseMap, float intensity = 1.0f)
{
    // 创建与原图尺寸一致的法线贴图
    Bitmap normalMap = new Bitmap(diffuseMap.Width, diffuseMap.Height, PixelFormat.Format24bppRgb);

    // 锁定原漫反射图和目标法线图的内存
    BitmapData diffuseData = diffuseMap.LockBits(
        new Rectangle(0, 0, diffuseMap.Width, diffuseMap.Height),
        ImageLockMode.ReadOnly,
        diffuseMap.PixelFormat);
    BitmapData normalData = normalMap.LockBits(
        new Rectangle(0, 0, normalMap.Width, normalMap.Height),
        ImageLockMode.WriteOnly,
        normalMap.PixelFormat);

    try
    {
        int bytesPerPixel = Image.GetPixelFormatSize(diffuseData.PixelFormat) / 8;
        int stride = diffuseData.Stride;
        IntPtr diffusePtr = diffuseData.Scan0;
        IntPtr normalPtr = normalData.Scan0;

        // 分配托管数组，减少非托管内存直接访问次数
        byte[] diffuseBuffer = new byte[stride * diffuseData.Height];
        byte[] normalBuffer = new byte[stride * normalData.Height];
        System.Runtime.InteropServices.Marshal.Copy(diffusePtr, diffuseBuffer, 0, diffuseBuffer.Length);

        // Sobel算子内核
        int[] gx = new int[] { -1, 0, 1, -2, 0, 2, -1, 0, 1 };
        int[] gy = new int[] { 1, 2, 1, 0, 0, 0, -1, -2, -1 };

        for (int y = 1; y < diffuseData.Height - 1; y++)
        {
            for (int x = 1; x < diffuseData.Width - 1; x++)
            {
                // 计算当前像素及邻域的灰度值与梯度
                int graySumGx = 0;
                int graySumGy = 0;

                for (int ky = -1; ky <= 1; ky++)
                {
                    for (int kx = -1; kx <= 1; kx++)
                    {
                        int offset = (y + ky) * stride + (x + kx) * bytesPerPixel;
                        // 采用ITU-R BT.601标准计算灰度值，更符合视觉特性
                        byte gray = (byte)(0.299 * diffuseBuffer[offset] + 0.587 * diffuseBuffer[offset + 1] + 0.114 * diffuseBuffer[offset + 2]);
                        int kernelIndex = (ky + 1) * 3 + (kx + 1);
                        graySumGx += gray * gx[kernelIndex];
                        graySumGy += gray * gy[kernelIndex];
                    }
                }

                // 应用强度参数并转换为法线分量范围[-1,1]
                float gxVal = graySumGx * intensity / 255.0f;
                float gyVal = graySumGy * intensity / 255.0f;

                // 将法线分量转换为RGB通道值（范围从[-1,1]映射到[0,255]）
                byte r = (byte)((gxVal + 1) * 127.5f);
                byte g = (byte)((-gyVal + 1) * 127.5f);
                byte b = (byte)(Math.Sqrt(1 - Math.Clamp(gxVal * gxVal + gyVal * gyVal, 0, 1)) * 255);

                // 写入法线缓冲区
                int normalOffset = y * stride + x * bytesPerPixel;
                normalBuffer[normalOffset] = r;
                normalBuffer[normalOffset + 1] = g;
                normalBuffer[normalOffset + 2] = b;
            }
        }

        // 处理边界像素，直接设为默认法线（z轴向上，对应RGB(128,128,255)）
        byte defaultR = 128;
        byte defaultG = 128;
        byte defaultB = 255;
        // 顶部和底部行
        for (int x = 0; x < diffuseData.Width; x++)
        {
            int topOffset = 0 * stride + x * bytesPerPixel;
            normalBuffer[topOffset] = defaultR;
            normalBuffer[topOffset + 1] = defaultG;
            normalBuffer[topOffset + 2] = defaultB;

            int bottomOffset = (diffuseData.Height - 1) * stride + x * bytesPerPixel;
            normalBuffer[bottomOffset] = defaultR;
            normalBuffer[bottomOffset + 1] = defaultG;
            normalBuffer[bottomOffset + 2] = defaultB;
        }
        // 左侧和右侧列（排除已处理的顶部、底部）
        for (int y = 1; y < diffuseData.Height - 1; y++)
        {
            int leftOffset = y * stride + 0 * bytesPerPixel;
            normalBuffer[leftOffset] = defaultR;
            normalBuffer[leftOffset + 1] = defaultG;
            normalBuffer[leftOffset + 2] = defaultB;

            int rightOffset = y * stride + (diffuseData.Width - 1) * bytesPerPixel;
            normalBuffer[rightOffset] = defaultR;
            normalBuffer[rightOffset + 1] = defaultG;
            normalBuffer[rightOffset + 2] = defaultB;
        }

        // 将缓冲区数据复制回非托管内存
        System.Runtime.InteropServices.Marshal.Copy(normalBuffer, 0, normalPtr, normalBuffer.Length);
    }
    finally
    {
        // 必须解锁内存，避免位图损坏
        diffuseMap.UnlockBits(diffuseData);
        normalMap.UnlockBits(normalData);
    }

    return normalMap;
}

关键优化说明 #

• 内存操作优化：一次性将位图数据复制到托管数组，减少非托管内存的直接访问开销，兼顾性能与安全性。
• 灰度计算标准：使用ITU-R BT.601权重计算灰度，生成的法线细节更贴合人眼感知的纹理变化。
• 边界处理：边缘像素因无法获取完整邻域，直接设置为默认法线，避免异常梯度值影响整体效果。
• 可调节强度：通过intensity参数控制法线的凹凸程度，方便用户根据需求调整效果。

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