【C++】OpenCVで画像データセットを効率的に作成する方法と実装ポイント

sudo apt update
sudo apt install libopencv-dev

#include <nlohmann/json.hpp>
using json = nlohmann::json;

#include <filesystem>
namespace fs = std::filesystem;

#include <omp.h>

project_root/
├── data/
│   ├── raw/               # 元画像や未加工のデータ
│   ├── processed/         # 前処理済みの画像データ
│   ├── annotations/       # ラベルやアノテーションファイル
│   └── augmented/         # データ拡張後の画像
├── src/                   # C++ソースコード
│   ├── main.cpp
│   ├── image_processing.cpp
│   └── image_processing.h
├── build/                 # ビルド成果物
├── config/                # 設定ファイル(パラメータやパス指定)
└── logs/                  # 実行ログやエラーログ

namespace dataset {
    void loadImage(const std::string& path);
}
namespace preprocessing {
    void loadImage(const std::string& path);
}

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
namespace fs = std::filesystem;
int main() {
    std::string imageDir = "./data/raw";
    std::vector<std::string> imagePaths;
    // ディレクトリ内の画像ファイルを収集
    for (const auto& entry : fs::directory_iterator(imageDir)) {
        if (entry.is_regular_file()) {
            std::string ext = entry.path().extension().string();
            if (ext == ".jpg" || ext == ".png" || ext == ".bmp") {
                imagePaths.push_back(entry.path().string());
            }
        }
    }
    // 画像を1枚ずつ読み込み、リサイズして処理
    for (const auto& path : imagePaths) {
        cv::Mat img = cv::imread(path);
        if (img.empty()) {
            std::cerr << "Failed to load image: " << path << std::endl;
            continue;
        }
        // 画像を幅256ピクセルにリサイズ(アスペクト比維持)
        int targetWidth = 256;
        int targetHeight = static_cast<int>(img.rows * (256.0 / img.cols));
        cv::Mat resizedImg;
        cv::resize(img, resizedImg, cv::Size(targetWidth, targetHeight));
        // ここで画像処理や保存などの処理を行う
        std::cout << "Processed image: " << path << " -> size: "
                  << resizedImg.cols << "x" << resizedImg.rows << std::endl;
    }
    return 0;
}

Processed image: ./data/raw/cat_001.jpg -> size: 256x192
Processed image: ./data/raw/dog_002.png -> size: 256x170
...

#include <opencv2/opencv.hpp>
#include <iostream>
#include <string>
#include <filesystem>
namespace fs = std::filesystem;
int main() {
    std::string videoPath = "input_video.mp4";
    std::string outputDir = "./data/frames";
    fs::create_directories(outputDir);
    cv::VideoCapture cap(videoPath);
    if (!cap.isOpened()) {
        std::cerr << "Failed to open video: " << videoPath << std::endl;
        return -1;
    }
    double videoFPS = cap.get(cv::CAP_PROP_FPS);
    int frameInterval = static_cast<int>(videoFPS / 5); // 5fps抽出
    int frameCount = 0;
    int savedCount = 0;
    cv::Mat frame;
    while (true) {
        bool ret = cap.read(frame);
        if (!ret || frame.empty()) break;
        if (frameCount % frameInterval == 0) {
            // リサイズ(幅256ピクセル、アスペクト比維持)
            int targetWidth = 256;
            int targetHeight = static_cast<int>(frame.rows * (256.0 / frame.cols));
            cv::Mat resizedFrame;
            cv::resize(frame, resizedFrame, cv::Size(targetWidth, targetHeight));
            // ファイル名生成
            std::string filename = outputDir + "/frame_" + std::to_string(savedCount) + ".png";
            cv::imwrite(filename, resizedFrame);
            std::cout << "Saved frame: " << filename << std::endl;
            savedCount++;
        }
        frameCount++;
    }
    cap.release();
    return 0;
}

Saved frame: ./data/frames/frame_0.png
Saved frame: ./data/frames/frame_1.png
Saved frame: ./data/frames/frame_2.png
...

#include <opencv2/opencv.hpp>
#include <iostream>
cv::Mat resizeWithPadding(const cv::Mat& src, int targetWidth, int targetHeight) {
    int originalWidth = src.cols;
    int originalHeight = src.rows;
    float aspectSrc = static_cast<float>(originalWidth) / originalHeight;
    float aspectTarget = static_cast<float>(targetWidth) / targetHeight;
    cv::Mat resized;
    if (aspectSrc > aspectTarget) {
        // 横長画像：幅をtargetWidthに合わせてリサイズ
        int newHeight = static_cast<int>(targetWidth / aspectSrc);
        cv::resize(src, resized, cv::Size(targetWidth, newHeight));
        int top = (targetHeight - newHeight) / 2;
        int bottom = targetHeight - newHeight - top;
        cv::copyMakeBorder(resized, resized, top, bottom, 0, 0, cv::BORDER_CONSTANT, cv::Scalar(0,0,0));
    } else {
        // 縦長画像：高さをtargetHeightに合わせてリサイズ
        int newWidth = static_cast<int>(targetHeight * aspectSrc);
        cv::resize(src, resized, cv::Size(newWidth, targetHeight));
        int left = (targetWidth - newWidth) / 2;
        int right = targetWidth - newWidth - left;
        cv::copyMakeBorder(resized, resized, 0, 0, left, right, cv::BORDER_CONSTANT, cv::Scalar(0,0,0));
    }
    return resized;
}
int main() {
    cv::Mat img = cv::imread("input.jpg");
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    cv::Mat output = resizeWithPadding(img, 256, 256);
    cv::imwrite("output_padded.jpg", output);
    std::cout << "パディング付きリサイズ完了" << std::endl;
    return 0;
}

パディング付きリサイズ完了

cv::Mat floatImg;
img.convertTo(floatImg, CV_32FC3, 1.0 / 255.0); // 0〜1に正規化

cv::Mat normalizedImg = (floatImg - mean) / stddev;

cv::GaussianBlur(src, dst, cv::Size(5,5), 1.5);

cv::medianBlur(src, dst, 3);

cv::bilateralFilter(src, dst, 9, 75, 75);

cv::Point2f center(img.cols/2.0F, img.rows/2.0F);
double angle = 15.0; // 15度回転
cv::Mat rotMat = cv::getRotationMatrix2D(center, angle, 1.0);
cv::Mat rotated;
cv::warpAffine(img, rotated, rotMat, img.size());

cv::Mat flipped;
cv::flip(img, flipped, 1); // 1は水平方向反転

cv::resize(img, scaled, cv::Size(), 1.2, 1.2);

cv::Mat transMat = (cv::Mat_<double>(2,3) << 1, 0, 10, 0, 1, 20); // x方向10px, y方向20px移動
cv::warpAffine(img, shifted, transMat, img.size());

img.convertTo(brighter, -1, 1, 50); // 輝度を50増加

img.convertTo(contrastAdjusted, -1, 1.5, 0); // コントラスト1.5倍

double alpha = 0.7;
cv::addWeighted(foreground, alpha, background, 1 - alpha, 0.0, blended);

foreground.copyTo(background(cv::Rect(x, y, fg.cols, fg.rows)), mask);

#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <iostream>
struct Annotation {
    std::string filename;
    std::string className;
    int xmin, ymin, xmax, ymax;
};
std::vector<Annotation> loadCSVAnnotations(const std::string& csvPath) {
    std::vector<Annotation> annotations;
    std::ifstream file(csvPath);
    if (!file.is_open()) {
        std::cerr << "CSVファイルを開けませんでした: " << csvPath << std::endl;
        return annotations;
    }
    std::string line;
    // ヘッダー行を読み飛ばす
    std::getline(file, line);
    while (std::getline(file, line)) {
        std::stringstream ss(line);
        std::string token;
        Annotation ann;
        std::getline(ss, ann.filename, ',');
        std::getline(ss, ann.className, ',');
        std::getline(ss, token, ','); ann.xmin = std::stoi(token);
        std::getline(ss, token, ','); ann.ymin = std::stoi(token);
        std::getline(ss, token, ','); ann.xmax = std::stoi(token);
        std::getline(ss, token, ','); ann.ymax = std::stoi(token);
        annotations.push_back(ann);
    }
    return annotations;
}
int main() {
    auto annotations = loadCSVAnnotations("annotations.csv");
    for (const auto& ann : annotations) {
        std::cout << ann.filename << " " << ann.className << " "
                  << ann.xmin << "," << ann.ymin << "," << ann.xmax << "," << ann.ymax << std::endl;
    }
    return 0;
}

image_001.jpg cat 50,30,200,180
image_001.jpg dog 220,40,350,200
image_002.jpg bird 15,10,100,90

{
  "image_001.jpg": [
    {"class": "cat", "bbox": [50, 30, 200, 180]},
    {"class": "dog", "bbox": [220, 40, 350, 200]}
  ],
  "image_002.jpg": [
    {"class": "bird", "bbox": [15, 10, 100, 90]}
  ]
}

#include <iostream>
#include <fstream>
#include <nlohmann/json.hpp>
#include <vector>
#include <string>
using json = nlohmann::json;
struct Annotation {
    std::string className;
    int xmin, ymin, xmax, ymax;
};
std::vector<Annotation> loadJSONAnnotations(const std::string& jsonPath, const std::string& imageName) {
    std::vector<Annotation> annotations;
    std::ifstream file(jsonPath);
    if (!file.is_open()) {
        std::cerr << "JSONファイルを開けませんでした: " << jsonPath << std::endl;
        return annotations;
    }
    json j;
    file >> j;
    if (j.contains(imageName)) {
        for (const auto& item : j[imageName]) {
            Annotation ann;
            ann.className = item["class"];
            ann.xmin = item["bbox"][0];
            ann.ymin = item["bbox"][1];
            ann.xmax = item["bbox"][2];
            ann.ymax = item["bbox"][3];
            annotations.push_back(ann);
        }
    }
    return annotations;
}
int main() {
    auto annotations = loadJSONAnnotations("annotations.json", "image_001.jpg");
    for (const auto& ann : annotations) {
        std::cout << ann.className << " "
                  << ann.xmin << "," << ann.ymin << "," << ann.xmax << "," << ann.ymax << std::endl;
    }
    return 0;
}

cat 50,30,200,180
dog 220,40,350,200

<class_id> <x_center> <y_center> <width> <height>

0 0.5 0.5 0.4 0.3
1 0.7 0.6 0.2 0.1

#include <iostream>
#include <fstream>
#include <string>
void saveYOLOLabel(const std::string& filename, int classId, float xCenter, float yCenter, float width, float height) {
    std::ofstream ofs(filename, std::ios::app);
    if (!ofs.is_open()) {
        std::cerr << "ファイルを開けませんでした: " << filename << std::endl;
        return;
    }
    ofs << classId << " " << xCenter << " " << yCenter << " " << width << " " << height << std::endl;
    ofs.close();
}
int main() {
    // 例: クラス0の物体を画像中央に幅0.4、高さ0.3で保存
    saveYOLOLabel("image_001.txt", 0, 0.5f, 0.5f, 0.4f, 0.3f);
    saveYOLOLabel("image_001.txt", 1, 0.7f, 0.6f, 0.2f, 0.1f);
    std::cout << "YOLO形式ラベルを保存しました。" << std::endl;
    return 0;
}

YOLO形式ラベルを保存しました。

#include <string>
#include <vector>
struct BoundingBox {
    int xmin;
    int ymin;
    int xmax;
    int ymax;
    std::string className;
};
class ImageAnnotation {
public:
    std::string filename;
    std::vector<BoundingBox> boxes;
    void addBoundingBox(const BoundingBox& box) {
        boxes.push_back(box);
    }
    void clear() {
        boxes.clear();
    }
};

int main() {
    ImageAnnotation annotation;
    annotation.filename = "image_001.jpg";
    BoundingBox box1 = {50, 30, 200, 180, "cat"};
    BoundingBox box2 = {220, 40, 350, 200, "dog"};
    annotation.addBoundingBox(box1);
    annotation.addBoundingBox(box2);
    for (const auto& box : annotation.boxes) {
        std::cout << annotation.filename << " " << box.className << " "
                  << box.xmin << "," << box.ymin << "," << box.xmax << "," << box.ymax << std::endl;
    }
    return 0;
}

image_001.jpg cat 50,30,200,180
image_001.jpg dog 220,40,350,200

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        std::cerr << "カスケード分類器の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat img = cv::imread("test.jpg");
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    std::vector<cv::Rect> faces;
    faceCascade.detectMultiScale(img, faces, 1.1, 3, 0, cv::Size(30, 30));
    for (const auto& face : faces) {
        cv::rectangle(img, face, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Detected Faces", img);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに検出された顔の周囲に緑色の矩形が表示される)

import torch
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
img_path = 'input.jpg'
results = model(img_path)
results.save()  # 検出結果を保存(画像にバウンディングボックスを描画)

# 検出結果のラベルと座標を取得

for *box, conf, cls in results.xyxy[0]:
    print(f"Class: {int(cls)}, Confidence: {conf:.2f}, Box: {box}")

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    cv::Mat img = cv::imread("input.jpg");
    if (img.empty()) return -1;
    std::vector<int> params;
    params.push_back(cv::IMWRITE_JPEG_QUALITY);
    params.push_back(90);  // 画質90(0〜100)
    cv::imwrite("output.jpg", img, params);
    return 0;
}

params.clear();
params.push_back(cv::IMWRITE_PNG_COMPRESSION);
params.push_back(3);  // 圧縮レベル3(0〜9)
cv::imwrite("output.png", img, params);

#include <opencv2/opencv.hpp>
#include <fstream>
#include <string>
void saveImageAndLabel(const cv::Mat& img, const std::string& baseName, const std::string& label) {
    std::string imgPath = baseName + ".jpg";
    std::string labelPath = baseName + ".txt";
    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
    cv::imwrite(imgPath, img, params);
    std::ofstream ofs(labelPath);
    if (ofs.is_open()) {
        ofs << label << std::endl;
        ofs.close();
    }
}
int main() {
    cv::Mat img = cv::imread("input.jpg");
    if (img.empty()) return -1;
    std::string baseName = "dataset/image_0001";
    std::string label = "cat 50 30 200 180";  // 例：クラス名とバウンディングボックス
    saveImageAndLabel(img, baseName, label);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <omp.h>
namespace fs = std::filesystem;
int main() {
    std::string inputDir = "./data/raw";
    std::string outputDir = "./data/processed";
    fs::create_directories(outputDir);
    std::vector<std::string> imagePaths;
    for (const auto& entry : fs::directory_iterator(inputDir)) {
        if (entry.is_regular_file()) {
            std::string ext = entry.path().extension().string();
            if (ext == ".jpg" || ext == ".png" || ext == ".bmp") {
                imagePaths.push_back(entry.path().string());
            }
        }
    }
    int numImages = static_cast<int>(imagePaths.size());
    #pragma omp parallel for schedule(dynamic)
    for (int i = 0; i < numImages; ++i) {
        cv::Mat img = cv::imread(imagePaths[i]);
        if (img.empty()) {
            #pragma omp critical
            std::cerr << "Failed to load image: " << imagePaths[i] << std::endl;
            continue;
        }
        cv::Mat resized;
        cv::resize(img, resized, cv::Size(256, 256));
        std::string filename = fs::path(imagePaths[i]).filename().string();
        std::string outputPath = outputDir + "/" + filename;
        cv::imwrite(outputPath, resized);
        #pragma omp critical
        std::cout << "Processed: " << filename << " by thread " << omp_get_thread_num() << std::endl;
    }
    return 0;
}

Processed: cat_001.jpg by thread 0
Processed: dog_002.png by thread 1
Processed: bird_003.bmp by thread 2
...

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
namespace fs = std::filesystem;
std::queue<std::string> taskQueue;
std::mutex queueMutex;
std::condition_variable cv;
bool finished = false;
void worker(const std::string& outputDir) {
    while (true) {
        std::string imagePath;
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            cv.wait(lock, [] { return !taskQueue.empty() || finished; });
            if (finished && taskQueue.empty()) break;
            imagePath = taskQueue.front();
            taskQueue.pop();
        }
        cv::Mat img = cv::imread(imagePath);
        if (img.empty()) {
            std::cerr << "Failed to load image: " << imagePath << std::endl;
            continue;
        }
        cv::Mat resized;
        cv::resize(img, resized, cv::Size(256, 256));
        std::string filename = fs::path(imagePath).filename().string();
        std::string outputPath = outputDir + "/" + filename;
        cv::imwrite(outputPath, resized);
        std::cout << "Processed: " << filename << " by thread " << std::this_thread::get_id() << std::endl;
    }
}
int main() {
    std::string inputDir = "./data/raw";
    std::string outputDir = "./data/processed";
    fs::create_directories(outputDir);
    // タスクをキューに追加
    for (const auto& entry : fs::directory_iterator(inputDir)) {
        if (entry.is_regular_file()) {
            std::string ext = entry.path().extension().string();
            if (ext == ".jpg" || ext == ".png" || ext == ".bmp") {
                std::lock_guard<std::mutex> lock(queueMutex);
                taskQueue.push(entry.path().string());
            }
        }
    }
    // ワーカースレッドを複数起動
    const int numThreads = std::thread::hardware_concurrency();
    std::vector<std::thread> workers;
    for (int i = 0; i < numThreads; ++i) {
        workers.emplace_back(worker, outputDir);
    }
    // 全タスク投入完了を通知
    {
        std::lock_guard<std::mutex> lock(queueMutex);
        finished = true;
    }
    cv.notify_all();
    // スレッド終了待ち
    for (auto& t : workers) {
        t.join();
    }
    return 0;
}

Processed: cat_001.jpg by thread 140735123456768
Processed: dog_002.png by thread 140735115064064
...

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    try {
        cv::Mat img = cv::imread("input.jpg");
        if (img.empty()) {
            throw std::runtime_error("画像が読み込めませんでした。ファイルが存在しないか破損しています。");
        }
        cv::Mat resized;
        cv::resize(img, resized, cv::Size(256, 256));
        if (!cv::imwrite("output.jpg", resized)) {
            throw std::runtime_error("画像の保存に失敗しました。");
        }
        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 <iostream>
#include <fstream>
#include <string>
#include <mutex>
enum class LogLevel { DEBUG, INFO, WARNING, ERROR, FATAL };
class Logger {
private:
    LogLevel currentLevel;
    std::mutex mtx;
    std::ofstream logFile;
    std::string levelToString(LogLevel level) {
        switch (level) {
            case LogLevel::DEBUG: return "DEBUG";
            case LogLevel::INFO: return "INFO";
            case LogLevel::WARNING: return "WARNING";
            case LogLevel::ERROR: return "ERROR";
            case LogLevel::FATAL: return "FATAL";
            default: return "UNKNOWN";
        }
    }
public:
    Logger(LogLevel level, const std::string& filename = "") : currentLevel(level) {
        if (!filename.empty()) {
            logFile.open(filename, std::ios::app);
        }
    }
    ~Logger() {
        if (logFile.is_open()) logFile.close();
    }
    void log(LogLevel level, const std::string& message) {
        if (level < currentLevel) return;
        std::lock_guard<std::mutex> lock(mtx);
        std::string output = "[" + levelToString(level) + "] " + message + "\n";
        std::cout << output;
        if (logFile.is_open()) {
            logFile << output;
            logFile.flush();
        }
    }
};
int main() {
    Logger logger(LogLevel::INFO, "app.log");
    logger.log(LogLevel::DEBUG, "これはデバッグメッセージです。");  // 出力されない
    logger.log(LogLevel::INFO, "処理を開始しました。");
    logger.log(LogLevel::WARNING, "ファイルが見つかりません。");
    logger.log(LogLevel::ERROR, "画像の読み込みに失敗しました。");
    logger.log(LogLevel::FATAL, "致命的なエラーが発生しました。");
    return 0;
}

[INFO] 処理を開始しました。
[WARNING] ファイルが見つかりません。
[ERROR] 画像の読み込みに失敗しました。
[FATAL] 致命的なエラーが発生しました。

#include <filesystem>
namespace fs = std::filesystem;
fs::path imgPath = fs::path("data") / "images" / "img1.jpg";
std::string pathStr = imgPath.string();  // プラットフォームに応じた文字列を取得

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("input_with_exif.jpg");
    if (img.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // Exif情報は保持されずに保存される
    if (!cv::imwrite("output_no_exif.jpg", img)) {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "Exif情報を除去して保存しました。" << std::endl;
    return 0;
}

Exif情報を除去して保存しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        std::cerr << "カスケード分類器の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat img = cv::imread("input.jpg");
    if (img.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<cv::Rect> faces;
    faceCascade.detectMultiScale(img, faces, 1.1, 3, 0, cv::Size(30, 30));
    for (const auto& face : faces) {
        // 顔領域を切り出し
        cv::Mat faceROI = img(face);
        // ガウシアンブラーでぼかし処理
        cv::GaussianBlur(faceROI, faceROI, cv::Size(55, 55), 30);
        // ぼかした領域を元画像に戻す(faceROIは参照なので自動反映)
    }
    if (!cv::imwrite("output_masked.jpg", img)) {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "顔領域をマスク処理して保存しました。" << std::endl;
    return 0;
}

顔領域をマスク処理して保存しました。

void applyMosaic(cv::Mat& img, const cv::Rect& region, int blockSize) {
    for (int y = region.y; y < region.y + region.height; y += blockSize) {
        for (int x = region.x; x < region.x + region.width; x += blockSize) {
            int w = std::min(blockSize, region.x + region.width - x);
            int h = std::min(blockSize, region.y + region.height - y);
            cv::Rect blockRect(x, y, w, h);
            cv::Mat block = img(blockRect);
            cv::Scalar color = cv::mean(block);
            block.setTo(color);
        }
    }
}

#include <gtest/gtest.h>
#include <opencv2/opencv.hpp>
// テスト対象のリサイズ関数(例)
cv::Mat resizeImage(const cv::Mat& src, int width, int height) {
    cv::Mat dst;
    cv::resize(src, dst, cv::Size(width, height));
    return dst;
}
TEST(ImageProcessingTest, ResizeImage) {
    cv::Mat src = cv::Mat::zeros(100, 200, CV_8UC3);
    cv::Mat resized = resizeImage(src, 50, 50);
    EXPECT_EQ(resized.cols, 50);
    EXPECT_EQ(resized.rows, 50);
    EXPECT_EQ(resized.type(), src.type());
}
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

#include <opencv2/opencv.hpp>
#include <iostream>
bool compareImages(const cv::Mat& img1, const cv::Mat& img2, double threshold, cv::Mat& diff) {
    if (img1.size() != img2.size() || img1.type() != img2.type()) {
        std::cerr << "画像サイズまたはタイプが異なります。" << std::endl;
        return false;
    }
    cv::absdiff(img1, img2, diff);
    cv::Mat grayDiff;
    cv::cvtColor(diff, grayDiff, cv::COLOR_BGR2GRAY);
    double maxVal;
    cv::minMaxLoc(grayDiff, nullptr, &maxVal);
    return maxVal <= threshold;
}
int main() {
    cv::Mat baseImg = cv::imread("baseline.png");
    cv::Mat testImg = cv::imread("test_output.png");
    cv::Mat diff;
    if (baseImg.empty() || testImg.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    double threshold = 10.0; // 許容差分値
    bool result = compareImages(baseImg, testImg, threshold, diff);
    if (!result) {
        cv::imwrite("diff.png", diff);
        std::cout << "画像に差異があります。差分画像を保存しました。" << std::endl;
    } else {
        std::cout << "画像は基準と一致しています。" << std::endl;
    }
    return 0;
}

画像に差異があります。差分画像を保存しました。

dataset/
├── v1.0/
│   ├── images/
│   └── annotations/
├── v1.1/
│   ├── images/
│   └── annotations/
└── latest -> v1.1/  # シンボリックリンクで最新バージョンを指す

新規画像取得
      ↓
前処理・ラベル付け
      ↓
品質検査・修正
      ↓
既存データセットに統合(バージョニング)
      ↓
増分データ抽出
      ↓
増分学習実行
      ↓
モデル評価・改善