【C++】OpenCVによる画像処理の基本から高速実装テクニックまで

#include <iostream>
#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img1 = cv::imread("sample.jpg");
    if (img1.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // img1をコピーしてimg2を作成(img2はimg1のコピー)
    cv::Mat img2;
    img1.copyTo(img2);
    // img2の一部を変更してももimg1は変更されない
    img2.at<cv::Vec3b>(0, 0) = cv::Vec3b(0, 0, 255); // 左上のピクセルを赤に変更
    // img1の左上ピクセルの値を表示
    std::cout << "img1(0,0): " << img1.at<cv::Vec3b>(0, 0) << std::endl;
    // img2の左上ピクセルの値を表示
    std::cout << "img2(0,0): " << img2.at<cv::Vec3b>(0, 0) << std::endl;
    return 0;
}

img1(0,0): [B, G, R]  // 元の色(例：[123, 45, 67])
img2(0,0): [0, 0, 255] // 赤に変更された値

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat mat;
    // 3行3列、8ビット3チャンネルの画像を作成
    mat.create(3, 3, CV_8UC3);
    // 全ピクセルを青色に初期化
    mat = cv::Scalar(255, 0, 0); // BGR順なので青
    std::cout << "mat:\n" << mat << std::endl;
    return 0;
}

mat:
[255, 0, 0, 255, 0, 0, 255, 0, 0;
 255, 0, 0, 255, 0, 0, 255, 0, 0;
 255, 0, 0, 255, 0, 0, 255, 0, 0]

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // ROIを矩形で指定(x=50, y=50, 幅=100, 高さ=100)
    cv::Rect roi(50, 50, 100, 100);
    // ROI部分のサブマトリクスを取得(データは共有)
    cv::Mat subImage = image(roi);
    // ROI部分を赤色で塗りつぶす
    subImage = cv::Scalar(0, 0, 255); // BGRで赤
    // 変更は元画像にも反映される
    cv::imshow("Modified Image", image);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    int type = image.type();
    int depth = CV_MAT_DEPTH(type);
    int channels = CV_MAT_CN(type);
    std::cout << "Image depth: " << depth << std::endl;
    std::cout << "Channels: " << channels << std::endl;
    // depthの値の意味を表示
    switch (depth) {
        case CV_8U:  std::cout << "8-bit unsigned integer" << std::endl; break;
        case CV_8S:  std::cout << "8-bit signed integer" << std::endl; break;
        case CV_16U: std::cout << "16-bit unsigned integer" << std::endl; break;
        case CV_16S: std::cout << "16-bit signed integer" << std::endl; break;
        case CV_32S: std::cout << "32-bit signed integer" << std::endl; break;
        case CV_32F: std::cout << "32-bit float" << std::endl; break;
        case CV_64F: std::cout << "64-bit float" << std::endl; break;
        default:     std::cout << "Unknown depth" << std::endl; break;
    }
    return 0;
}

Image depth: 0
Channels: 3
8-bit unsigned integer

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // カラー画像として読み込み
    cv::Mat colorImage = cv::imread("image.png", cv::IMREAD_COLOR);
    if (colorImage.empty()) {
        std::cerr << "カラー画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "カラー画像のサイズ: " << colorImage.cols << "x" << colorImage.rows << std::endl;
    // グレースケール画像として読み込み
    cv::Mat grayImage = cv::imread("image.png", cv::IMREAD_GRAYSCALE);
    if (grayImage.empty()) {
        std::cerr << "グレースケール画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "グレースケール画像のサイズ: " << grayImage.cols << "x" << grayImage.rows << std::endl;
    // アルファチャンネルを含めて読み込み
    cv::Mat unchangedImage = cv::imread("image.png", cv::IMREAD_UNCHANGED);
    if (unchangedImage.empty()) {
        std::cerr << "アルファチャンネル付き画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::cout << "アルファチャンネル付き画像のチャンネル数: " << unchangedImage.channels() << std::endl;
    return 0;
}

カラー画像のサイズ: 640x480
グレースケール画像のサイズ: 640x480
アルファチャンネル付き画像のチャンネル数: 4

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

JPEG画像を品質90で保存しました。

std::vector<int> pngParams = {cv::IMWRITE_PNG_COMPRESSION, 9}; // 最大圧縮
cv::imwrite("output_max_compression.png", image, pngParams);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::imshow("Async Example", image);
    // waitKeyを呼ばないとウィンドウがすぐ閉じてしまう
    // cv::waitKey(0);
    std::cout << "imshowの後にすぐ終了します。" << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::imshow("WaitKey Example", image);
    std::cout << "キーを押してください..." << std::endl;
    int key = cv::waitKey(0); // キー入力を無限に待つ
    std::cout << "押されたキーのコード: " << key << std::endl;
    // 'q'キー(ASCIIコード113)で終了
    if (key == 'q' || key == 'Q') {
        std::cout << "終了します。" << std::endl;
    }
    return 0;
}

キーを押してください...
押されたキーのコード: 113
終了します。

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // リサイズ可能なウィンドウを作成
    cv::namedWindow("Resizable Window", cv::WINDOW_NORMAL);
    // 画像を表示
    cv::imshow("Resizable Window", image);
    // キー入力を待つ
    cv::waitKey(0);
    return 0;
}

cv::resizeWindow("Resizable Window", 800, 600);

cv::moveWindow("Resizable Window", 100, 100);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat colorImage = cv::imread("image.jpg");
    if (colorImage.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat grayImage;
    cv::cvtColor(colorImage, grayImage, cv::COLOR_BGR2GRAY);
    cv::imshow("Original", colorImage);
    cv::imshow("Grayscale", grayImage);
    cv::waitKey(0);
    return 0;
}

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

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat hsvImage;
    cv::cvtColor(image, hsvImage, cv::COLOR_BGR2HSV);
    // 赤色の範囲は色相が0〜10と160〜179の2つに分かれるため2つのマスクを作成
    cv::Mat lowerRedMask, upperRedMask, redMask;
    // 下側の赤色範囲
    cv::inRange(hsvImage, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), lowerRedMask);
    // 上側の赤色範囲
    cv::inRange(hsvImage, cv::Scalar(160, 100, 100), cv::Scalar(179, 255, 255), upperRedMask);
    // 2つのマスクを合成
    cv::bitwise_or(lowerRedMask, upperRedMask, redMask);
    // 元画像とマスクを使って赤色部分だけ抽出
    cv::Mat redRegion;
    cv::bitwise_and(image, image, redRegion, redMask);
    cv::imshow("Original", image);
    cv::imshow("Red Mask", redMask);
    cv::imshow("Red Region", redRegion);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像、赤色マスク、赤色領域が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("image.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<cv::Mat> channels;
    cv::split(image, channels); // channels[0]=Blue, [1]=Green, [2]=Red
    // 青チャンネルを2倍に強調(255を超えないように制限)
    cv::Mat blueEnhanced;
    cv::multiply(channels[0], 2.0, blueEnhanced);
    cv::threshold(blueEnhanced, blueEnhanced, 255, 255, cv::THRESH_TRUNC);
    channels[0] = blueEnhanced;
    cv::Mat mergedImage;
    cv::merge(channels, mergedImage);
    cv::imshow("Original", image);
    cv::imshow("Blue Enhanced", mergedImage);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と青チャンネルが強調された画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat resizedNearest, resizedLinear, resizedLanczos;
    // 2倍にリサイズ(拡大)
    cv::resize(src, resizedNearest, cv::Size(), 2.0, 2.0, cv::INTER_NEAREST);
    cv::resize(src, resizedLinear, cv::Size(), 2.0, 2.0, cv::INTER_LINEAR);
    cv::resize(src, resizedLanczos, cv::Size(), 2.0, 2.0, cv::INTER_LANCZOS4);
    cv::imshow("Original", src);
    cv::imshow("Nearest Neighbor", resizedNearest);
    cv::imshow("Bilinear", resizedLinear);
    cv::imshow("Lanczos", resizedLanczos);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と3種類のリサイズ画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 画像中心座標
    cv::Point2f center(src.cols / 2.0F, src.rows / 2.0F);
    double angle = 45.0;    // 回転角度(度)
    double scale = 1.0;     // 拡大縮小率
    // 回転行列を取得
    cv::Mat rotMat = cv::getRotationMatrix2D(center, angle, scale);
    cv::Mat rotated;
    // アフィン変換を適用
    cv::warpAffine(src, rotated, rotMat, src.size());
    cv::imshow("Original", src);
    cv::imshow("Rotated 45 degrees", rotated);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と45度回転した画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 変換前の4点(例：画像の四隅)
    std::vector<cv::Point2f> srcPoints = {
        cv::Point2f(0, 0),
        cv::Point2f(src.cols - 1, 0),
        cv::Point2f(src.cols - 1, src.rows - 1),
        cv::Point2f(0, src.rows - 1)
    };
    // 変換後の4点(例：台形に変形)
    std::vector<cv::Point2f> dstPoints = {
        cv::Point2f(50, 50),
        cv::Point2f(src.cols - 100, 30),
        cv::Point2f(src.cols - 50, src.rows - 50),
        cv::Point2f(30, src.rows - 30)
    };
    // 透視変換行列を取得
    cv::Mat perspMat = cv::getPerspectiveTransform(srcPoints, dstPoints);
    cv::Mat warped;
    // 透視変換を適用
    cv::warpPerspective(src, warped, perspMat, src.size());
    cv::imshow("Original", src);
    cv::imshow("Perspective Transform", warped);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と透視変換後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat blurred;
    // 5x5の平均フィルタを適用
    cv::blur(src, blurred, cv::Size(5, 5));
    cv::imshow("Original", src);
    cv::imshow("Average Filtered", blurred);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と平均フィルタ適用後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat gaussianBlurred;
    // 5x5カーネル、標準偏差0(自動計算)
    cv::GaussianBlur(src, gaussianBlurred, cv::Size(5, 5), 0);
    cv::imshow("Original", src);
    cv::imshow("Gaussian Filtered", gaussianBlurred);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像とガウシアンフィルタ適用後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat noisyImage = cv::imread("salt_pepper_noise.jpg");
    if (noisyImage.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat medianFiltered;
    // カーネルサイズは奇数(例：5)
    cv::medianBlur(noisyImage, medianFiltered, 5);
    cv::imshow("Noisy Image", noisyImage);
    cv::imshow("Median Filtered", medianFiltered);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに塩胡椒ノイズ画像とメディアンフィルタ適用後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.jpg");
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat bilateralFiltered;
    // d:近傍直径, sigmaColor:色空間の標準偏差, sigmaSpace:座標空間の標準偏差
    cv::bilateralFilter(src, bilateralFiltered, 9, 75, 75);
    cv::imshow("Original", src);
    cv::imshow("Bilateral Filtered", bilateralFiltered);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像と双方向フィルタ適用後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat edges;
    double lowThreshold = 50;
    double highThreshold = 150;
    int apertureSize = 3;
    bool L2gradient = false;
    cv::Canny(src, edges, lowThreshold, highThreshold, apertureSize, L2gradient);
    cv::imshow("Original", src);
    cv::imshow("Canny Edges", edges);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像とCannyエッジ検出結果が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat blurred, laplacian;
    cv::GaussianBlur(src, blurred, cv::Size(3, 3), 0);
    cv::Laplacian(blurred, laplacian, CV_16S, 3);
    cv::Mat absLaplacian;
    cv::convertScaleAbs(laplacian, absLaplacian);
    cv::imshow("Original", src);
    cv::imshow("Laplacian", absLaplacian);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像とLaplacianエッジ画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
#include <cmath>
int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat gradX, gradY;
    cv::Sobel(src, gradX, CV_16S, 1, 0, 3);
    cv::Sobel(src, gradY, CV_16S, 0, 1, 3);
    cv::Mat absGradX, absGradY;
    cv::convertScaleAbs(gradX, absGradX);
    cv::convertScaleAbs(gradY, absGradY);
    cv::Mat grad;
    cv::addWeighted(absGradX, 0.5, absGradY, 0.5, 0, grad);
    cv::imshow("Original", src);
    cv::imshow("Sobel Gradient", grad);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元画像とSobel勾配画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("person.jpg", cv::IMREAD_GRAYSCALE);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // HOGDescriptorの初期化(デフォルトパラメータ)
    cv::HOGDescriptor hog;
    // HOG特徴量を格納するベクトル
    std::vector<float> descriptors;
    // 画像サイズをHOGDescriptorのウィンドウサイズに合わせる必要がある場合がある
    cv::resize(image, image, hog.winSize);
    // HOG特徴量を計算
    hog.compute(image, descriptors);
    std::cout << "HOG特徴量の次元数: " << descriptors.size() << std::endl;
    return 0;
}

HOG特徴量の次元数: 3780

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("binary_image.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 二値化(閾値処理)
    cv::Mat binary;
    cv::threshold(src, binary, 128, 255, cv::THRESH_BINARY);
    // 3x3の正方形カーネルを作成
    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
    cv::Mat dilated, eroded;
    cv::dilate(binary, dilated, kernel);
    cv::erode(binary, eroded, kernel);
    cv::imshow("Original Binary", binary);
    cv::imshow("Dilated", dilated);
    cv::imshow("Eroded", eroded);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元の二値画像、膨張処理後、収縮処理後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_binary.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    cv::threshold(src, binary, 128, 255, cv::THRESH_BINARY);
    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5));
    cv::Mat opened, closed;
    cv::morphologyEx(binary, opened, cv::MORPH_OPEN, kernel);
    cv::morphologyEx(binary, closed, cv::MORPH_CLOSE, kernel);
    cv::imshow("Original Binary", binary);
    cv::imshow("Opened", opened);
    cv::imshow("Closed", closed);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元の二値画像、オープニング処理後、クロージング処理後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("binary_shape.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    cv::threshold(src, binary, 128, 255, cv::THRESH_BINARY);
    cv::Mat dist;
    cv::distanceTransform(binary, dist, cv::DIST_L2, 3);
    // 距離画像を可視化のために正規化
    cv::Mat distNormalized;
    cv::normalize(dist, distNormalized, 0, 1.0, cv::NORM_MINMAX);
    cv::imshow("Original Binary", binary);
    cv::imshow("Distance Transform", distNormalized);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに元の二値画像と距離変換結果の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
void thinningIteration(cv::Mat& img, int iter) {
    cv::Mat marker = cv::Mat::zeros(img.size(), CV_8UC1);
    for (int i = 1; i < img.rows - 1; i++) {
        for (int j = 1; j < img.cols - 1; j++) {
            uchar p2 = img.at<uchar>(i - 1, j);
            uchar p3 = img.at<uchar>(i - 1, j + 1);
            uchar p4 = img.at<uchar>(i, j + 1);
            uchar p5 = img.at<uchar>(i + 1, j + 1);
            uchar p6 = img.at<uchar>(i + 1, j);
            uchar p7 = img.at<uchar>(i + 1, j - 1);
            uchar p8 = img.at<uchar>(i, j - 1);
            uchar p9 = img.at<uchar>(i - 1, j - 1);
            int A = (p2 == 0 && p3 == 1) + (p3 == 0 && p4 == 1) +
                    (p4 == 0 && p5 == 1) + (p5 == 0 && p6 == 1) +
                    (p6 == 0 && p7 == 1) + (p7 == 0 && p8 == 1) +
                    (p8 == 0 && p9 == 1) + (p9 == 0 && p2 == 1);
            int B = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9;
            int m1 = (iter == 0) ? (p2 * p4 * p6) : (p2 * p4 * p8);
            int m2 = (iter == 0) ? (p4 * p6 * p8) : (p2 * p6 * p8);
            if (A == 1 && (B >= 2 && B <= 6) && m1 == 0 && m2 == 0)
                marker.at<uchar>(i, j) = 1;
        }
    }
    img &= ~marker;
}
void thinning(cv::Mat& img) {
    img /= 255;
    cv::Mat prev = cv::Mat::zeros(img.size(), CV_8UC1);
    cv::Mat diff;
    do {
        thinningIteration(img, 0);
        thinningIteration(img, 1);
        cv::absdiff(img, prev, diff);
        img.copyTo(prev);
    } while (cv::countNonZero(diff) > 0);
    img *= 255;
}
int main() {
    cv::Mat src = cv::imread("binary_shape.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    cv::threshold(src, binary, 128, 255, cv::THRESH_BINARY);
    thinning(binary);
    cv::imshow("Skeleton", binary);
    cv::waitKey(0);
    return 0;
}

(ウィンドウにスケルトン化された細線画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat img2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    if (img1.empty() || img2.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // ORB検出器の作成
    cv::Ptr<cv::ORB> orb = cv::ORB::create();
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;
    orb->detectAndCompute(img1, cv::noArray(), keypoints1, descriptors1);
    orb->detectAndCompute(img2, cv::noArray(), keypoints2, descriptors2);
    // Brute-Force Matcher (Hamming距離)
    cv::BFMatcher bfMatcher(cv::NORM_HAMMING);
    std::vector<cv::DMatch> bfMatches;
    bfMatcher.match(descriptors1, descriptors2, bfMatches);
    // FLANN Matcherの設定(バイナリ記述子用)
    cv::Ptr<cv::DescriptorMatcher> flannMatcher = cv::DescriptorMatcher::create(cv::DescriptorMatcher::FLANNBASED);
    std::vector<cv::DMatch> flannMatches;
    // FLANNはバイナリ記述子に直接使えないため、float型に変換が必要
    cv::Mat descriptors1_float, descriptors2_float;
    descriptors1.convertTo(descriptors1_float, CV_32F);
    descriptors2.convertTo(descriptors2_float, CV_32F);
    flannMatcher->match(descriptors1_float, descriptors2_float, flannMatches);
    // マッチ結果を描画
    cv::Mat imgMatchesBF, imgMatchesFLANN;
    cv::drawMatches(img1, keypoints1, img2, keypoints2, bfMatches, imgMatchesBF);
    cv::drawMatches(img1, keypoints1, img2, keypoints2, flannMatches, imgMatchesFLANN);
    cv::imshow("BFMatcher Matches", imgMatchesBF);
    cv::imshow("FLANN Matcher Matches", imgMatchesFLANN);
    cv::waitKey(0);
    return 0;
}

(ウィンドウにBFMatcherとFLANN Matcherのマッチング結果が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat img2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    if (img1.empty() || img2.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Ptr<cv::ORB> orb = cv::ORB::create();
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;
    orb->detectAndCompute(img1, cv::noArray(), keypoints1, descriptors1);
    orb->detectAndCompute(img2, cv::noArray(), keypoints2, descriptors2);
    cv::BFMatcher bfMatcher(cv::NORM_HAMMING);
    std::vector<cv::DMatch> matches;
    bfMatcher.match(descriptors1, descriptors2, matches);
    // マッチから対応点を抽出
    std::vector<cv::Point2f> points1, points2;
    for (const auto& match : matches) {
        points1.push_back(keypoints1[match.queryIdx].pt);
        points2.push_back(keypoints2[match.trainIdx].pt);
    }
    // RANSACでホモグラフィ行列を推定し、外れ値を除去
    std::vector<uchar> inliersMask(points1.size());
    cv::Mat homography = cv::findHomography(points1, points2, cv::RANSAC, 3.0, inliersMask);
    // インライアのみ抽出
    std::vector<cv::DMatch> inlierMatches;
    for (size_t i = 0; i < matches.size(); i++) {
        if (inliersMask[i]) {
            inlierMatches.push_back(matches[i]);
        }
    }
    cv::Mat imgInliers;
    cv::drawMatches(img1, keypoints1, img2, keypoints2, inlierMatches, imgInliers);
    cv::imshow("Inlier Matches after RANSAC", imgInliers);
    cv::waitKey(0);
    return 0;
}

(ウィンドウにRANSACで外れ値除去後のマッチング結果が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("checkerboard.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // チェッカーボードの内側コーナー数(列×行)
    cv::Size patternSize(9, 6);
    std::vector<cv::Point2f> corners;
    bool found = cv::findChessboardCorners(image, patternSize, corners,
                                           cv::CALIB_CB_ADAPTIVE_THRESH | cv::CALIB_CB_NORMALIZE_IMAGE);
    if (found) {
        // コーナーのサブピクセル精度化
        cv::Mat gray;
        cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
        cv::cornerSubPix(gray, corners, cv::Size(11, 11), cv::Size(-1, -1),
                         cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::MAX_ITER, 30, 0.1));
        // 検出したコーナーを描画
        cv::drawChessboardCorners(image, patternSize, corners, found);
        cv::imshow("Detected Corners", image);
        cv::waitKey(0);
    } else {
        std::cerr << "チェッカーボードのコーナーが検出できませんでした。" << std::endl;
    }
    return 0;
}

(ウィンドウにチェッカーボードのコーナーが赤い点で描画された画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
int main() {
    // チェッカーボードの内側コーナー数
    cv::Size patternSize(9, 6);
    float squareSize = 25.0f; // 正方形の一辺の長さ(mmなど)
    // 3Dのチェッカーボードのコーナー座標(Z=0の平面)
    std::vector<cv::Point3f> objectCorners;
    for (int i = 0; i < patternSize.height; i++) {
        for (int j = 0; j < patternSize.width; j++) {
            objectCorners.emplace_back(j * squareSize, i * squareSize, 0);
        }
    }
    std::vector<std::vector<cv::Point3f>> objectPoints; // 3D点群(複数画像分)
    std::vector<std::vector<cv::Point2f>> imagePoints;  // 2D画像点群
    std::vector<std::string> imageFiles = {
        "calib1.jpg", "calib2.jpg", "calib3.jpg", // キャリブレーション画像のパス
        // ... 必要な枚数を追加
    };
    for (const auto& file : imageFiles) {
        cv::Mat image = cv::imread(file);
        if (image.empty()) {
            std::cerr << "画像の読み込みに失敗しました: " << file << std::endl;
            continue;
        }
        std::vector<cv::Point2f> corners;
        bool found = cv::findChessboardCorners(image, patternSize, corners);
        if (found) {
            cv::Mat gray;
            cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
            cv::cornerSubPix(gray, corners, cv::Size(11, 11), cv::Size(-1, -1),
                             cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::MAX_ITER, 30, 0.1));
            imagePoints.push_back(corners);
            objectPoints.push_back(objectCorners);
            cv::drawChessboardCorners(image, patternSize, corners, found);
            cv::imshow("Calibration", image);
            cv::waitKey(100);
        } else {
            std::cerr << "チェッカーボードのコーナーが検出できませんでした: " << file << std::endl;
        }
    }
    cv::destroyAllWindows();
    cv::Mat cameraMatrix, distCoeffs;
    std::vector<cv::Mat> rvecs, tvecs;
    // キャリブレーション実行
    double rms = cv::calibrateCamera(objectPoints, imagePoints, cv::Size(640, 480),
                                     cameraMatrix, distCoeffs, rvecs, tvecs);
    std::cout << "キャリブレーション完了 RMS誤差: " << rms << std::endl;
    std::cout << "カメラ行列:\n" << cameraMatrix << std::endl;
    std::cout << "歪み係数:\n" << distCoeffs << std::endl;
    return 0;
}

キャリブレーション完了 RMS誤差: 0.25
カメラ行列:
[fx,  0, cx;
  0, fy, cy;
  0,  0,  1]
歪み係数:
[k1, k2, p1, p2, k3]

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 事前にキャリブレーションで得たパラメータを設定
    cv::Mat cameraMatrix = (cv::Mat_<double>(3, 3) << 800, 0, 320,
                                                      0, 800, 240,
                                                      0, 0, 1);
    cv::Mat distCoeffs = (cv::Mat_<double>(1, 5) << -0.2, 0.1, 0, 0, 0);
    cv::Mat distorted = cv::imread("distorted.jpg");
    if (distorted.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat map1, map2;
    cv::Size imageSize = distorted.size();
    // 補正用マップを作成
    cv::initUndistortRectifyMap(cameraMatrix, distCoeffs, cv::Mat(),
                                cameraMatrix, imageSize, CV_16SC2, map1, map2);
    cv::Mat undistorted;
    // リマップして歪み補正
    cv::remap(distorted, undistorted, map1, map2, cv::INTER_LINEAR);
    cv::imshow("Distorted Image", distorted);
    cv::imshow("Undistorted Image", undistorted);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに歪んだ画像と補正後の画像が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap(0); // カメラを開く
    if (!cap.isOpened()) {
        std::cerr << "カメラが開けません" << std::endl;
        return -1;
    }
    cv::Ptr<cv::BackgroundSubtractor> pBackSub = cv::createBackgroundSubtractorMOG2();
    cv::Mat frame, fgMask;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        // 背景差分を計算し前景マスクを取得
        pBackSub->apply(frame, fgMask);
        // ノイズ除去のためにモルフォロジー処理(膨張)
        cv::dilate(fgMask, fgMask, cv::Mat(), cv::Point(-1, -1), 2);
        cv::imshow("Frame", frame);
        cv::imshow("Foreground Mask", fgMask);
        if (cv::waitKey(30) >= 0) break;
    }
    return 0;
}

(カメラ映像と動体部分が白く抽出された前景マスクが表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "カメラが開けません" << std::endl;
        return -1;
    }
    cv::Mat prevFrame, prevGray;
    cap >> prevFrame;
    cv::cvtColor(prevFrame, prevGray, cv::COLOR_BGR2GRAY);
    // 特徴点を検出
    std::vector<cv::Point2f> prevPoints;
    cv::goodFeaturesToTrack(prevGray, prevPoints, 100, 0.3, 7);
    while (true) {
        cv::Mat frame, gray;
        cap >> frame;
        if (frame.empty()) break;
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
        std::vector<cv::Point2f> nextPoints;
        std::vector<uchar> status;
        std::vector<float> err;
        // オプティカルフローを計算
        cv::calcOpticalFlowPyrLK(prevGray, gray, prevPoints, nextPoints, status, err);
        // 動きを線と円で描画
        for (size_t i = 0; i < nextPoints.size(); i++) {
            if (status[i]) {
                cv::line(frame, prevPoints[i], nextPoints[i], cv::Scalar(0, 255, 0), 2);
                cv::circle(frame, nextPoints[i], 5, cv::Scalar(0, 0, 255), -1);
            }
        }
        cv::imshow("Optical Flow", frame);
        prevGray = gray.clone();
        prevPoints = nextPoints;
        if (cv::waitKey(30) >= 0) break;
    }
    return 0;
}

(カメラ映像上に特徴点の動きが緑の線と赤い円で表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // Kalmanフィルタの初期化(状態：位置と速度)
    cv::KalmanFilter kf(4, 2, 0);
    kf.transitionMatrix = (cv::Mat_<float>(4, 4) <<
        1, 0, 1, 0,
        0, 1, 0, 1,
        0, 0, 1, 0,
        0, 0, 0, 1);
    cv::setIdentity(kf.measurementMatrix);
    cv::setIdentity(kf.processNoiseCov, cv::Scalar::all(1e-4));
    cv::setIdentity(kf.measurementNoiseCov, cv::Scalar::all(1e-1));
    cv::setIdentity(kf.errorCovPost, cv::Scalar::all(1));
    cv::Mat measurement(2, 1, CV_32F);
    measurement.setTo(cv::Scalar(0));
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "カメラが開けません" << std::endl;
        return -1;
    }
    cv::Mat frame;
    bool initialized = false;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;
        // ここでは単純に赤い物体の重心を検出する例(実際は物体検出器を使う)
        cv::Mat hsv, mask;
        cv::cvtColor(frame, hsv, cv::COLOR_BGR2HSV);
        cv::inRange(hsv, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), mask);
        std::vector<std::vector<cv::Point>> contours;
        cv::findContours(mask, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
        if (!contours.empty()) {
            // 最大輪郭の重心を計算
            size_t maxIdx = 0;
            double maxArea = 0;
            for (size_t i = 0; i < contours.size(); i++) {
                double area = cv::contourArea(contours[i]);
                if (area > maxArea) {
                    maxArea = area;
                    maxIdx = i;
                }
            }
            cv::Moments m = cv::moments(contours[maxIdx]);
            cv::Point2f center(m.m10 / m.m00, m.m01 / m.m00);
            measurement.at<float>(0) = center.x;
            measurement.at<float>(1) = center.y;
            if (!initialized) {
                // 初期状態設定
                kf.statePost.at<float>(0) = center.x;
                kf.statePost.at<float>(1) = center.y;
                kf.statePost.at<float>(2) = 0;
                kf.statePost.at<float>(3) = 0;
                initialized = true;
            } else {
                // Kalmanフィルタ更新
                kf.correct(measurement);
            }
        }
        // 状態予測
        cv::Mat prediction = kf.predict();
        cv::Point2f predictPt(prediction.at<float>(0), prediction.at<float>(1));
        // 予測位置を描画
        cv::circle(frame, predictPt, 10, cv::Scalar(255, 0, 0), 2);
        cv::imshow("Tracking", frame);
        if (cv::waitKey(30) >= 0) break;
    }
    return 0;
}

(カメラ映像上に青い円で予測位置が表示される)

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("group_photo.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // Haar分類器の読み込み(OpenCV付属の顔検出用XML)
    cv::CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        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 <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("pedestrians.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::HOGDescriptor hog;
    hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
    std::vector<cv::Rect> detections;
    std::vector<double> weights;
    // 歩行者検出
    hog.detectMultiScale(image, detections, weights);
    // 検出結果を描画
    for (size_t i = 0; i < detections.size(); i++) {
        cv::rectangle(image, detections[i], cv::Scalar(0, 0, 255), 2);
        std::string score = cv::format("%.2f", weights[i]);
        cv::putText(image, score, detections[i].tl(), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(255, 0, 0), 1);
    }
    cv::imshow("Pedestrian Detection", image);
    cv::waitKey(0);
    return 0;
}

(ウィンドウに歩行者が赤い矩形で囲まれ、信頼度スコアが表示される)

#include <opencv2/opencv.hpp>
#include <opencv2/dnn.hpp>
#include <iostream>
#include <fstream>
int main() {
    // モデルの構成ファイルと重みファイルのパス
    std::string modelConfiguration = "yolov3.cfg";
    std::string modelWeights = "yolov3.weights";
    std::string classesFile = "coco.names";
    // クラス名の読み込み
    std::vector<std::string> classes;
    std::ifstream ifs(classesFile.c_str());
    std::string line;
    while (std::getline(ifs, line)) classes.push_back(line);
    // ネットワークの読み込み
    cv::dnn::Net net = cv::dnn::readNetFromDarknet(modelConfiguration, modelWeights);
    net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
    cv::Mat image = cv::imread("street.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 入力画像の前処理
    cv::Mat blob;
    cv::dnn::blobFromImage(image, blob, 1/255.0, cv::Size(416, 416), cv::Scalar(), true, false);
    net.setInput(blob);
    // 出力レイヤー名の取得
    std::vector<cv::String> outNames = net.getUnconnectedOutLayersNames();
    std::vector<cv::Mat> outs;
    // 推論実行
    net.forward(outs, outNames);
    float confThreshold = 0.5;
    float nmsThreshold = 0.4;
    std::vector<int> classIds;
    std::vector<float> confidences;
    std::vector<cv::Rect> boxes;
    int width = image.cols;
    int height = image.rows;
    // 出力結果の解析
    for (size_t i = 0; i < outs.size(); ++i) {
        float* data = (float*)outs[i].data;
        for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols) {
            cv::Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
            cv::Point classIdPoint;
            double confidence;
            cv::minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
            if (confidence > confThreshold) {
                int centerX = (int)(data[0] * width);
                int centerY = (int)(data[1] * height);
                int boxWidth = (int)(data[2] * width);
                int boxHeight = (int)(data[3] * height);
                int left = centerX - boxWidth / 2;
                int top = centerY - boxHeight / 2;
                classIds.push_back(classIdPoint.x);
                confidences.push_back((float)confidence);
                boxes.push_back(cv::Rect(left, top, boxWidth, boxHeight));
            }
        }
    }
    // 非最大抑制で重複検出を削減
    std::vector<int> indices;
    cv::dnn::NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
    for (int idx : indices) {
        cv::Rect box = boxes[idx];
        cv::rectangle(image, box, cv::Scalar(0, 255, 0), 2);
        std::string label = cv::format("%.2f", confidences[idx]);
        if (!classes.empty()) {
            label = classes[classIds[idx]] + ": " + label;
        }
        int baseLine;
        cv::Size labelSize = cv::getTextSize(label, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
        int top = std::max(box.y, labelSize.height);
        cv::rectangle(image, cv::Point(box.x, top - labelSize.height),
                      cv::Point(box.x + labelSize.width, top + baseLine), cv::Scalar::all(255), cv::FILLED);
        cv::putText(image, label, cv::Point(box.x, top), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar());
    }
    cv::imshow("YOLO Object Detection", image);
    cv::waitKey(0);
    return 0;
}