Tôi đã đọc qua tài liệu và ví dụ nhưng trong quá trình triển khai, tôi không thể hiểu đúng.

Sự cố: Sử dụng đoạn mã sau, tệp .png được viết sẽ chuyển đổi các vùng trong suốt thành màu trắng đồng nhất. Tôi đang cố gắng phủ màu .png kết quả lên trên một hình ảnh khác, nhưng do độ mờ, hình ảnh bên dưới không ảnh hưởng đến đầu ra.

Tôi đang thiếu gì? Tôi đã thử nhiều tùy chọn khác nhau nhưng không thể có được kết quả đầu ra đúng.

Mã C++ như sau:

chức năng() {
    int x, y, w, h;
    xt kép, yt, wt, ht;

    // lấy vị trí và kích thước hình ảnh
    trạng thái->biến đổi (0,0, 0,0, xt, yt);
    trạng thái->transformDelta(1.0, 1.0, wt, ht);

    nếu (wt > 0) {
        x = (int) trần(xt);
        w = (int) trần(wt);
    } khác {
        x = (int) ceil(xt + wt);
        w = (int) trần(-wt);
    }

    nếu (ht > 0) {
        y = (int) trần(yt);
        h = (int) trần(ht);
    } khác {
        y = (int) ceil(yt + ht);
        h = (int) trần(-ht);
    }

    GString* filePath = GString::format("{0:s}img-{1:d__{2:d}.", this->outputDir.c_str(),
            cái này->trangNum, cái này->imageNum);

    std::ofstream imgFile;

    Đảo ngược GBool = isColorMapInverted(colorMap);

    if (str->getKind() == strDCT && !invert) {
        // kết xuất tập tin JPEG

        filePath->append("jpg");
        // mở file ảnh
        imgFile.open(filePath->getCString(), std::ios::out | std::ios::trunc | std::ios::binary);

        //LOG4CPLUS_INFO(s_logger, "Ghi hình ảnh" << filePath->getCString());

        // khởi tạo luồng
        str = ((DCTStream*) str)->getRawStream();
        str->đặt lại();

        // sao chép luồng
        int c;

        while ((c = str->getChar()) != EOF) {
            imgFile << (Guchar) c;
        }
    } khác {
        TẬP TIN* f1;

        filePath->append("png");

        // mở file ảnh
        if (!(f1 = fopen(filePath->getCString(), "wb"))) {
            ném std::runtime_error("Không thể mở tệp để ghi PNG");
        }

        //LOG4CPLUS_INFO(s_logger, "Ghi hình ảnh" << filePath->getCString());

        // Khởi tạo nội dung PNG
        png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

        nếu (!png_ptr) {
            ném std::runtime_error("png_create_write_struct không thành công");
        }

        png_infop info_ptr = png_create_info_struct(png_ptr);

        nếu (!info_ptr) {
            ném std::runtime_error("png_create_info_struct không thành công");
        }

        nếu (setjmp(png_jmpbuf(png_ptr))) {
            ném std::runtime_error("Lỗi trong quá trình init_io");
        }

        //Viết tiêu đề PNG
        png_init_io(png_ptr, f1);

        nếu (setjmp(png_jmpbuf(png_ptr))) {
            ném std::runtime_error("Lỗi khi viết tiêu đề png");
        }

        // Thiết lập loại ảnh PNG và mức độ nén
        png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
// png_set_expand(png_ptr);
// /* Đặt màu nền để vẽ trong suốt và alpha
// hình ảnh trên */
// png_color_16 my_background;
// png_set_background(png_ptr, &my_background,PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
        png_set_invert_alpha(png_ptr);

        const png_byte bit_deep = Bản đồ màu 8: 1;
        const png_byte color_type = Bản đồ màu PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_GRAY;

        png_set_IHDR(png_ptr, info_ptr, chiều rộng, chiều cao, bit_deep, color_type, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

        // Ghi byte thông tin hình ảnh
        png_write_info(png_ptr, info_ptr);

        writeStreamToPng(png_ptr, str, chiều rộng, chiều cao, colorMap, MaskColors);

        // Viết đoạn cuối PNG
        nếu (setjmp(png_jmpbuf(png_ptr))) {
            ném std::runtime_error("Lỗi khi viết đoạn cuối png");
        }

        png_write_end(png_ptr, NULL);
        fclose(f1);
    }

    ++this->imageNum;
    str->close();
    imgFile.close();

    const int dirLength = this->outputDir.length();
    GString* const fileName = new GString(filePath, dirLength, filePath->getLength() - dirLength);
    const SimpleBoundingRectangle simpleBound(x, y, x + w, y + h);
    const BoundingPolygon* const giới hạn = new BoundingPolygon(
            getEffectiveBoundingPolygon(simpleBound));
    SVGImage* const img = new SVGImage(x, y, w, h, fileName, this->currentClipPathIndex, giới hạn);
    cái này->addNode(img);

    // Không xóa fileName - Hàm hủy của SVGImage sẽ làm điều đó
    xóa đường dẫn tệp;
}

static void writeStreamToPng(png_structp const png_ptr, Stream* const stream, const int width,
        const int chiều cao, GfxImageColorMap* const colorMap, int* MaskColors) {
    const int numBits = colorMap ? colorMap->getBits() : 1;
    const int numPixelComponents = colorMap ? colorMap->getNumPixelComps() : 1;
    // Nếu bản đồ màu được chỉ định, giả sử RGB, tức là 3 byte/pixel
    const int rowSize = colorMap ? (chiều rộng 3 *): ((chiều rộng + 7) / 8);
    png_byte* row = (png_byte*) malloc(rowSize);
    png_bytep* const row_pointer = &row;

    //Khởi tạo luồng hình ảnh
    ImageStream* const imgStream = new ImageStream(stream, width, numPixelComponents, numBits);
    imgStream->đặt lại();

    // Với mỗi dòng...
    for (int y = 0; y < chiều cao; y++) {
        // Chuyển đổi dữ liệu luồng của mỗi hàng thành hàng PNG
        nếu (bản đồ màu) {
            GfxRGB rgb;
            Guchar* p = imgStream->getLine();

            cho (int x = 0; x < chiều rộng; x++) {
                nếu (p) {
                    colorMap->getRGB(p, &rgb);
                    p += numPixelComponents;
                } khác {
                    /* Không còn dòng nào trong luồng - giả sử 0 như đã hoàn thành trong
                     Hình ảnh drawImage của ImageOutputDev */
                    rgb.r = rgb.g = rgb.b = 0;
                }

                // Ghi các pixel RGB vào hàng
                row[3 * x] = colToByte(rgb.r);
                row[3 * x + 1] = colToByte(rgb.g);
                row[3 * x + 2] = colToByte(rgb.b);
            }
        } khác {
            for (int i = 0; i < rowSize; ++i) {
                row[i] =stream->getChar() ^ *maskColors;
            }
        }

        nếu (setjmp(png_jmpbuf(png_ptr))) {
            xóa hàng;
            xóa imgStream;
            ném std::runtime_error("Lỗi khi ghi hàng png");
        }

        // Ghi dòng vào file
        png_write_rows(png_ptr, row_pointer, 1);
    }

    xóa hàng;
    xóa imgStream;
}

câu trả lời hay nhất

color_type = Bản đồ màu PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_GRAY

Đó là những loại màu PNG mờ.

Hãy thử PNG_COLOR_TYPE_RGBA :PNG_COLOR_TYPE_GRAY_ALPHA

Về việc viết PNG có nền trong suốt trong C++ libPng, chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/19945372/