Windows C++下将指定透明色的BMP转换为PNG的实现方案问询

我来给你几个具体可落地的方案，完全适配你的需求——不管是基于你现有的MFC/CImage代码，还是贴合你向Direct2D迁移的方向：

方案一：基于CImage手动添加Alpha通道（改动最小，无需额外库） #

你已经在使用CImage，那我们可以直接在这个基础上扩展，手动给图像添加Alpha通道，把指定颜色设为透明。这个方案只用到CImage和Windows原生API，逻辑清晰，改动量小：

#include <atlimage.h> // 确保包含CImage的头文件

BOOL ConvertBmpToPngWithTransparent(LPCTSTR bmpFilename, LPCTSTR pngFilename, COLORREF crTransparent)
{
    // 1. 加载源BMP文件
    CImage bmpImage;
    if (bmpImage.Load(bmpFilename) != S_OK)
    {
        // 处理加载失败，比如弹出提示或返回错误
        return FALSE;
    }

    int imgWidth = bmpImage.GetWidth();
    int imgHeight = bmpImage.GetHeight();
    int srcBpp = bmpImage.GetBPP(); // 源图像位深，比如24位BMP就是24

    // 2. 创建带Alpha通道的32位ARGB目标图像
    CImage pngImage;
    // createAlphaChannel参数确保图像有Alpha通道
    if (!pngImage.Create(imgWidth, imgHeight, 32, CImage::createAlphaChannel))
    {
        return FALSE;
    }

    // 3. 遍历每个像素，设置Alpha值
    for (int y = 0; y < imgHeight; ++y)
    {
        // 获取当前行的像素指针
        BYTE* pSrcRow = reinterpret_cast<BYTE*>(bmpImage.GetPixelAddress(0, y));
        BYTE* pDstRow = reinterpret_cast<BYTE*>(pngImage.GetPixelAddress(0, y));

        for (int x = 0; x < imgWidth; ++x)
        {
            COLORREF srcColor;
            // 根据源图像位深读取颜色
            if (srcBpp == 24)
            {
                // 24位BMP的像素顺序是BGR
                BYTE b = pSrcRow[0];
                BYTE g = pSrcRow[1];
                BYTE r = pSrcRow[2];
                srcColor = RGB(r, g, b);
                pSrcRow += 3; // 移动到下一个像素
            }
            else if (srcBpp == 32)
            {
                // 32位BMP可能自带Alpha，但我们忽略它，只取RGB
                BYTE b = pSrcRow[0];
                BYTE g = pSrcRow[1];
                BYTE r = pSrcRow[2];
                srcColor = RGB(r, g, b);
                pSrcRow += 4;
            }
            else
            {
                // 处理其他位深（比如8位索引色），这里简化处理，直接用GetPixel
                srcColor = bmpImage.GetPixel(x, y);
            }

            // 设置目标像素的ARGB（32位顺序是BGRA）
            if (srcColor == crTransparent)
            {
                // 完全透明：Alpha设为0
                pDstRow[0] = GetBValue(srcColor); // B
                pDstRow[1] = GetGValue(srcColor); // G
                pDstRow[2] = GetRValue(srcColor); // R
                pDstRow[3] = 0;                   // Alpha
            }
            else
            {
                // 完全不透明：Alpha设为255
                pDstRow[0] = GetBValue(srcColor);
                pDstRow[1] = GetGValue(srcColor);
                pDstRow[2] = GetRValue(srcColor);
                pDstRow[3] = 255;
            }
            pDstRow += 4; // 32位像素每个占4字节
        }
    }

    // 4. 保存为PNG（这里用到CImage内置的GDI+支持，和你原来的代码一致）
    HRESULT hr = pngImage.Save(pngFilename, Gdiplus::ImageFormatPNG);
    return SUCCEEDED(hr);
}

方案说明： #

• 完全基于你现有的CImage代码，学习成本极低
• 手动处理每个像素的Alpha通道，精准控制透明色
• 保存时依赖CImage的GDI+支持，但和你原来的代码逻辑一致，属于你已经在使用的范围
• 支持24位/32位BMP，8位索引色BMP也能通过GetPixel兼容（效率稍低，但你说性能不是问题）

方案二：Direct2D + WIC方案（适配你的技术迁移方向） #

既然你正在从GDI迁移到Direct2D，这个方案刚好能让你熟悉D2D的基础用法，而且完全不依赖GDI+，只用Windows原生的WIC（Windows Imaging Component）和Direct2D API：

首先需要添加必要的头文件和链接库：

#include <d2d1.h>
#include <wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "windowscodecs.lib")

然后是核心转换函数：

HRESULT ConvertBmpToPngWithTransparent_D2D(LPCTSTR bmpFilename, LPCTSTR pngFilename, COLORREF crTransparent)
{
    HRESULT hr = S_OK;

    // 初始化WIC和Direct2D工厂
    IWICImagingFactory* pWicFactory = nullptr;
    ID2D1Factory* pD2dFactory = nullptr;

    hr = CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pWicFactory));
    if (FAILED(hr)) goto Cleanup;

    hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pD2dFactory);
    if (FAILED(hr)) goto Cleanup;

    // 加载BMP文件
    IWICBitmapDecoder* pDecoder = nullptr;
    hr = pWicFactory->CreateDecoderFromFilename(
        bmpFilename,
        nullptr,
        GENERIC_READ,
        WICDecodeMetadataCacheOnLoad,
        &pDecoder
    );
    if (FAILED(hr)) goto Cleanup;

    IWICBitmapFrameDecode* pSrcFrame = nullptr;
    hr = pDecoder->GetFrame(0, &pSrcFrame);
    if (FAILED(hr)) goto Cleanup;

    // 获取图像尺寸
    UINT imgWidth, imgHeight;
    hr = pSrcFrame->GetSize(&imgWidth, &imgHeight);
    if (FAILED(hr)) goto Cleanup;

    // 创建带Alpha通道的目标WIC位图（格式为PBGRA，Direct2D偏好的格式）
    IWICBitmap* pTargetBitmap = nullptr;
    hr = pWicFactory->CreateBitmap(
        imgWidth,
        imgHeight,
        GUID_WICPixelFormat32bppPBGRA,
        WICBitmapCacheOnDemand,
        &pTargetBitmap
    );
    if (FAILED(hr)) goto Cleanup;

    // 创建Direct2D渲染目标，绑定到目标WIC位图
    ID2D1RenderTarget* pRenderTarget = nullptr;
    D2D1_RENDER_TARGET_PROPERTIES rtProps = D2D1::RenderTargetProperties(
        D2D1_RENDER_TARGET_TYPE_DEFAULT,
        D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED)
    );
    hr = pD2dFactory->CreateWicBitmapRenderTarget(
        pTargetBitmap,
        rtProps,
        &pRenderTarget
    );
    if (FAILED(hr)) goto Cleanup;

    // 将源BMP转换为Direct2D位图
    ID2D1Bitmap* pD2dBmp = nullptr;
    hr = pRenderTarget->CreateBitmapFromWicBitmap(pSrcFrame, nullptr, &pD2dBmp);
    if (FAILED(hr)) goto Cleanup;

    // 创建颜色键效果：自动将指定颜色转换为透明
    ID2D1Effect* pColorKeyEffect = nullptr;
    hr = pRenderTarget->CreateEffect(CLSID_D2D1ColorKey, &pColorKeyEffect);
    if (FAILED(hr)) goto Cleanup;

    pColorKeyEffect->SetInput(0, pD2dBmp);
    // 将RGB颜色转换为Direct2D使用的0-1浮点数范围
    D2D1_VECTOR_3F transparentVec = D2D1::Vector3F(
        static_cast<float>(GetRValue(crTransparent)) / 255.0f,
        static_cast<float>(GetGValue(crTransparent)) / 255.0f,
        static_cast<float>(GetBValue(crTransparent)) / 255.0f
    );
    pColorKeyEffect->SetValue(D2D1_COLORKEY_PROP_COLOR, transparentVec);
    // 设置颜色容差，避免细微颜色偏差导致透明不彻底（可根据需求调整）
    pColorKeyEffect->SetValue(D2D1_COLORKEY_PROP_TOLERANCE, 0.01f);

    // 开始绘制
    pRenderTarget->BeginDraw();
    pRenderTarget->Clear(); // 清空背景

    // 绘制带透明效果的图像到目标
    D2D1_RECT_F drawRect = D2D1::RectF(0.0f, 0.0f, static_cast<float>(imgWidth), static_cast<float>(imgHeight));
    pRenderTarget->DrawImage(pColorKeyEffect, nullptr, &drawRect);

    hr = pRenderTarget->EndDraw();
    if (FAILED(hr)) goto Cleanup;

    // 将目标WIC位图保存为PNG文件
    IWICBitmapEncoder* pPngEncoder = nullptr;
    hr = pWicFactory->CreateEncoder(GUID_ContainerFormatPng, nullptr, &pPngEncoder);
    if (FAILED(hr)) goto Cleanup;

    IWICStream* pStream = nullptr;
    hr = pWicFactory->CreateStream(&pStream);
    if (FAILED(hr)) goto Cleanup;

    hr = pStream->InitializeFromFilename(pngFilename, GENERIC_WRITE);
    if (FAILED(hr)) goto Cleanup;

    hr = pPngEncoder->Initialize(pStream, WICBitmapEncoderNoCache);
    if (FAILED(hr)) goto Cleanup;

    IWICBitmapFrameEncode* pEncodeFrame = nullptr;
    hr = pPngEncoder->CreateNewFrame(&pEncodeFrame, nullptr);
    if (FAILED(hr)) goto Cleanup;

    hr = pEncodeFrame->Initialize(nullptr);
    if (FAILED(hr)) goto Cleanup;

    hr = pEncodeFrame->SetSize(imgWidth, imgHeight);
    if (FAILED(hr)) goto Cleanup;

    WICPixelFormatGUID pixelFormat = GUID_WICPixelFormat32bppPBGRA;
    hr = pEncodeFrame->SetPixelFormat(&pixelFormat);
    if (FAILED(hr)) goto Cleanup;

    hr = pEncodeFrame->WriteSource(pTargetBitmap, nullptr);
    if (FAILED(hr)) goto Cleanup;

    hr = pEncodeFrame->Commit();
    if (FAILED(hr)) goto Cleanup;

    hr = pPngEncoder->Commit();
    if (FAILED(hr)) goto Cleanup;

Cleanup:
    // 释放所有COM对象（必须按创建顺序逆序释放）
    if (pEncodeFrame) pEncodeFrame->Release();
    if (pPngEncoder) pPngEncoder->Release();
    if (pStream) pStream->Release();
    if (pColorKeyEffect) pColorKeyEffect->Release();
    if (pD2dBmp) pD2dBmp->Release();
    if (pRenderTarget) pRenderTarget->Release();
    if (pTargetBitmap) pTargetBitmap->Release();
    if (pSrcFrame) pSrcFrame->Release();
    if (pDecoder) pDecoder->Release();
    if (pD2dFactory) pD2dFactory->Release();
    if (pWicFactory) pWicFactory->Release();

    return hr;
}

方案说明： #

• 完全基于Windows原生的Direct2D和WIC，无需任何外部库或GDI+
• 用D2D的颜色键效果处理透明，比手动遍历像素更高效（虽然你说性能不是问题），还能处理颜色容差
• 刚好贴合你向Direct2D迁移的技术路线，能帮你快速熟悉D2D的基础流程
• 需要注意COM对象的创建和释放，必须严格遵循COM规则

方案三：先存PNG再修改（退而求其次的备选） #

如果你实在想先按原来的代码生成PNG，再事后修改透明色，这个方案本质和方案一类似，只是多了一次文件IO：

BOOL PostProcessPngAddTransparent(LPCTSTR pngFilename, COLORREF crTransparent)
{
    CImage pngImage;
    if (pngImage.Load(pngFilename) != S_OK)
    {
        return FALSE;
    }

    // 确保图像有Alpha通道，如果没有就创建
    if (pngImage.GetBPP() != 32 || !pngImage.HasAlphaChannel())
    {
        CImage tempImage;
        tempImage.Create(pngImage.GetWidth(), pngImage.GetHeight(), 32, CImage::createAlphaChannel);
        // 把原图像拷贝到带Alpha的图像
        pngImage.BitBlt(tempImage.GetDC(), 0, 0);
        pngImage.Destroy();
        pngImage.Attach(tempImage.Detach());
    }

    // 遍历像素设置透明，逻辑和方案一完全一致
    int imgWidth = pngImage.GetWidth();
    int imgHeight = pngImage.GetHeight();
    for (int y = 0; y < imgHeight; ++y)
    {
        BYTE* pRow = reinterpret_cast<BYTE*>(pngImage.GetPixelAddress(0, y));
        for (int x = 0; x < imgWidth; ++x)
        {
            COLORREF pixelColor = RGB(pRow[2], pRow[1], pRow[0]); // PNG是BGRA顺序
            if (pixelColor == crTransparent)
            {
                pRow[3] = 0; // 设置Alpha为0
            }
            else
            {
                pRow[3] = 255; // 保持不透明
            }
            pRow += 4;
        }
    }

    return SUCCEEDED(pngImage.Save(pngFilename, Gdiplus::ImageFormatPNG));
}

方案说明： #

• 完全基于你原来的代码流程，先生成PNG再处理
• 多了一次文件读写，效率略低，但逻辑简单
• 适合你临时测试或者有特殊场景需要分两步处理的情况

选择建议： #

1. 如果你想快速实现，改动最小：选方案一，直接在你现有代码基础上扩展，几乎不用学习新东西
2. 如果你想贴合技术迁移方向，学习Direct2D：选方案二，虽然代码稍长，但都是D2D的基础用法，对后续迁移有帮助
3. 如果你必须分两步处理：选方案三，但不推荐作为首选

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