如何在C++中格式化像素数据适配PySide2的QImage.fromData()

针对你遇到的性能瓶颈，以下两种方案可以直接在C++端完成像素格式处理，让Python端仅需简单调用即可生成QPixmap，彻底规避多次转换的开销：

方案1：编码为标准图像格式（PNG/JPEG）字节流 #

QImage.fromData()原生支持解析PNG、JPEG等标准编码格式的字节数据，兼容性强，Python端无需额外指定格式参数。

C++端实现 #

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <QImage>
#include <QByteArray>
#include <QBuffer>
#include <OpenImageIO/imageio.h>

namespace py = pybind11;
namespace oiio = OIIO;

struct EncodedImage {
    bool valid;
    std::vector<uint8_t> bytes;
};

EncodedImage load_exr_encode_png(const std::string& path) {
    EncodedImage result{};
    auto infile = oiio::ImageInput::open(path);
    if (!infile) {
        result.valid = false;
        return result;
    }

    const oiio::ImageSpec& spec = infile->spec();
    int w = spec.width, h = spec.height, ch = spec.nchannels;
    std::vector<float> pixels(w * h * ch);
    infile->read_image(oiio::TypeDesc::FLOAT, pixels.data());
    infile->close();

    // 转换为Qt支持的RGBA8888格式（浮点转8位整数，适配多数UI场景）
    QImage img(w, h, QImage::Format_RGBA8888);
    uchar* img_buf = img.bits();
    int stride = img.bytesPerLine();

    for (int y = 0; y < h; ++y) {
        uchar* row = img_buf + y * stride;
        for (int x = 0; x < w; ++x) {
            int idx = (y * w + x) * ch;
            float r = std::clamp(pixels[idx], 0.0f, 1.0f) * 255;
            float g = std::clamp(pixels[idx+1], 0.0f, 1.0f) * 255;
            float b = std::clamp(pixels[idx+2], 0.0f, 1.0f) * 255;
            float a = ch >=4 ? std::clamp(pixels[idx+3], 0.0f, 1.0f)*255 : 255;

            int pixel_idx = x * 4;
            row[pixel_idx] = static_cast<uchar>(r);
            row[pixel_idx+1] = static_cast<uchar>(g);
            row[pixel_idx+2] = static_cast<uchar>(b);
            row[pixel_idx+3] = static_cast<uchar>(a);
        }
    }

    // 将QImage编码为PNG字节数组
    QByteArray byte_arr;
    QBuffer buffer(&byte_arr);
    buffer.open(QIODevice::WriteOnly);
    img.save(&buffer, "PNG"); // 若追求更小体积可换JPEG，但PNG无损适配EXR特性

    result.valid = true;
    result.bytes = std::vector<uint8_t>(byte_arr.begin(), byte_arr.end());
    return result;
}

PYBIND11_MODULE(exr_loader, m) {
    py::class_<EncodedImage>(m, "EncodedImage")
        .def_readonly("valid", &EncodedImage::valid)
        .def_readonly("bytes", &EncodedImage::bytes);

    m.def("load_exr_encode_png", &load_exr_encode_png, "Load EXR and encode to PNG bytes");
}

Python端调用 #

from PySide2.QtGui import QImage, QPixmap
import exr_loader

img_data = exr_loader.load_exr_encode_png("large_exr_file.exr")
if img_data.valid:
    q_byte_arr = QByteArray(img_data.bytes)
    q_img = QImage.fromData(q_byte_arr)
    pixmap = QPixmap.fromImage(q_img)
    # 直接用于UI控件显示

方案2：直接生成原始像素字节流（无编码开销） #

如果想避免图像编码的性能损耗，可以直接在C++端按QImage要求的格式打包原始像素字节，Python端调用时明确指定格式参数。

C++端实现 #

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <OpenImageIO/imageio.h>

namespace py = pybind11;
namespace oiio = OIIO;

struct RawImage {
    bool valid;
    int width;
    int height;
    std::vector<uint8_t> rgba_bytes;
};

RawImage load_exr_raw_rgba(const std::string& path) {
    RawImage result{};
    auto infile = oiio::ImageInput::open(path);
    if (!infile) {
        result.valid = false;
        return result;
    }

    const oiio::ImageSpec& spec = infile->spec();
    result.width = spec.width;
    result.height = spec.height;
    int ch = spec.nchannels;
    std::vector<float> pixels(result.width * result.height * ch);
    infile->read_image(oiio::TypeDesc::FLOAT, pixels.data());
    infile->close();

    // 直接生成RGBA8888格式的原始字节流
    result.rgba_bytes.resize(result.width * result.height * 4);
    uchar* dest = result.rgba_bytes.data();

    for (int y = 0; y < result.height; ++y) {
        for (int x = 0; x < result.width; ++x) {
            int idx = (y * result.width + x) * ch;
            float r = std::clamp(pixels[idx], 0.0f, 1.0f) * 255;
            float g = std::clamp(pixels[idx+1], 0.0f, 1.0f) * 255;
            float b = std::clamp(pixels[idx+2], 0.0f, 1.0f) * 255;
            float a = ch >=4 ? std::clamp(pixels[idx+3], 0.0f, 1.0f)*255 : 255;

            int dest_idx = (y * result.width + x) * 4;
            dest[dest_idx] = static_cast<uchar>(r);
            dest[dest_idx+1] = static_cast<uchar>(g);
            dest[dest_idx+2] = static_cast<uchar>(b);
            dest[dest_idx+3] = static_cast<uchar>(a);
        }
    }

    result.valid = true;
    return result;
}

PYBIND11_MODULE(exr_loader, m) {
    py::class_<RawImage>(m, "RawImage")
        .def_readonly("valid", &RawImage::valid)
        .def_readonly("width", &RawImage::width)
        .def_readonly("height", &RawImage::height)
        .def_readonly("rgba_bytes", &RawImage::rgba_bytes);

    m.def("load_exr_raw_rgba", &load_exr_raw_rgba, "Load EXR output raw RGBA8888 bytes");
}

Python端调用 #

from PySide2.QtGui import QImage, QPixmap
import exr_loader

img_data = exr_loader.load_exr_raw_rgba("large_exr_file.exr")
if img_data.valid:
    q_byte_arr = QByteArray(img_data.rgba_bytes)
    # 关键：指定宽高、字节行间距、像素格式
    q_img = QImage(q_byte_arr, img_data.width, img_data.height, 
                   img_data.width*4, QImage.Format_RGBA8888)
    pixmap = QPixmap.fromImage(q_img)

额外优化提示 #

• 若需保留EXR的浮点精度，可改用QImage::Format_RGBA32F格式，C++端直接传递float数组的字节即可，Python端对应指定格式。
• 缓存大尺寸图片时，建议在C++端做好内存管理，避免重复加载；Python端可复用QPixmap对象，减少重复转换。

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