【C++】OpenCV初心者が最短で画像処理を習得する基本ステップとサンプルコード集

// C API(古いスタイル。最新のOpenCVではおそらく動きません)
IplImage* img = cvLoadImage("sample.jpg", CV_LOAD_IMAGE_COLOR);
cvShowImage("Image", img);
cvReleaseImage(&img);
cvWaitKey(0);

// C++ API(推奨)
cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_COLOR);
cv::imshow("Image", img);
cv::waitKey(0);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像を読み込む
    cv::Mat img1 = cv::imread("sample.jpg", cv::IMREAD_COLOR);
    if (img1.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    // img1をコピー(データは共有される)
    cv::Mat img2 = img1;
    // img2の一部のピクセルを書き換える(この時点でデータが複製される)
    img2(cv::Rect(0, 0, 100, 100)).setTo(cv::Scalar(0, 0, 255)); // 左上100x100を赤に変更
    // 画像を表示
    cv::imshow("Original Image (img1)", img1);
    cv::imshow("Modified Image (img2)", img2);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像をカラーで読み込む
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_COLOR);
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    std::cout << "画像サイズ: " << img.cols << "x" << img.rows << std::endl;
    return 0;
}

画像サイズ: 640x480

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::imshow("Display Window", img);
    cv::waitKey(0); // キー入力待ち(0は無限待機)
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    bool result = cv::imwrite("output.png", img);
    if (result) {
        std::cout << "画像を保存しました。" << std::endl;
    } else {
        std::cerr << "画像の保存に失敗しました。" << std::endl;
    }
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat colorImg = cv::imread("sample.jpg");
    if (colorImg.empty()) return -1;
    cv::Mat grayImg;
    cv::cvtColor(colorImg, grayImg, cv::COLOR_BGR2GRAY);
    cv::imshow("Gray Image", grayImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat resizedImg;
    // 画像サイズを半分に縮小
    cv::resize(img, resizedImg, cv::Size(img.cols / 2, img.rows / 2));
    cv::imshow("Original", img);
    cv::imshow("Resized", resizedImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat nearest, linear, cubic, lanczos;
    cv::resize(img, nearest, cv::Size(), 2.0, 2.0, cv::INTER_NEAREST);
    cv::resize(img, linear, cv::Size(), 2.0, 2.0, cv::INTER_LINEAR);
    cv::resize(img, cubic, cv::Size(), 2.0, 2.0, cv::INTER_CUBIC);
    cv::resize(img, lanczos, cv::Size(), 2.0, 2.0, cv::INTER_LANCZOS4);
    cv::imshow("Nearest", nearest);
    cv::imshow("Linear", linear);
    cv::imshow("Cubic", cubic);
    cv::imshow("Lanczos", lanczos);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    // 左上から幅100、高さ100の領域を切り出す
    cv::Rect roi(0, 0, 100, 100);
    cv::Mat roiImg = img(roi);
    cv::imshow("ROI", roiImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Rect roi(0, 0, 100, 100);
    cv::Mat roiRef = img(roi);          // 参照のみ
    cv::Mat roiClone = roiRef.clone();  // データを複製
    cv::Mat roiCopy;
    roiRef.copyTo(roiCopy);             // データを複製
    // roiRefの一部を赤に変更(元画像も変わる)
    roiRef.setTo(cv::Scalar(0, 0, 255));
    // roiCloneとroiCopyは元画像の変更の影響を受けない
    cv::imshow("Original Image", img);
    cv::imshow("ROI Reference", roiRef);
    cv::imshow("ROI Clone", roiClone);
    cv::imshow("ROI Copy", roiCopy);
    cv::waitKey(0);
    return 0;
}

// 実行結果の説明
// 「Original Image」と「ROI Reference」は赤く塗りつぶされた部分が反映されています。
// 「ROI Clone」と「ROI Copy」は元画像の変更前の状態を保持しています。

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat hsvImg;
    cv::cvtColor(img, hsvImg, cv::COLOR_BGR2HSV);
    cv::imshow("Original", img);
    cv::imshow("HSV", hsvImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    std::vector<cv::Mat> channels;
    cv::split(img, channels); // B, G, Rに分離
    // 例：青チャンネルを強調
    channels[0] = channels[0] + 50;
    cv::Mat merged;
    cv::merge(channels, merged);
    cv::imshow("Original", img);
    cv::imshow("Blue Enhanced", merged);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat hsv;
    cv::cvtColor(img, hsv, cv::COLOR_BGR2HSV);
    // 赤色の範囲(Hueは0〜10と160〜179の2範囲に分かれる)
    cv::Mat mask1, mask2, mask;
    cv::inRange(hsv, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), mask1);
    cv::inRange(hsv, cv::Scalar(160, 100, 100), cv::Scalar(179, 255, 255), mask2);
    cv::bitwise_or(mask1, mask2, mask);
    // 元画像にマスクを適用
    cv::Mat result;
    cv::bitwise_and(img, img, result, mask);
    cv::imshow("Original", img);
    cv::imshow("Red Mask", mask);
    cv::imshow("Extracted Red", result);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat blurred;
    // 5x5のカーネルで平均化フィルタを適用
    cv::blur(img, blurred, cv::Size(5, 5));
    cv::imshow("Original", img);
    cv::imshow("Average Blur", blurred);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat gaussianBlurred;
    // 7x7のカーネル、標準偏差は0(自動計算)
    cv::GaussianBlur(img, gaussianBlurred, cv::Size(7, 7), 0);
    cv::imshow("Original", img);
    cv::imshow("Gaussian Blur", gaussianBlurred);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("noisy_sample.jpg");
    if (img.empty()) return -1;
    cv::Mat medianBlurred;
    // カーネルサイズは奇数(例：5)
    cv::medianBlur(img, medianBlurred, 5);
    cv::imshow("Noisy Image", img);
    cv::imshow("Median Blur", medianBlurred);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat bilateralBlurred;
    // d=9:近傍の直径, sigmaColor=75, sigmaSpace=75
    cv::bilateralFilter(img, bilateralBlurred, 9, 75, 75);
    cv::imshow("Original", img);
    cv::imshow("Bilateral Filter", bilateralBlurred);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat grad_x, grad_y;
    cv::Mat abs_grad_x, abs_grad_y, grad;
    // x方向の勾配(3x3カーネル)
    cv::Sobel(img, grad_x, CV_16S, 1, 0, 3);
    // y方向の勾配(3x3カーネル)
    cv::Sobel(img, grad_y, CV_16S, 0, 1, 3);
    // 絶対値に変換
    cv::convertScaleAbs(grad_x, abs_grad_x);
    cv::convertScaleAbs(grad_y, abs_grad_y);
    // 勾配の合成(重み付け和)
    cv::addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
    cv::imshow("Original", img);
    cv::imshow("Sobel Edge", grad);
    cv::waitKey(0);
    return 0;
}

cv::Scharr(img, grad_x, CV_16S, 1, 0);
cv::Scharr(img, grad_y, CV_16S, 0, 1);

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat edges;
    // 低閾値50、高閾値150でCannyエッジ検出
    cv::Canny(img, edges, 50, 150);
    cv::imshow("Original", img);
    cv::imshow("Canny Edges", edges);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat laplacian, abs_laplacian;
    cv::Laplacian(img, laplacian, CV_16S, 3);
    cv::convertScaleAbs(laplacian, abs_laplacian);
    cv::imshow("Original", img);
    cv::imshow("Laplacian", abs_laplacian);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat edges;
    cv::Canny(img, edges, 50, 150);
    // モルフォロジー膨張でエッジを太くする
    cv::Mat dilated;
    cv::dilate(edges, dilated, cv::Mat(), cv::Point(-1, -1), 1);
    cv::imshow("Canny Edges", edges);
    cv::imshow("Dilated Edges", dilated);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    double thresh = 128; // 閾値
    double maxValue = 255; // 最大値(白)
    // 閾値処理(バイナリ)
    cv::threshold(img, binary, thresh, maxValue, cv::THRESH_BINARY);
    cv::imshow("Original", img);
    cv::imshow("Binary Threshold", binary);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    cv::Mat binary;
    double thresh = cv::threshold(img, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::cout << "大津の方法で決定された閾値: " << thresh << std::endl;
    cv::imshow("Original", img);
    cv::imshow("Otsu Binary", binary);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("uneven_lighting.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat adaptiveBinary;
    // ブロックサイズは奇数、Cは閾値から引く定数
    cv::adaptiveThreshold(img, adaptiveBinary, 255,
                          cv::ADAPTIVE_THRESH_MEAN_C,
                          cv::THRESH_BINARY, 11, 2);
    cv::imshow("Original", img);
    cv::imshow("Adaptive Threshold", adaptiveBinary);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("low_contrast.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat equalized;
    cv::equalizeHist(img, equalized);
    cv::imshow("Original", img);
    cv::imshow("Equalized", equalized);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("shapes.png", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    // 二値化(大津の方法)
    cv::Mat binary;
    cv::threshold(img, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    // 輪郭抽出
    cv::findContours(binary, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
    // 輪郭描画用のカラー画像を作成
    cv::Mat contourImg = cv::Mat::zeros(img.size(), CV_8UC3);
    // 輪郭をランダムな色で描画
    for (size_t i = 0; i < contours.size(); i++) {
        cv::Scalar color(rand() % 256, rand() % 256, rand() % 256);
        cv::drawContours(contourImg, contours, static_cast<int>(i), color, 2, cv::LINE_8, hierarchy, 0);
    }
    cv::imshow("Original", img);
    cv::imshow("Contours", contourImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("shapes.png", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat binary;
    cv::threshold(img, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    for (size_t i = 0; i < contours.size(); i++) {
        double area = cv::contourArea(contours[i]);
        double perimeter = cv::arcLength(contours[i], true);
        std::cout << "Contour " << i << ": 面積 = " << area << ", 周囲長 = " << perimeter << std::endl;
    }
    return 0;
}

Contour 0: 面積 = 0, 周囲長 = 0
Contour 1: 面積 = 0, 周囲長 = 0
Contour 2: 面積 = 0, 周囲長 = 0
Contour 3: 面積 = 0, 周囲長 = 0
Contour 4: 面積 = 0, 周囲長 = 0
Contour 5: 面積 = 0, 周囲長 = 0
Contour 6: 面積 = 0, 周囲長 = 2
Contour 7: 面積 = 0, 周囲長 = 0
Contour 8: 面積 = 0, 周囲長 = 0
Contour 9: 面積 = 372906, 周囲長 = 3018.66

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("shapes.png", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat binary;
    cv::threshold(img, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat approxImg = cv::Mat::zeros(img.size(), CV_8UC3);
    for (size_t i = 0; i < contours.size(); i++) {
        std::vector<cv::Point> approx;
        double epsilon = 0.02 * cv::arcLength(contours[i], true);
        cv::approxPolyDP(contours[i], approx, epsilon, true);
        cv::Scalar color(0, 255, 0);
        cv::polylines(approxImg, approx, true, color, 2);
        std::cout << "Contour " << i << ": 元の点数 = " << contours[i].size()
                  << ", 近似点数 = " << approx.size() << std::endl;
    }
    cv::imshow("Approximated Contours", approxImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("shapes.png");
    if (img.empty()) return -1;
    cv::Mat gray;
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
    cv::Mat binary;
    cv::threshold(gray, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat result = img.clone();
    for (size_t i = 0; i < contours.size(); i++) {
        // 最小外接矩形
        cv::RotatedRect minRect = cv::minAreaRect(contours[i]);
        cv::Point2f rectPoints[4];
        minRect.points(rectPoints);
        for (int j = 0; j < 4; j++) {
            cv::line(result, rectPoints[j], rectPoints[(j + 1) % 4], cv::Scalar(0, 255, 0), 2);
        }
        // 最小外接円
        cv::Point2f center;
        float radius;
        cv::minEnclosingCircle(contours[i], center, radius);
        cv::circle(result, center, static_cast<int>(radius), cv::Scalar(255, 0, 0), 2);
    }
    cv::imshow("Min Area Rect and Enclosing Circle", result);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    double scale_x = 1.5; // 横方向1.5倍
    double scale_y = 1.5; // 縦方向1.5倍
    double translate_x = 50; // 右に50ピクセル移動
    double translate_y = 30; // 下に30ピクセル移動
    cv::Mat M = (cv::Mat_<double>(2, 3) << scale_x, 0, translate_x,
                                           0, scale_y, translate_y);
    cv::Mat transformed;
    cv::warpAffine(img, transformed, M, img.size());
    cv::imshow("Original", img);
    cv::imshow("Scaled and Translated", transformed);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Point2f center(img.cols / 2.0f, img.rows / 2.0f);
    double angle = 45.0; // 45度回転
    double scale = 1.0;  // 拡大縮小なし
    cv::Mat rotMat = cv::getRotationMatrix2D(center, angle, scale);
    cv::Mat rotated;
    cv::warpAffine(img, rotated, rotMat, img.size());
    cv::imshow("Original", img);
    cv::imshow("Rotated", rotated);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    // 元画像の3点
    std::vector<cv::Point2f> srcTri;
    srcTri.push_back(cv::Point2f(0, 0));
    srcTri.push_back(cv::Point2f(img.cols - 1, 0));
    srcTri.push_back(cv::Point2f(0, img.rows - 1));
    // 変換後の3点
    std::vector<cv::Point2f> dstTri;
    dstTri.push_back(cv::Point2f(0, img.rows*0.33f));
    dstTri.push_back(cv::Point2f(img.cols*0.85f, img.rows*0.25f));
    dstTri.push_back(cv::Point2f(img.cols*0.15f, img.rows*0.7f));
    cv::Mat warpMat = cv::getAffineTransform(srcTri, dstTri);
    cv::Mat warped;
    cv::warpAffine(img, warped, warpMat, img.size());
    cv::imshow("Original", img);
    cv::imshow("Affine Transformed", warped);
    cv::waitKey(0);
    return 0;
}

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

// 4点を左上、右上、右下、左下の順に並べ替える関数
std::vector<cv::Point2f> sortPoints(const std::vector<cv::Point>& points) {
    std::vector<cv::Point2f> sorted(4);
    // x + y が最小が左上、最大が右下に近い
    std::vector<int> sumPts;
    for (const auto& p : points) sumPts.push_back(p.x + p.y);
    int minSumIdx = std::distance(
        sumPts.begin(), std::min_element(sumPts.begin(), sumPts.end()));
    int maxSumIdx = std::distance(
        sumPts.begin(), std::max_element(sumPts.begin(), sumPts.end()));
    sorted[0] = points[minSumIdx]; // 左上
    sorted[2] = points[maxSumIdx]; // 右下

    // x - y が最小が左下、最大が右上に近い
    std::vector<int> diffPts;
    for (const auto& p : points) diffPts.push_back(p.x - p.y);
    int minDiffIdx = std::distance(
        diffPts.begin(), std::min_element(diffPts.begin(), diffPts.end()));
    int maxDiffIdx = std::distance(
        diffPts.begin(), std::max_element(diffPts.begin(), diffPts.end()));
    sorted[3] = points[minDiffIdx]; // 左下
    sorted[1] = points[maxDiffIdx]; // 右上
    return sorted;
}

int main() {
    cv::Mat img = cv::imread("document.png");
    if (img.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }

    cv::Mat gray, blur, edges;
    // グレースケール化
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
    // ぼかしでノイズ除去
    cv::GaussianBlur(gray, blur, cv::Size(5, 5), 0);
    // Cannyエッジ検出
    cv::Canny(blur, edges, 75, 200);

    // 輪郭検出
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(edges, contours, cv::RETR_LIST, cv::CHAIN_APPROX_SIMPLE);

    std::vector<cv::Point> approx;
    double maxArea = 0;
    std::vector<cv::Point> pageContour;

    // 最大の4点輪郭を探す
    for (const auto& contour : contours) {
        double area = cv::contourArea(contour);
        if (area < 1000) continue; // 小さい輪郭は無視
        cv::approxPolyDP(contour, approx, 0.02 * cv::arcLength(contour, true),
                         true);
        if (approx.size() == 4 && area > maxArea &&
            cv::isContourConvex(approx)) {
            maxArea = area;
            pageContour = approx;
        }
    }

    if (pageContour.empty()) {
        std::cerr << "用紙の輪郭が検出できませんでした\n";
        return -1;
    }

    // 順番を左上、右上、右下、左下に整列
    std::vector<cv::Point2f> srcPoints = sortPoints(pageContour);

    // 変換後の四隅座標（A4サイズピクセル相当）
    cv::Size outputSize(420, 594);
    std::vector<cv::Point2f> dstPoints{
        cv::Point2f(0, 0), cv::Point2f(outputSize.width - 1, 0),
        cv::Point2f(outputSize.width - 1, outputSize.height - 1),
        cv::Point2f(0, outputSize.height - 1)};

    // 射影変換行列取得
    cv::Mat perspectiveMat = cv::getPerspectiveTransform(srcPoints, dstPoints);

    cv::Mat warped;
    cv::warpPerspective(img, warped, perspectiveMat, outputSize);

    cv::imshow("Original", img);
    cv::imshow("Detected Edges", edges);
    cv::imshow("Warped Document", warped);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::imread("sample.jpg");
    if (img.empty()) return -1;
    cv::Mat map_x(img.size(), CV_32FC1);
    cv::Mat map_y(img.size(), CV_32FC1);
    // 簡単な左右反転マップを作成
    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            map_x.at<float>(y, x) = static_cast<float>(img.cols - x - 1);
            map_y.at<float>(y, x) = static_cast<float>(y);
        }
    }
    cv::Mat warped;
    cv::remap(img, warped, map_x, map_y, cv::INTER_LINEAR);
    cv::imshow("Original", img);
    cv::imshow("Warped (Flip)", warped);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img1 = cv::imread("image1.jpg");
    cv::Mat img2 = cv::imread("image2.jpg");
    if (img1.empty() || img2.empty()) return -1;
    // 画像サイズを合わせる(img2をimg1のサイズにリサイズ)
    cv::resize(img2, img2, img1.size());
    cv::Mat blended;
    double alpha = 0.7; // img1の重み
    double beta = 1.0 - alpha; // img2の重み
    // ブレンド処理
    cv::addWeighted(img1, alpha, img2, beta, 0.0, blended);
    cv::imshow("Image 1", img1);
    cv::imshow("Image 2", img2);
    cv::imshow("Blended", blended);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    std::cout << "チャンネル数: " << img.channels() << std::endl; // 4ならアルファチャンネルあり
    cv::imshow("Transparent PNG", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat background = cv::imread("background.jpg");
    cv::Mat foreground = cv::imread("transparent.png", cv::IMREAD_UNCHANGED);
    if (background.empty() || foreground.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    // 背景画像を前景画像のサイズにリサイズ
    cv::resize(background, background, foreground.size());
    // 前景画像のアルファチャンネルを分離
    std::vector<cv::Mat> channels;
    cv::split(foreground, channels);
    cv::Mat alpha = channels[3]; // アルファチャンネル
    // アルファチャンネルを0〜1の範囲に正規化
    cv::Mat alpha_f;
    alpha.convertTo(alpha_f, CV_32FC1, 1.0 / 255.0);
    // 前景のBGRチャネルをfloat型に変換
    cv::Mat foreground_rgb;
    cv::merge(std::vector<cv::Mat>{channels[0], channels[1], channels[2]}, foreground_rgb);
    foreground_rgb.convertTo(foreground_rgb, CV_32FC3, 1.0 / 255.0);
    // 背景画像をfloat型に変換
    cv::Mat background_f;
    background.convertTo(background_f, CV_32FC3, 1.0 / 255.0);
    // アルファブレンド
    cv::Mat blended = cv::Mat::zeros(foreground.size(), CV_32FC3);
    for (int y = 0; y < blended.rows; y++) {
        for (int x = 0; x < blended.cols; x++) {
            float alpha_val = alpha_f.at<float>(y, x);
            cv::Vec3f fg_pixel = foreground_rgb.at<cv::Vec3f>(y, x);
            cv::Vec3f bg_pixel = background_f.at<cv::Vec3f>(y, x);
            blended.at<cv::Vec3f>(y, x) = fg_pixel * alpha_val + bg_pixel * (1.0f - alpha_val);
        }
    }
    // 表示用に8ビットに変換
    blended.convertTo(blended, CV_8UC3, 255.0);
    cv::imshow("Background", background);
    cv::imshow("Foreground (with alpha)", foreground);
    cv::imshow("Blended Image", blended);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    // 黒い背景の画像を作成
    cv::Mat img = cv::Mat::zeros(400, 600, CV_8UC3);
    // 線を描画(青色、太さ3)
    cv::line(img, cv::Point(50, 50), cv::Point(550, 50), cv::Scalar(255, 0, 0), 3);
    // 円を描画(緑色、太さ-1で塗りつぶし)
    cv::circle(img, cv::Point(300, 150), 50, cv::Scalar(0, 255, 0), -1);
    // 矩形を描画(赤色、太さ2)
    cv::rectangle(img, cv::Point(100, 250), cv::Point(500, 350), cv::Scalar(0, 0, 255), 2);
    // ポリラインを描画(黄色、閉じた多角形、太さ2)
    std::vector<cv::Point> pts = {cv::Point(200, 370), cv::Point(300, 370), cv::Point(350, 390), cv::Point(250, 410)};
    cv::polylines(img, pts, true, cv::Scalar(0, 255, 255), 2);
    cv::imshow("Drawing", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat img = cv::Mat::zeros(200, 600, CV_8UC3);
    std::string text = "OpenCV Text";
    // テキストを描画
    cv::putText(img, text, cv::Point(50, 100), cv::FONT_HERSHEY_SIMPLEX,
                2.0, cv::Scalar(255, 255, 255), 3, cv::LINE_AA);
    cv::imshow("Text", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <opencv2/freetype.hpp>
int main() {
    cv::Mat img = cv::Mat::zeros(200, 600, CV_8UC3);
    // FreeType2オブジェクトの作成
    cv::Ptr<cv::freetype::FreeType2> ft2 = cv::freetype::createFreeType2();
    ft2->loadFontData("C:/Windows/Fonts/msgothic.ttc", 0); // フォントファイルのパス
    std::string text = "こんにちは、OpenCV！";
    // 日本語テキストを描画
    ft2->putText(img, text, cv::Point(50, 100), 40, cv::Scalar(255, 255, 255), -1, cv::LINE_AA, true);
    cv::imshow("Japanese Text", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 動画ファイルのパスを指定してVideoCaptureを作成
    cv::VideoCapture cap("sample_video.mp4");
    if (!cap.isOpened()) {
        std::cerr << "動画ファイルを開けませんでした。" << std::endl;
        return -1;
    }
    cv::Mat frame;
    while (true) {
        // フレームを1枚読み込む
        bool ret = cap.read(frame);
        if (!ret || frame.empty()) break; // 動画終了または読み込み失敗
        cv::imshow("Video Playback", frame);
        // 30ms待機し、キー入力があれば終了
        if (cv::waitKey(30) >= 0) break;
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap("sample_video.mp4");
    if (!cap.isOpened()) {
        std::cerr << "動画ファイルを開けませんでした。" << std::endl;
        return -1;
    }
    int frame_width = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_WIDTH));
    int frame_height = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_HEIGHT));
    double fps = cap.get(cv::CAP_PROP_FPS);
    // 出力ファイル名、コーデック(例：MJPG)、fps、フレームサイズを指定
    cv::VideoWriter writer("output.avi", cv::VideoWriter::fourcc('M','J','P','G'), fps, cv::Size(frame_width, frame_height));
    if (!writer.isOpened()) {
        std::cerr << "動画ファイルの書き込みを開始できませんでした。" << std::endl;
        return -1;
    }
    cv::Mat frame;
    while (true) {
        bool ret = cap.read(frame);
        if (!ret || frame.empty()) break;
        // ここでフレーム処理が可能(例：グレースケール変換など)
        writer.write(frame); // フレームを書き込み
        cv::imshow("Video Playback", frame);
        if (cv::waitKey(30) >= 0) break;
    }
    cap.release();
    writer.release();
    cv::destroyAllWindows();
    return 0;
}

while (true) {
    bool ret = cap.read(frame);
    if (!ret || frame.empty()) break;
    // 例：グレースケール変換
    cv::Mat gray;
    cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
    cv::imshow("Processed Frame", gray);
    if (cv::waitKey(30) >= 0) break;
}

int fps = static_cast<int>(cap.get(cv::CAP_PROP_FPS));
int delay = 1000 / fps; // ミリ秒単位の待機時間
while (true) {
    bool ret = cap.read(frame);
    if (!ret || frame.empty()) break;
    cv::imshow("Video", frame);
    if (cv::waitKey(delay) >= 0) break;
}

#include <chrono>
while (true) {
    auto start = std::chrono::high_resolution_clock::now();
    bool ret = cap.read(frame);
    if (!ret || frame.empty()) break;
    cv::imshow("Video", frame);
    auto end = std::chrono::high_resolution_clock::now();
    int elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    int wait_time = delay - elapsed;
    if (wait_time < 1) wait_time = 1;
    if (cv::waitKey(wait_time) >= 0) break;
}

#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;
    while (true) {
        bool ret = cap.read(frame);
        if (!ret || frame.empty()) {
            std::cerr << "フレームの取得に失敗しました。" << std::endl;
            break;
        }
        // 例：リアルタイムでグレースケール変換
        cv::Mat gray;
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
        cv::imshow("Camera", gray);
        if (cv::waitKey(30) >= 0) break;
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("group_photo.jpg");
    if (img.empty()) {
        std::cerr << "画像が読み込めませんでした。" << std::endl;
        return -1;
    }
    cv::CascadeClassifier face_cascade;
    if (!face_cascade.load("haarcascade_frontalface_default.xml")) {
        std::cerr << "分類器の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat gray;
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
    cv::equalizeHist(gray, gray);
    std::vector<cv::Rect> faces;
    face_cascade.detectMultiScale(gray, 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;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("pedestrians.jpg");
    if (img.empty()) return -1;
    cv::HOGDescriptor hog;
    hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
    std::vector<cv::Rect> detections;
    hog.detectMultiScale(img, detections);
    for (const auto& rect : detections) {
        cv::rectangle(img, rect, cv::Scalar(0, 0, 255), 2);
    }
    cv::imshow("Pedestrian Detection", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("scene.jpg");
    cv::Mat templ = cv::imread("template.jpg");
    if (img.empty() || templ.empty()) return -1;
    cv::Mat result;
    cv::matchTemplate(img, templ, result, cv::TM_CCOEFF_NORMED);
    double minVal, maxVal;
    cv::Point minLoc, maxLoc;
    cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);
    // 類似度が最大の位置に矩形を描画
    cv::rectangle(img, maxLoc, cv::Point(maxLoc.x + templ.cols, maxLoc.y + templ.rows), cv::Scalar(0, 255, 0), 2);
    cv::imshow("Template Matching", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    int stateSize = 4;  // [x, y, vx, vy]
    int measSize = 2;   // [x, y]
    int contrSize = 0;
    cv::KalmanFilter kf(stateSize, measSize, contrSize, CV_32F);
    // 状態遷移行列
    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 state(stateSize, 1, CV_32F);
    cv::Mat measurement(measSize, 1, CV_32F);
    measurement.setTo(cv::Scalar(0));
    // 仮の観測データ(例として直線的に移動)
    for (int i = 0; i < 50; i++) {
        // 予測
        cv::Mat prediction = kf.predict();
        cv::Point predictPt(prediction.at<float>(0), prediction.at<float>(1));
        // 観測値(ノイズ付き)
        measurement.at<float>(0) = i + static_cast<float>(rand() % 5 - 2);
        measurement.at<float>(1) = i + static_cast<float>(rand() % 5 - 2);
        // 更新
        kf.correct(measurement);
        std::cout << "予測位置: (" << predictPt.x << ", " << predictPt.y << "), "
                  << "観測位置: (" << measurement.at<float>(0) << ", " << measurement.at<float>(1) << ")" << std::endl;
    }
    return 0;
}