【C++】OpenCVで画像を高品質に圧縮する方法と品質・サイズ最適化のポイント

#include <opencv2/opencv.hpp>
#include <vector>
#include <fstream>
#include <iostream>
int main() {
    // 画像の読み込み
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // JPEG圧縮のパラメータ設定(品質90)
    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
    // 画像をJPEG形式でメモリに圧縮
    std::vector<uchar> buffer;
    bool success = cv::imencode(".jpg", image, buffer, params);
    if (!success) {
        std::cerr << "画像のエンコードに失敗しました。" << std::endl;
        return -1;
    }
    // 圧縮データをファイルに保存
    std::ofstream ofs("output.jpg", std::ios::binary);
    ofs.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
    ofs.close();
    std::cout << "画像の圧縮と保存が完了しました。" << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.png");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_PNG_COMPRESSION, 3};
    std::vector<uchar> buffer;
    if (!cv::imencode(".png", image, buffer, params)) {
        std::cerr << "エンコードに失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "圧縮データサイズ: " << buffer.size() << " バイト" << std::endl;
    return 0;
}

圧縮データサイズ: 123456 バイト

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.png");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_PNG_COMPRESSION, 3};
    if (!cv::imwrite("output.png", image, params)) {
        std::cerr << "ファイル書き出しに失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "ファイルに保存しました。" << std::endl;
    return 0;
}

ファイルに保存しました。

std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 85}; // 品質85に設定
cv::imwrite("output.jpg", image, params);

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 75};
    if (!cv::imwrite("compressed_75.jpg", image, params)) {
        std::cerr << "JPEG保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "品質75でJPEG保存しました。" << std::endl;
    return 0;
}

品質75でJPEG保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat rgb = cv::imread("input.jpg");
    if (rgb.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat yuv;
    cv::cvtColor(rgb, yuv, cv::COLOR_BGR2YUV);
    std::cout << "YUV変換が完了しました。" << std::endl;
    return 0;
}

YUV変換が完了しました。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
int main() {
    cv::Mat image = cv::imread("input.png", cv::IMREAD_UNCHANGED);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_PNG_COMPRESSION, 5};
    if (!cv::imwrite("compressed.png", image, params)) {
        std::cerr << "PNG保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "圧縮レベル5でPNG保存しました。" << std::endl;
    return 0;
}

圧縮レベル5でPNG保存しました。

cv::Mat image = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
int main() {
    // 透過PNGをアルファチャンネル込みで読み込む
    cv::Mat image = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 圧縮レベルを4に設定して保存
    std::vector<int> params = {cv::IMWRITE_PNG_COMPRESSION, 4};
    if (!cv::imwrite("compressed_transparent.png", image, params)) {
        std::cerr << "PNG保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "透過PNGを圧縮レベル4で保存しました。" << std::endl;
    return 0;
}

透過PNGを圧縮レベル4で保存しました。

#include <iostream>
#include <opencv2/opencv.hpp>
#include <vector>

int main() {
    cv::Mat image = cv::imread("sample.png", cv::IMREAD_UNCHANGED);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }

    // ロッシー圧縮(品質80)
    std::vector<int> lossy_params = {cv::IMWRITE_WEBP_QUALITY, 80};
    if (!cv::imwrite("output_lossy.webp", image, lossy_params)) {
        std::cerr << "ロッシー圧縮の保存に失敗しました。" << std::endl;
        return -1;
    }

    // ロスレス圧縮（品質100はロスレスに近い）
    std::vector<int> lossless_params = {cv::IMWRITE_WEBP_QUALITY, 100};
    if (!cv::imwrite("output_lossless.webp", image, lossless_params)) {
        std::cerr << "ロスレス圧縮の保存に失敗しました。" << std::endl;
        return -1;
    }

    std::cout << "WebPのロッシーとロスレス圧縮を保存しました。" << std::endl;
    return 0;
}

WebPのロッシーとロスレス圧縮を保存しました。

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // アルファチャンネル付きロッシー圧縮(品質85)
    std::vector<int> params = {
        cv::IMWRITE_WEBP_QUALITY, 85
    };
    cv::imwrite("output_alpha_lossy.webp", image, params);
    std::cout << "アルファチャンネル付きWebPをロッシー圧縮で保存しました。" << std::endl;
    return 0;
}

アルファチャンネル付きWebPをロッシー圧縮で保存しました。

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
#include <chrono>
int main() {
    cv::Mat image = cv::imread("input.png", cv::IMREAD_UNCHANGED);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_WEBP_QUALITY, 50};
    cv::imwrite("compressed.webp", image, params);
    // 圧縮ファイルの読み込みとデコード速度計測
    auto start = std::chrono::high_resolution_clock::now();
    cv::Mat decoded = cv::imread("compressed.webp", cv::IMREAD_UNCHANGED);
    auto end = std::chrono::high_resolution_clock::now();
    if (decoded.empty()) {
        std::cerr << "WebP画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::chrono::duration<double, std::milli> duration = end - start;
    std::cout << "WebP画像のデコード時間: " << duration.count() << " ms" << std::endl;
    return 0;
}

WebP画像のデコード時間: 12.3456 ms

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
#include <fstream>
bool compressToTargetSize(const cv::Mat& image, const std::string& outputPath, size_t targetSize, int minQuality = 10, int maxQuality = 95) {
    int low = minQuality;
    int high = maxQuality;
    int bestQuality = minQuality;
    std::vector<uchar> buffer;
    while (low <= high) {
        int mid = (low + high) / 2;
        std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, mid};
        if (!cv::imencode(".jpg", image, buffer, params)) {
            std::cerr << "エンコードに失敗しました。" << std::endl;
            return false;
        }
        size_t compressedSize = buffer.size();
        if (compressedSize <= targetSize) {
            bestQuality = mid;
            low = mid + 1;  // もっと高画質を試す
        } else {
            high = mid - 1; // サイズオーバーなので画質を下げる
        }
    }
    // 最適品質でファイル保存
    std::vector<int> finalParams = {cv::IMWRITE_JPEG_QUALITY, bestQuality};
    if (!cv::imwrite(outputPath, image, finalParams)) {
        std::cerr << "ファイル保存に失敗しました。" << std::endl;
        return false;
    }
    std::cout << "目標サイズ " << targetSize << " バイトに対し、品質 " << bestQuality << " で圧縮しました。" << std::endl;
    return true;
}
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    size_t targetSize = 100 * 1024; // 100KB
    if (!compressToTargetSize(image, "output.jpg", targetSize)) {
        return -1;
    }
    return 0;
}

if (!compressToTargetSize(image, "output.jpg", targetSize)) {
    std::cout << "目標サイズに到達できませんでした。画像をリサイズして再試行します。" << std::endl;
    cv::Mat resized;
    cv::resize(image, resized, cv::Size(), 0.5, 0.5); // 50%に縮小
    if (!compressToTargetSize(resized, "output_resized.jpg", targetSize)) {
        std::cerr << "リサイズ後も目標サイズに到達できませんでした。" << std::endl;
        return -1;
    }
}

#include <opencv2/opencv.hpp>
#include <filesystem>
#include <vector>
#include <string>
#include <iostream>
namespace fs = std::filesystem;
std::vector<std::string> getImageFiles(const std::string& directory) {
    std::vector<std::string> imageFiles;
    for (const auto& entry : fs::directory_iterator(directory)) {
        if (!entry.is_regular_file()) continue;
        std::string ext = entry.path().extension().string();
        // 小文字に変換
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        if (ext == ".jpg" || ext == ".jpeg" || ext == ".png" || ext == ".bmp") {
            imageFiles.push_back(entry.path().string());
        }
    }
    return imageFiles;
}
int main() {
    std::string dirPath = "./images";
    auto files = getImageFiles(dirPath);
    std::cout << "対象画像ファイル一覧:" << std::endl;
    for (const auto& file : files) {
        std::cout << "  " << file << std::endl;
    }
    return 0;
}

対象画像ファイル一覧:
  ./images/photo1.jpg
  ./images/sample.png
  ./images/picture.bmp

#include <opencv2/opencv.hpp>
#include <filesystem>
#include <vector>
#include <string>
#include <iostream>
namespace fs = std::filesystem;
std::vector<std::string> getImageFiles(const std::string& directory) {
    std::vector<std::string> imageFiles;
    for (const auto& entry : fs::directory_iterator(directory)) {
        if (!entry.is_regular_file()) continue;
        std::string ext = entry.path().extension().string();
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        if (ext == ".jpg" || ext == ".jpeg" || ext == ".png") {
            imageFiles.push_back(entry.path().string());
        }
    }
    return imageFiles;
}
int main() {
    std::string dirPath = "./images";
    auto files = getImageFiles(dirPath);
    cv::parallel_for_(cv::Range(0, static_cast<int>(files.size())), [&](const cv::Range& range) {
        for (int i = range.start; i < range.end; ++i) {
            cv::Mat image = cv::imread(files[i]);
            if (image.empty()) {
                std::cerr << "画像の読み込みに失敗しました: " << files[i] << std::endl;
                continue;
            }
            std::string outputPath = "./compressed/" + fs::path(files[i]).filename().string();
            std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 85};
            if (!cv::imwrite(outputPath, image, params)) {
                std::cerr << "画像の保存に失敗しました: " << outputPath << std::endl;
            } else {
                std::cout << "圧縮保存しました: " << outputPath << std::endl;
            }
        }
    });
    return 0;
}

圧縮保存しました: ./compressed/photo1.jpg
圧縮保存しました: ./compressed/sample.png

#include <opencv2/opencv.hpp>
#include <vector>
#include <fstream>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
    std::vector<uchar> buffer;
    if (!cv::imencode(".jpg", image, buffer, params)) {
        std::cerr << "画像のエンコードに失敗しました。" << std::endl;
        return -1;
    }
    // バッファをファイルに書き出す
    std::ofstream ofs("compressed.jpg", std::ios::binary);
    ofs.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
    ofs.close();
    std::cout << "メモリ圧縮とファイル保存が完了しました。" << std::endl;
    return 0;
}

メモリ圧縮とファイル保存が完了しました。

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
#include <chrono>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
    // imencodeの計測
    auto startEncode = std::chrono::high_resolution_clock::now();
    std::vector<uchar> buffer;
    cv::imencode(".jpg", image, buffer, params);
    auto endEncode = std::chrono::high_resolution_clock::now();
    // imwriteの計測
    auto startWrite = std::chrono::high_resolution_clock::now();
    cv::imwrite("output_imwrite.jpg", image, params);
    auto endWrite = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> encodeTime = endEncode - startEncode;
    std::chrono::duration<double, std::milli> writeTime = endWrite - startWrite;
    std::cout << "imencode時間: " << encodeTime.count() << " ms" << std::endl;
    std::cout << "imwrite時間: " << writeTime.count() << " ms" << std::endl;
    return 0;
}

imencode時間: 15.2345 ms
imwrite時間: 20.5678 ms

#include <opencv2/opencv.hpp>
#include <vector>
#include <fstream>
#include <iostream>
int main() {
    try {
        cv::Mat image = cv::imread("input.jpg");
        if (image.empty()) {
            std::cerr << "画像の読み込みに失敗しました。" << std::endl;
            return -1;
        }
        std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
        std::vector<uchar> buffer;
        if (!cv::imencode(".jpg", image, buffer, params)) {
            std::cerr << "画像のエンコードに失敗しました。" << std::endl;
            return -1;
        }
        std::ofstream ofs("compressed.jpg", std::ios::binary);
        if (!ofs) {
            std::cerr << "ファイルのオープンに失敗しました。" << std::endl;
            return -1;
        }
        ofs.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
        if (!ofs) {
            std::cerr << "ファイル書き込みに失敗しました。" << std::endl;
            return -1;
        }
        std::cout << "画像の圧縮と保存が成功しました。" << std::endl;
    }
    catch (const cv::Exception& e) {
        std::cerr << "OpenCV例外が発生しました: " << e.what() << std::endl;
        return -1;
    }
    catch (const std::exception& e) {
        std::cerr << "標準例外が発生しました: " << e.what() << std::endl;
        return -1;
    }
    catch (...) {
        std::cerr << "不明な例外が発生しました。" << std::endl;
        return -1;
    }
    return 0;
}

画像の圧縮と保存が成功しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 元画像の半分のサイズに縮小
    cv::Mat resized;
    cv::resize(image, resized, cv::Size(), 0.5, 0.5, cv::INTER_AREA);
    cv::imwrite("resized.jpg", resized);
    std::cout << "画像をリサイズして保存しました。" << std::endl;
    return 0;
}

画像をリサイズして保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat noisy = cv::imread("noisy.jpg");
    if (noisy.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat denoised;
    cv::fastNlMeansDenoisingColored(noisy, denoised, 10, 10, 7, 21);
    cv::imwrite("denoised.jpg", denoised);
    std::cout << "ノイズ除去を行い画像を保存しました。" << std::endl;
    return 0;
}

ノイズ除去を行い画像を保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat converted;
    // BGRからsRGB(実質的にはBGRからRGB)に変換
    cv::cvtColor(image, converted, cv::COLOR_BGR2RGB);
    cv::imwrite("converted.jpg", converted);
    std::cout << "カラースペースを変換して保存しました。" << std::endl;
    return 0;
}

カラースペースを変換して保存しました。

std::vector<uchar> buffer;
for (const auto& imagePath : imagePaths) {
    cv::Mat image = cv::imread(imagePath);
    if (image.empty()) continue;
    buffer.clear();  // サイズは維持しつつ内容をクリア
    cv::imencode(".jpg", image, buffer, params);
    // bufferを使ってファイル保存や送信処理
}

buffer.reserve(500000); // 500KB程度を想定

#include <opencv2/opencv.hpp>
#include <opencv2/cudaimgproc.hpp>
#include <opencv2/cudaarithm.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // CPUからGPUへアップロード
    cv::cuda::GpuMat gpuImage;
    gpuImage.upload(image);
    // GPU上でリサイズ
    cv::cuda::GpuMat gpuResized;
    cv::cuda::resize(gpuImage, gpuResized, cv::Size(image.cols / 2, image.rows / 2), 0, 0, cv::INTER_AREA);
    // GPUからCPUへダウンロード
    cv::Mat resized;
    gpuResized.download(resized);
    cv::imwrite("resized_gpu.jpg", resized);
    std::cout << "GPUでリサイズして保存しました。" << std::endl;
    return 0;
}

GPUでリサイズして保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::UMat image;
    cv::imread("input.jpg").copyTo(image);
    cv::UMat resized;
    cv::resize(image, resized, cv::Size(image.cols / 2, image.rows / 2), 0, 0, cv::INTER_AREA);
    cv::imwrite("resized_umat.jpg", resized);
    std::cout << "OpenCLバックエンドでリサイズして保存しました。" << std::endl;
    return 0;
}

OpenCLバックエンドでリサイズして保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <cmath>
double calculatePSNR(const cv::Mat& original, const cv::Mat& compressed) {
    cv::Mat s1;
    cv::absdiff(original, compressed, s1);       // 差分の絶対値
    s1.convertTo(s1, CV_32F);                     // float型に変換
    s1 = s1.mul(s1);                              // 二乗
    cv::Scalar s = cv::sum(s1);                   // 全画素の和
    double sse = s.val[0] + s.val[1] + s.val[2]; // RGB3チャンネルの合計
    if (sse <= 1e-10) {                           // 差がほぼゼロの場合
        return 100;                               // 非常に高いPSNRを返す
    } else {
        double mse = sse / (double)(original.channels() * original.total());
        double psnr = 10.0 * std::log10((255 * 255) / mse);
        return psnr;
    }
}
int main() {
    cv::Mat original = cv::imread("original.jpg");
    cv::Mat compressed = cv::imread("compressed.jpg");
    if (original.empty() || compressed.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    double psnr = calculatePSNR(original, compressed);
    std::cout << "PSNR: " << psnr << " dB" << std::endl;
    return 0;
}

PSNR: 35.6789 dB

#include <opencv2/opencv.hpp>
#include <iostream>
cv::Scalar calculateSSIM(const cv::Mat& img1, const cv::Mat& img2) {
    const double C1 = 6.5025, C2 = 58.5225;
    cv::Mat I1, I2;
    img1.convertTo(I1, CV_32F);
    img2.convertTo(I2, CV_32F);
    cv::Mat I1_2 = I1.mul(I1);        // I1^2
    cv::Mat I2_2 = I2.mul(I2);        // I2^2
    cv::Mat I1_I2 = I1.mul(I2);       // I1 * I2
    cv::Mat mu1, mu2;
    cv::GaussianBlur(I1, mu1, cv::Size(11, 11), 1.5);
    cv::GaussianBlur(I2, mu2, cv::Size(11, 11), 1.5);
    cv::Mat mu1_2 = mu1.mul(mu1);
    cv::Mat mu2_2 = mu2.mul(mu2);
    cv::Mat mu1_mu2 = mu1.mul(mu2);
    cv::Mat sigma1_2, sigma2_2, sigma12;
    cv::GaussianBlur(I1_2, sigma1_2, cv::Size(11, 11), 1.5);
    sigma1_2 -= mu1_2;
    cv::GaussianBlur(I2_2, sigma2_2, cv::Size(11, 11), 1.5);
    sigma2_2 -= mu2_2;
    cv::GaussianBlur(I1_I2, sigma12, cv::Size(11, 11), 1.5);
    sigma12 -= mu1_mu2;
    cv::Mat t1, t2, t3;
    t1 = 2 * mu1_mu2 + C1;
    t2 = 2 * sigma12 + C2;
    t3 = t1.mul(t2);                 // 分子
    t1 = mu1_2 + mu2_2 + C1;
    t2 = sigma1_2 + sigma2_2 + C2;
    t1 = t1.mul(t2);                // 分母
    cv::Mat ssim_map;
    cv::divide(t3, t1, ssim_map);
    cv::Scalar mssim = cv::mean(ssim_map);
    return mssim;
}
int main() {
    cv::Mat original = cv::imread("original.jpg");
    cv::Mat compressed = cv::imread("compressed.jpg");
    if (original.empty() || compressed.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Scalar ssim = calculateSSIM(original, compressed);
    std::cout << "SSIM (B, G, R): " << ssim[0] << ", " << ssim[1] << ", " << ssim[2] << std::endl;
    std::cout << "平均 SSIM: " << (ssim[0] + ssim[1] + ssim[2]) / 3 << std::endl;
    return 0;
}

SSIM (B, G, R): 0.92, 0.93, 0.91
平均 SSIM: 0.92

#include <opencv2/opencv.hpp>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <chrono>
#include <vector>
#include <string>
namespace fs = std::filesystem;
int main() {
    std::string inputDir = "./images";
    std::string outputDir = "./compressed";
    std::ofstream logFile("compression_log.csv");
    logFile << "Filename,Quality,OriginalSize,CompressedSize,CompressionRatio,ProcessingTime(ms)\n";
    std::vector<int> qualities = {50, 70, 90};
    for (const auto& entry : fs::directory_iterator(inputDir)) {
        if (!entry.is_regular_file()) continue;
        std::string ext = entry.path().extension().string();
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        if (ext != ".jpg" && ext != ".jpeg" && ext != ".png") continue;
        cv::Mat image = cv::imread(entry.path().string());
        if (image.empty()) {
            std::cerr << "画像の読み込みに失敗しました: " << entry.path() << std::endl;
            continue;
        }
        size_t originalSize = fs::file_size(entry.path());
        for (int q : qualities) {
            std::vector<int> params;
            if (ext == ".png") {
                // PNGは圧縮レベル0-9、ここでは品質を圧縮レベルに変換
                int compressionLevel = 9 - (q / 11); // 目安の変換
                params = {cv::IMWRITE_PNG_COMPRESSION, compressionLevel};
            } else {
                params = {cv::IMWRITE_JPEG_QUALITY, q};
            }
            std::vector<uchar> buffer;
            auto start = std::chrono::high_resolution_clock::now();
            bool success = cv::imencode(ext, image, buffer, params);
            auto end = std::chrono::high_resolution_clock::now();
            if (!success) {
                std::cerr << "エンコードに失敗しました: " << entry.path() << std::endl;
                continue;
            }
            size_t compressedSize = buffer.size();
            double compressionRatio = static_cast<double>(compressedSize) / originalSize;
            double processingTime = std::chrono::duration<double, std::milli>(end - start).count();
            // ファイル保存
            std::string outputPath = outputDir + "/" + entry.path().stem().string() + "_q" + std::to_string(q) + ext;
            std::ofstream ofs(outputPath, std::ios::binary);
            ofs.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
            ofs.close();
            // ログ出力
            logFile << entry.path().filename().string() << "," << q << "," << originalSize << "," << compressedSize << ","
                    << compressionRatio << "," << processingTime << "\n";
            std::cout << "処理完了: " << outputPath << " (品質=" << q << ", 圧縮率=" << compressionRatio << ", 時間=" << processingTime << "ms)" << std::endl;
        }
    }
    logFile.close();
    std::cout << "全画像の圧縮ログを compression_log.csv に保存しました。" << std::endl;
    return 0;
}

#include <opencv2/core/utils/logger.hpp>
#include <iostream>
int main() {
    // ログレベルをデバッグに設定
    cv::utils::logging::setLogLevel(cv::utils::logging::LOG_LEVEL_DEBUG);
    std::cout << "OpenCVのログレベルをDEBUGに設定しました。" << std::endl;
    // ここでOpenCVの処理を実行すると詳細ログが出力される
    return 0;
}

#include <opencv2/core/utils/logger.hpp>
#include <iostream>
void customLogger(cv::utils::logging::LogLevel level, const char* msg, const char* func, const char* file, int line) {
    std::cout << "[" << level << "] " << file << ":" << line << " " << func << " - " << msg << std::endl;
}
int main() {
    cv::utils::logging::setLogCallback(customLogger);
    // OpenCVの処理を実行すると、ログがcustomLoggerに渡される
    return 0;
}

cv::Mat image = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);

cv::imwrite("output.png", image);

if (image.channels() == 4) {
    std::cout << "アルファチャンネルがあります。" << std::endl;
}

#ifdef _WIN32
#include <windows.h>
#include <string>
std::wstring utf8ToWide(const std::string& utf8) {
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), (int)utf8.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), (int)utf8.size(), &wstrTo[0], size_needed);
    return wstrTo;
}
#endif

cv::Mat bgrImage = cv::imread("image.jpg");
cv::Mat rgbImage;
cv::cvtColor(bgrImage, rgbImage, cv::COLOR_BGR2RGB);