【C++】OpenCVで実現する自動化ツールの作り方と開発ステップ

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像を読み込む
    cv::Mat inputImage = cv::imread("input.jpg");
    if (inputImage.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 画像をグレースケールに変換
    cv::Mat grayImage;
    cv::cvtColor(inputImage, grayImage, cv::COLOR_BGR2GRAY);
    // 画像を保存する
    if (!cv::imwrite("output.png", grayImage)) {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "画像処理が完了しました。" << std::endl;
    return 0;
}

画像処理が完了しました。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap(0); // カメラデバイス0を開く
    if (!cap.isOpened()) {
        std::cerr << "カメラを開けませんでした。" << std::endl;
        return -1;
    }
    cv::Mat frame, grayFrame;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        cv::cvtColor(frame, grayFrame, cv::COLOR_BGR2GRAY);
        cv::imshow("Gray Video", grayFrame);
        if (cv::waitKey(30) >= 0) break; // 30ms待機、キー入力で終了
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

(カメラ映像がグレースケールでリアルタイム表示される)

[入力ステージ] → [前処理ステージ] → [解析ステージ] → [出力ステージ]

#include <opencv2/opencv.hpp>
#include <iostream>
cv::Mat loadImage(const std::string& path) {
    cv::Mat img = cv::imread(path);
    if (img.empty()) {
        std::cerr << "画像の読み込みに失敗しました: " << path << std::endl;
    }
    return img;
}
int main() {
    cv::Mat image = loadImage("sample.jpg");
    if (image.empty()) return -1;
    // 以降の処理へ渡す
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("shapes.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    cv::threshold(src, binary, 100, 255, cv::THRESH_BINARY);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat output = cv::Mat::zeros(src.size(), CV_8UC3);
    for (size_t i = 0; i < contours.size(); ++i) {
        cv::drawContours(output, contours, static_cast<int>(i), cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Contours", output);
    cv::waitKey(0);
    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::rectangle(image, cv::Point(50, 50), cv::Point(200, 200), cv::Scalar(0, 0, 255), 3);
    // 画像を保存
    if (!cv::imwrite("output_with_rect.jpg", image)) {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
        return -1;
    }
    // 画面表示
    cv::imshow("Result", image);
    cv::waitKey(0);
    return 0;
}

(赤い矩形が描画された画像が表示され、output_with_rect.jpgとして保存される)

cv::Mat image = cv::imread("input.jpg", cv::IMREAD_COLOR);
if (image.empty()) {
    std::cerr << "画像の読み込みに失敗しました。" << std::endl;
}

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

cv::VideoCapture cap("video.mp4"); // ファイルから
// または
cv::VideoCapture cap(0); // カメラデバイス0から

cv::VideoWriter writer("output.avi", cv::VideoWriter::fourcc('M','J','P','G'), 30, cv::Size(width, height));
writer.write(frame);

cv::cvtColor(src, dst, cv::COLOR_BGR2GRAY);

cv::resize(src, dst, cv::Size(newWidth, newHeight));

cv::GaussianBlur(src, dst, cv::Size(5,5), 0);
cv::medianBlur(src, dst, 3);

cv::threshold(src, dst, 128, 255, cv::THRESH_BINARY);
cv::adaptiveThreshold(src, dst, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 11, 2);

cv::Canny(src, edges, 100, 200);

cv::CascadeClassifier face_cascade;
face_cascade.load("haarcascade_frontalface_default.xml");
std::vector<cv::Rect> faces;
face_cascade.detectMultiScale(grayImage, faces);

cv::Ptr<cv::ORB> orb = cv::ORB::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
orb->detectAndCompute(image, cv::noArray(), keypoints, descriptors);

std::vector<std::vector<cv::Point>> contours;
cv::findContours(binaryImage, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

cv::matchTemplate(image, templateImage, result, cv::TM_CCOEFF_NORMED);

cv::rectangle(image, cv::Point(50, 50), cv::Point(200, 200), cv::Scalar(0, 255, 0), 2);
cv::putText(image, "Detected", cv::Point(60, 45), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(0, 255, 0), 2);

cv::imshow("Result", image);
cv::waitKey(0);

class PipelineController {
public:
    PipelineController();
    void run();
private:
    FrameReader frameReader;
    Preprocessor preprocessor;
    Analyzer analyzer;
    ResultWriter resultWriter;
};

class FrameReader {
public:
    bool open(const std::string& source);
    bool read(cv::Mat& frame);
    void close();
private:
    cv::VideoCapture cap;
};

class Preprocessor {
public:
    void process(const cv::Mat& input, cv::Mat& output);
private:
    // パラメータや設定を保持
};

class Analyzer {
public:
    void analyze(const cv::Mat& input);
    const std::vector<cv::Rect>& getDetections() const;
private:
    std::vector<cv::Rect> detections;
    cv::CascadeClassifier cascade;
};

class ResultWriter {
public:
    void writeImage(const cv::Mat& image, const std::string& filename);
    void writeReport(const std::vector<cv::Rect>& detections, const std::string& filename);
};

class IAnalyzer {
public:
    virtual ~IAnalyzer() = default;
    virtual void analyze(const cv::Mat& input) = 0;
    virtual const std::vector<cv::Rect>& getDetections() const = 0;
};

class HaarAnalyzer : public IAnalyzer {
    // Haar Cascadeによる解析実装
};
class DnnAnalyzer : public IAnalyzer {
    // DNNによる解析実装
};

project_root
├── include                # ヘッダーファイル
│   ├── pipeline           # パイプライン関連クラスのヘッダー
│   │   ├── PipelineController.h
│   │   ├── FrameReader.h
│   │   ├── Preprocessor.h
│   │   ├── Analyzer.h
│   │   └── ResultWriter.h
│   └── utils              # ユーティリティ関数や共通定義
│       └── Logger.h
├── src                    # ソースファイル
│   ├── pipeline           # パイプライン関連クラスの実装
│   │   ├── PipelineController.cpp
│   │   ├── FrameReader.cpp
│   │   ├── Preprocessor.cpp
│   │   ├── Analyzer.cpp
│   │   └── ResultWriter.cpp
│   └── utils              # ユーティリティ実装
│       └── Logger.cpp
├── tests                  # テストコード
│   ├── pipeline
│   └── utils
├── data                   # 入力画像や動画、設定ファイル
├── build                  # ビルド出力ディレクトリ(CMake等で生成)
├── CMakeLists.txt          # ビルド設定ファイル
└── README.md               # プロジェクト説明

PipelineController
   ├── FrameReader
   ├── Preprocessor
   ├── Analyzer
   └── ResultWriter

namespace pipeline {
    class PipelineController { /* ... */ };
    class FrameReader { /* ... */ };
    // 他クラスも同様に
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像ファイルをカラーで読み込む
    cv::Mat colorImage = cv::imread("input.jpg", cv::IMREAD_COLOR);
    if (colorImage.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // グレースケールに変換
    cv::Mat grayImage;
    cv::cvtColor(colorImage, grayImage, cv::COLOR_BGR2GRAY);
    // 画像を表示
    cv::imshow("Color Image", colorImage);
    cv::imshow("Gray Image", grayImage);
    cv::waitKey(0);
    return 0;
}

(カラー画像とグレースケール画像の2つのウィンドウが表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap("input.mp4");
    if (!cap.isOpened()) {
        std::cerr << "動画ファイルを開けませんでした。" << std::endl;
        return -1;
    }
    cv::Mat frame, grayFrame;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        cv::cvtColor(frame, grayFrame, cv::COLOR_BGR2GRAY);
        cv::imshow("Gray Video", grayFrame);
        if (cv::waitKey(30) >= 0) break; // 30ms待機、キー入力で終了
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

(動画の各フレームがグレースケールでリアルタイム表示される)

cap.set(cv::CAP_PROP_FRAME_WIDTH, 640);
cap.set(cv::CAP_PROP_FRAME_HEIGHT, 480);
cap.set(cv::CAP_PROP_FPS, 30);

#include <opencv2/opencv.hpp>
#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <vector>
std::queue<cv::Mat> imageQueue;
std::mutex queueMutex;
std::condition_variable cvQueue;
bool finished = false;
void imageLoader(const std::vector<std::string>& files) {
    for (const auto& file : files) {
        cv::Mat img = cv::imread(file);
        if (!img.empty()) {
            std::unique_lock<std::mutex> lock(queueMutex);
            imageQueue.push(img);
            cvQueue.notify_one();
        }
    }
    std::unique_lock<std::mutex> lock(queueMutex);
    finished = true;
    cvQueue.notify_all();
}
void imageProcessor() {
    while (true) {
        std::unique_lock<std::mutex> lock(queueMutex);
        cvQueue.wait(lock, [] { return !imageQueue.empty() || finished; });
        if (imageQueue.empty() && finished) break;
        cv::Mat img = imageQueue.front();
        imageQueue.pop();
        lock.unlock();
        // ここで画像処理を行う(例：グレースケール変換)
        cv::Mat gray;
        cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
        // 処理結果の利用や保存など
        std::cout << "Processed an image of size: " << gray.cols << "x" << gray.rows << std::endl;
    }
}
int main() {
    std::vector<std::string> files = {"img1.jpg", "img2.jpg", "img3.jpg"};
    std::thread loader(imageLoader, files);
    std::thread processor(imageProcessor);
    loader.join();
    processor.join();
    return 0;
}

Processed an image of size: 640x480
Processed an image of size: 800x600
Processed an image of size: 1024x768

cv::cvtColor(src, dst, cv::COLOR_BGR2GRAY);

cv::cvtColor(src, dst, cv::COLOR_BGR2HSV);

cv::cvtColor(src, dst, cv::COLOR_BGR2Lab);

#include <opencv2/opencv.hpp>
#include <iostream>
cv::Mat resizeWithAspectRatio(const cv::Mat& src, int targetWidth, int targetHeight) {
    int originalWidth = src.cols;
    int originalHeight = src.rows;
    double aspectRatio = static_cast<double>(originalWidth) / originalHeight;
    int newWidth = targetWidth;
    int newHeight = targetHeight;
    if (targetWidth / static_cast<double>(targetHeight) > aspectRatio) {
        newWidth = static_cast<int>(targetHeight * aspectRatio);
    } else {
        newHeight = static_cast<int>(targetWidth / aspectRatio);
    }
    cv::Mat dst;
    cv::resize(src, dst, cv::Size(newWidth, newHeight));
    return dst;
}
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat resized = resizeWithAspectRatio(image, 640, 480);
    cv::imshow("Resized Image", resized);
    cv::waitKey(0);
    return 0;
}

(アスペクト比を保持したまま640x480以内にリサイズされた画像が表示される)

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

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

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

cv::threshold(src, dst, 128, 255, cv::THRESH_BINARY);

cv::threshold(src, dst, 128, 255, cv::THRESH_BINARY_INV);

cv::adaptiveThreshold(src, dst, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 11, 2);

double thresh = cv::threshold(src, dst, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat gray = cv::imread("input.jpg", cv::IMREAD_GRAYSCALE);
    if (gray.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    double thresh = cv::threshold(gray, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::cout << "自動決定されたしきい値: " << thresh << std::endl;
    cv::imshow("Binary Image", binary);
    cv::waitKey(0);
    return 0;
}

自動決定されたしきい値: 127.5
(しきい値処理された二値画像が表示される)

#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 image = cv::imread("face.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<cv::Rect> faces;
    cv::Mat gray;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
    cv::equalizeHist(gray, gray);
    faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, cv::Size(30, 30));
    for (const auto& face : faces) {
        cv::rectangle(image, face, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Detected Faces", image);
    cv::waitKey(0);
    return 0;
}

(検出された顔に緑色の矩形が描画された画像が表示される)

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

int main() {
    cv::HOGDescriptor hog;
    hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());

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

    std::vector<cv::Rect> detections;
    std::vector<double> foundWeights;

    // パラメータを指定して検出
    hog.detectMultiScale(image, detections, foundWeights,
                         0.0,              // hitThreshold
                         cv::Size(8, 8),   // winStride
                         cv::Size(32, 32), // padding
                         1.05,             // scale
                         2,                // groupThreshold
                         false);           // useMeanshiftGrouping

    // 信頼度が高い検出だけ描画
    for (size_t i = 0; i < detections.size(); i++) {
        if (foundWeights[i] < 1.0) continue; // 信頼度閾値
        cv::rectangle(image, detections[i], cv::Scalar(255, 0, 0), 2);
    }

    cv::imshow("Pedestrian Detection", image);
    cv::waitKey(0);
    return 0;
}

(検出された歩行者に青色の矩形が描画された画像が表示される)

#include <opencv2/opencv.hpp>
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
    // モデルとクラス名のパス
    std::string modelPath = "yolov5s.onnx";
    std::string classesFile = "coco.names";
    // クラス名の読み込み
    std::vector<std::string> classNames;
    std::ifstream ifs(classesFile.c_str());
    std::string line;
    while (std::getline(ifs, line)) classNames.push_back(line);
    // DNNネットワークの読み込み
    cv::dnn::Net net = cv::dnn::readNetFromONNX(modelPath);
    if (net.empty()) {
        std::cerr << "モデルの読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 入力前処理
    cv::Mat blob = cv::dnn::blobFromImage(image, 1/255.0, cv::Size(640, 640), cv::Scalar(), true, false);
    net.setInput(blob);
    // 推論実行
    std::vector<cv::Mat> outputs;
    net.forward(outputs, net.getUnconnectedOutLayersNames());
    // 出力解析(省略、NMSなどを実装する必要あり)
    // ここでは簡略化のため、描画処理は割愛
    std::cout << "YOLOv5推論完了" << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("shapes.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    cv::threshold(src, binary, 100, 255, cv::THRESH_BINARY);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat output = cv::Mat::zeros(src.size(), CV_8UC3);
    for (size_t i = 0; i < contours.size(); ++i) {
        double area = cv::contourArea(contours[i]);
        std::vector<cv::Point> approx;
        cv::approxPolyDP(contours[i], approx, 5, true);
        cv::Scalar color(0, 255, 0);
        cv::drawContours(output, contours, static_cast<int>(i), color, 2);
        // 面積と頂点数を表示
        cv::putText(output, "Area:" + std::to_string(static_cast<int>(area)), approx[0], cv::FONT_HERSHEY_SIMPLEX, 0.5, color, 1);
        cv::putText(output, "Verts:" + std::to_string(approx.size()), approx[0] + cv::Point(0,15), cv::FONT_HERSHEY_SIMPLEX, 0.5, color, 1);
    }
    cv::imshow("Contours and Shape Analysis", output);
    cv::waitKey(0);
    return 0;
}

(輪郭が緑色で描画され、各輪郭の面積と頂点数が表示されるウィンドウが開く)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("scene.jpg", cv::IMREAD_COLOR);
    cv::Mat templateImg = cv::imread("template.jpg", cv::IMREAD_COLOR);
    if (image.empty() || templateImg.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat result;
    cv::matchTemplate(image, templateImg, result, cv::TM_CCOEFF_NORMED);
    double minVal, maxVal;
    cv::Point minLoc, maxLoc;
    cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);
    cv::rectangle(image, maxLoc, cv::Point(maxLoc.x + templateImg.cols, maxLoc.y + templateImg.rows), cv::Scalar(0, 0, 255), 2);
    std::cout << "最高類似度スコア: " << maxVal << std::endl;
    cv::imshow("Template Matching Result", image);
    cv::waitKey(0);
    return 0;
}

最高類似度スコア: 0.85
(テンプレートに一致した領域が赤い矩形で囲まれた画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 画像をPNG形式で保存
    if (!cv::imwrite("output.png", image)) {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "画像を保存しました。" << std::endl;
    return 0;
}

画像を保存しました。

std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 90};
cv::imwrite("output.jpg", image, params);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    int width = 640;
    int height = 480;
    int fps = 30;
    cv::VideoWriter writer("output.avi", cv::VideoWriter::fourcc('M','J','P','G'), fps, cv::Size(width, height));
    if (!writer.isOpened()) {
        std::cerr << "動画ファイルの作成に失敗しました。" << std::endl;
        return -1;
    }
    for (int i = 0; i < 100; ++i) {
        cv::Mat frame(height, width, CV_8UC3, cv::Scalar(0, 0, 0));
        cv::putText(frame, "Frame " + std::to_string(i), cv::Point(50, 240), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(0, 255, 0), 2);
        writer.write(frame);
    }
    writer.release();
    std::cout << "動画を生成しました。" << std::endl;
    return 0;
}

動画を生成しました。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <fstream>
#include <vector>
struct Detection {
    int x, y, width, height;
};
int main() {
    std::vector<Detection> detections = {
        {100, 150, 50, 60},
        {200, 80, 40, 70}
    };
    std::ofstream ofs("detections.csv");
    if (!ofs) {
        std::cerr << "ファイルを開けませんでした。" << std::endl;
        return -1;
    }
    ofs << "x,y,width,height\n";
    for (const auto& d : detections) {
        ofs << d.x << "," << d.y << "," << d.width << "," << d.height << "\n";
    }
    ofs.close();
    std::cout << "CSVファイルを出力しました。" << std::endl;
    return 0;
}

CSVファイルを出力しました。

#include <opencv2/opencv.hpp>
#include <iostream>
#include <fstream>
#include <vector>
#include <nlohmann/json.hpp>
struct Detection {
    int x, y, width, height;
};
int main() {
    std::vector<Detection> detections = {
        {100, 150, 50, 60},
        {200, 80, 40, 70}
    };
    nlohmann::json j;
    for (const auto& d : detections) {
        j["detections"].push_back({
            {"x", d.x},
            {"y", d.y},
            {"width", d.width},
            {"height", d.height}
        });
    }
    std::ofstream ofs("detections.json");
    if (!ofs) {
        std::cerr << "ファイルを開けませんでした。" << std::endl;
        return -1;
    }
    ofs << j.dump(4); // インデント4スペースで整形出力
    ofs.close();
    std::cout << "JSONファイルを出力しました。" << std::endl;
    return 0;
}

JSONファイルを出力しました。

{
    "detections": [
        {
            "x": 100,
            "y": 150,
            "width": 50,
            "height": 60
        },
        {
            "x": 200,
            "y": 80,
            "width": 40,
            "height": 70
        }
    ]
}

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
struct Detection {
    cv::Rect bbox;
    std::string label;
};
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<Detection> detections = {
        {cv::Rect(100, 150, 50, 60), "Object A"},
        {cv::Rect(200, 80, 40, 70), "Object B"}
    };
    for (const auto& det : detections) {
        cv::rectangle(image, det.bbox, cv::Scalar(0, 255, 0), 2);
        cv::putText(image, det.label, det.bbox.tl() - cv::Point(0, 5),
                    cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Overlay Result", image);
    cv::waitKey(0);
    return 0;
}

(検出領域に緑色の矩形とラベルが描画された画像が表示される)

class ImageProcessingException : public std::runtime_error {
public:
    explicit ImageProcessingException(const std::string& message)
        : std::runtime_error(message) {}
};
class FileNotFoundException : public ImageProcessingException {
public:
    explicit FileNotFoundException(const std::string& message)
        : ImageProcessingException(message) {}
};

[2024-06-01 12:34:56][ERROR][PipelineController] ファイル読み込みに失敗しました: input.jpg

#define LOG_DEBUG(msg) if (logLevel <= DEBUG) std::cout << "[DEBUG] " << msg << std::endl;
#define LOG_ERROR(msg) std::cerr << "[ERROR] " << msg << std::endl;

#include <yaml-cpp/yaml.h>
#include <iostream>
#include <string>
struct Config {
    int threshold;
    double scaleFactor;
    std::string inputPath;
};
Config loadConfig(const std::string& filename) {
    Config config;
    YAML::Node node = YAML::LoadFile(filename);
    config.threshold = node["threshold"].as<int>();
    config.scaleFactor = node["scale_factor"].as<double>();
    config.inputPath = node["input_path"].as<std::string>();
    return config;
}
int main() {
    Config config = loadConfig("config.yaml");
    std::cout << "Threshold: " << config.threshold << std::endl;
    std::cout << "Scale Factor: " << config.scaleFactor << std::endl;
    std::cout << "Input Path: " << config.inputPath << std::endl;
    return 0;
}

threshold: 128
scale_factor: 1.1
input_path: "images/input.jpg"

#include <nlohmann/json.hpp>
#include <fstream>
#include <iostream>
#include <string>
struct Config {
    int threshold;
    double scaleFactor;
    std::string inputPath;
};
Config loadConfig(const std::string& filename) {
    Config config;
    std::ifstream ifs(filename);
    nlohmann::json j;
    ifs >> j;
    config.threshold = j["threshold"];
    config.scaleFactor = j["scale_factor"];
    config.inputPath = j["input_path"];
    return config;
}
int main() {
    Config config = loadConfig("config.json");
    std::cout << "Threshold: " << config.threshold << std::endl;
    std::cout << "Scale Factor: " << config.scaleFactor << std::endl;
    std::cout << "Input Path: " << config.inputPath << std::endl;
    return 0;
}

{
    "threshold": 128,
    "scale_factor": 1.1,
    "input_path": "images/input.jpg"
}

#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
std::atomic<int> threshold(128);
void parameterUpdater() {
    while (true) {
        std::cout << "新しいしきい値を入力してください(現在値: " << threshold.load() << "): ";
        int newVal;
        std::cin >> newVal;
        if (newVal > 0 && newVal < 255) {
            threshold.store(newVal);
            std::cout << "しきい値を " << newVal << " に更新しました。\n";
        } else {
            std::cout << "無効な値です。\n";
        }
    }
}
int main() {
    std::thread updater(parameterUpdater);
    // メイン処理の例
    for (int i = 0; i < 10; ++i) {
        int currentThreshold = threshold.load();
        std::cout << "現在のしきい値で処理中: " << currentThreshold << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    updater.detach();
    return 0;
}

新しいしきい値を入力してください(現在値: 128): 150
しきい値を 150 に更新しました。
現在のしきい値で処理中: 150

#include <gtest/gtest.h>
#include <opencv2/opencv.hpp>
// 色空間変換関数のテスト例
cv::Mat convertToGray(const cv::Mat& src) {
    cv::Mat gray;
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
    return gray;
}
TEST(ImageProcessingTest, ConvertToGray) {
    cv::Mat color = cv::imread("test_color.jpg");
    ASSERT_FALSE(color.empty());
    cv::Mat gray = convertToGray(color);
    EXPECT_EQ(gray.channels(), 1);
    EXPECT_EQ(gray.size(), color.size());
}
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

#include <opencv2/opencv.hpp>
#include <iostream>
#include <chrono>
int main() {
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    auto start = std::chrono::high_resolution_clock::now();
    cv::Mat gray;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - start;
    std::cout << "グレースケール変換にかかった時間: " << elapsed.count() << " ms" << std::endl;
    return 0;
}

name: C++ CI
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:

    - name: ソースコードのチェックアウト

      uses: actions/checkout@v3

    - name: CMakeのセットアップ

      uses: jwlawson/actions-setup-cmake@v1

    - name: OpenCVのインストール

      run: |
        sudo apt-get update
        sudo apt-get install -y libopencv-dev

    - name: ビルドディレクトリ作成

      run: mkdir build

    - name: CMakeでビルド設定

      run: cmake -S . -B build

    - name: ビルド実行

      run: cmake --build build --config Release

    - name: テスト実行

      run: ctest --test-dir build --output-on-failure

![Build Status](https://github.com/ユーザー名/リポジトリ名/actions/workflows/ci.yml/badge.svg)

cmake -D CMAKE_BUILD_TYPE=Release -D ENABLE_SSE=ON -D ENABLE_AVX=ON ..

-O3 -march=native -mtune=native

std::cout << cv::getBuildInformation() << std::endl;

#include <thread>
#include <vector>
#include <opencv2/opencv.hpp>
void processImage(const cv::Mat& img, int id) {
    cv::Mat gray;
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
    std::cout << "Thread " << id << " processed image size: " << gray.size() << std::endl;
}
int main() {
    std::vector<cv::Mat> images = {
        cv::imread("img1.jpg"),
        cv::imread("img2.jpg"),
        cv::imread("img3.jpg")
    };
    std::vector<std::thread> threads;
    for (int i = 0; i < images.size(); ++i) {
        if (!images[i].empty()) {
            threads.emplace_back(processImage, images[i], i);
        }
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <opencv2/cudaimgproc.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("input.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::cuda::GpuMat gpuSrc, gpuGray;
    gpuSrc.upload(src);
    cv::cuda::cvtColor(gpuSrc, gpuGray, cv::COLOR_BGR2GRAY);
    cv::Mat gray;
    gpuGray.download(gray);
    cv::imshow("GPU Grayscale", gray);
    cv::waitKey(0);
    return 0;
}

#include <filesystem>
namespace fs = std::filesystem;
fs::path inputDir = "data";
fs::path fileName = "image.jpg";
fs::path fullPath = inputDir / fileName; // OSに応じて適切に結合される

brew install opencv

#include <cxxopts.hpp>
#include <iostream>
int main(int argc, char* argv[]) {
    cxxopts::Options options("ImageTool", "画像処理自動化ツール");
    options.add_options()
        ("i,input", "入力画像ファイル", cxxopts::value<std::string>())
        ("o,output", "出力画像ファイル", cxxopts::value<std::string>()->default_value("output.jpg"))
        ("h,help", "ヘルプ表示");
    auto result = options.parse(argc, argv);
    if (result.count("help") || !result.count("input")) {
        std::cout << options.help() << std::endl;
        return 0;
    }
    std::string inputFile = result["input"].as<std::string>();
    std::string outputFile = result["output"].as<std::string>();
    std::cout << "入力ファイル: " << inputFile << std::endl;
    std::cout << "出力ファイル: " << outputFile << std::endl;
    // ここに画像処理コードを実装
    return 0;
}

#include <QApplication>
#include <QLabel>
#include <QImage>
#include <opencv2/opencv.hpp>
QImage cvMatToQImage(const cv::Mat& mat) {
    if (mat.type() == CV_8UC3) {
        cv::Mat rgb;
        cv::cvtColor(mat, rgb, cv::COLOR_BGR2RGB);
        return QImage((const unsigned char*)rgb.data, rgb.cols, rgb.rows, rgb.step, QImage::Format_RGB888).copy();
    } else if (mat.type() == CV_8UC1) {
        return QImage((const unsigned char*)mat.data, mat.cols, mat.rows, mat.step, QImage::Format_Grayscale8).copy();
    }
    return QImage();
}
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    cv::Mat image = cv::imread("input.jpg");
    if (image.empty()) return -1;
    QImage qimg = cvMatToQImage(image);
    QLabel label;
    label.setPixmap(QPixmap::fromImage(qimg));
    label.show();
    return app.exec();
}