【C++】OpenCVチュートリアル: 基本操作とサンプルで実践する画像処理

cv::Vec3b pixel = image.at<cv::Vec3b>(y, x);

cv::Rect roi(50, 50, 100, 100);
cv::Mat subImage = image(roi);

cv::Vec3b pixel = image.at<cv::Vec3b>(y, x);

uchar grayPixel = image.at<uchar>(y, x);

cv::Vec3b* rowPtr = image.ptr<cv::Vec3b>(y);
cv::Vec3b pixel = rowPtr[x];

cv::Rect roi(50, 50, 100, 100); // x=50, y=50から幅100、高さ100の範囲
cv::Mat subImage = image(roi);

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像ファイルのパスを指定
    std::string filename = "sample.jpg";
    // 画像を読み込み
    cv::Mat image = cv::imread(filename);
    // 画像の読み込みに失敗した場合の処理
    if (image.empty()) {
        std::cout << "画像の読み込みに失敗しました: " << filename << std::endl;
        return -1;
    }
    // 画像の表示
    cv::imshow("読み込んだ画像", image);
    cv::waitKey(0);
    return 0;
}

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

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

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    cv::Mat image = cv::imread("sample.jpg");
    if (image.empty()) {
        return -1;
    }
    // JPEGの品質を設定(0〜100)
    std::vector<int> params;
    params.push_back(cv::IMWRITE_JPEG_QUALITY);
    params.push_back(90); // 高品質
    // 画像を保存
    cv::imwrite("compressed.jpg", image, params);
    return 0;
}

// PNGの圧縮レベル(0〜9)
params.clear();
params.push_back(cv::IMWRITE_PNG_COMPRESSION);
params.push_back(3); // 中程度の圧縮
cv::imwrite("compressed.png", image, params);

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("sample.jpg");
    if (image.empty()) {
        return -1;
    }
    std::vector<uchar> buffer; // メモリバッファ
    std::vector<int> params;
    params.push_back(cv::IMWRITE_JPEG_QUALITY);
    params.push_back(80); // 80%の品質
    // 画像をJPEG形式にエンコード
    bool success = cv::imencode(".jpg", image, buffer, params);
    if (success) {
        std::cout << "画像をメモリ内にエンコードしました。" << std::endl;
    }
    // バッファから画像にデコード
    cv::Mat decodedImage = cv::imdecode(buffer, cv::IMREAD_COLOR);
    if (decodedImage.empty()) {
        std::cout << "デコードに失敗しました。" << std::endl;
        return -1;
    }
    cv::imshow("デコードされた画像", decodedImage);
    cv::waitKey(0);
    return 0;
}

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

cv::waitKey(0);

int key = cv::waitKey(0);
if (key == 'q') {
    // qキーが押された場合の処理
}

#include <opencv2/opencv.hpp>
int main() {
    cv::namedWindow("画像", cv::WINDOW_AUTOSIZE);
    cv::Mat image = cv::imread("sample.jpg");
    if (image.empty()) {
        return -1;
    }
    cv::imshow("画像", image);
    // ウィンドウを画面の左上座標(100, 50)に移動
    cv::moveWindow("画像", 100, 50);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::namedWindow("画像", cv::WINDOW_NORMAL);
    cv::Mat image = cv::imread("sample.jpg");
    if (image.empty()) {
        return -1;
    }
    cv::imshow("画像", image);
    // ウィンドウのサイズを幅800、高さ600に変更
    cv::resizeWindow("画像", 800, 600);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img1 = cv::imread("image1.jpg");
    cv::Mat img2 = cv::imread("image2.jpg");
    if (img1.empty() || img2.empty()) {
        return -1;
    }
    cv::Mat resultAdd, resultSub;
    // 画像の加算
    cv::add(img1, img2, resultAdd);
    // 画像の減算
    cv::subtract(img1, img2, resultSub);
    cv::imshow("加算結果", resultAdd);
    cv::imshow("減算結果", resultSub);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img1 = cv::imread("image1.jpg");
    cv::Mat img2 = cv::imread("image2.jpg");
    if (img1.empty() || img2.empty()) {
        return -1;
    }
    cv::Mat blended;
    // 画像の重み付け合成
    double alpha = 0.7; // img1の重み
    double beta = 0.3;  // img2の重み
    double gamma = 0.0; // 輝度の付加値
    cv::addWeighted(img1, alpha, img2, beta, gamma, blended);
    cv::imshow("ブレンド画像", blended);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img1 = cv::imread("mask1.png", cv::IMREAD_GRAYSCALE);
    cv::Mat img2 = cv::imread("mask2.png", cv::IMREAD_GRAYSCALE);
    if (img1.empty() || img2.empty()) {
        return -1;
    }
    cv::Mat andResult, orResult, xorResult, notResult;
    // AND演算
    cv::bitwise_and(img1, img2, andResult);
    // OR演算
    cv::bitwise_or(img1, img2, orResult);
    // XOR演算
    cv::bitwise_xor(img1, img2, xorResult);
    // NOT演算(img1の反転)
    cv::bitwise_not(img1, notResult);
    cv::imshow("AND結果", andResult);
    cv::imshow("OR結果", orResult);
    cv::imshow("XOR結果", xorResult);
    cv::imshow("NOT結果", notResult);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像の読み込み(カラー画像)
    cv::Mat colorImage = cv::imread("sample.jpg");
    if (colorImage.empty()) {
        return -1;
    }
    // BGRからグレースケールへ変換
    cv::Mat grayImage;
    cv::cvtColor(colorImage, grayImage, cv::COLOR_BGR2GRAY);
    // 表示
    cv::imshow("カラー画像", colorImage);
    cv::imshow("グレースケール画像", grayImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat bgrImage = cv::imread("sample.jpg");
    if (bgrImage.empty()) {
        return -1;
    }
    // BGRからHSVへ変換
    cv::Mat hsvImage;
    cv::cvtColor(bgrImage, hsvImage, cv::COLOR_BGR2HSV);
    // BGRからHLSへ変換
    cv::Mat hlsImage;
    cv::cvtColor(bgrImage, hlsImage, cv::COLOR_BGR2HLS);
    // 表示
    cv::imshow("BGR画像", bgrImage);
    cv::imshow("HSV画像", hsvImage);
    cv::imshow("HLS画像", hlsImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // グレースケール画像の読み込み
    cv::Mat grayImage = cv::imread("gray_sample.jpg", cv::IMREAD_GRAYSCALE);
    if (grayImage.empty()) {
        return -1;
    }
    // カラーマップの適用(例：JETマップ)
    cv::Mat colorMappedImage;
    cv::applyColorMap(grayImage, colorMappedImage, cv::COLORMAP_JET);
    // 表示
    cv::imshow("グレースケール画像", grayImage);
    cv::imshow("カラーマップ適用後", colorMappedImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg");
    if (src.empty()) {
        return -1;
    }
    cv::Mat dst;
    // 画像を縦横ともに2倍に拡大
    cv::resize(src, dst, cv::Size(), 2.0, 2.0, cv::INTER_LINEAR);
    // 画像を幅300、高さ200にリサイズ
    cv::resize(src, dst, cv::Size(300, 200), 0, 0, cv::INTER_AREA);
    cv::imshow("リサイズ後(拡大)", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg");
    if (src.empty()) {
        return -1;
    }
    // 変換前の3点
    std::vector<cv::Point2f> srcTri = {
        cv::Point2f(0, 0),
        cv::Point2f(src.cols - 1, 0),
        cv::Point2f(0, src.rows - 1)
    };
    // 変換後の3点(例：右下にシフト)
    std::vector<cv::Point2f> dstTri = {
        cv::Point2f(50, 50),
        cv::Point2f(src.cols - 50, 50),
        cv::Point2f(50, src.rows - 50)
    };
    // アフィン変換行列の計算
    cv::Mat affineMat = cv::getAffineTransform(srcTri, dstTri);
    // 変換の適用
    cv::Mat dst;
    cv::warpAffine(src, dst, affineMat, src.size());
    cv::imshow("アフィン変換結果", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg");
    if (src.empty()) {
        return -1;
    }
    // 変換前の4点
    std::vector<cv::Point2f> srcQuad = {
        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> dstQuad = {
        cv::Point2f(50, 50),
        cv::Point2f(src.cols - 50, 30),
        cv::Point2f(src.cols - 30, src.rows - 50),
        cv::Point2f(70, src.rows - 30)
    };
    // 透視変換行列の計算
    cv::Mat perspectiveMat = cv::getPerspectiveTransform(srcQuad, dstQuad);
    // 変換の適用
    cv::Mat dst;
    cv::warpPerspective(src, dst, perspectiveMat, src.size());
    cv::imshow("透視変換結果", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg");
    if (src.empty()) {
        return -1;
    }
    // 回転中心と角度
    cv::Point2f center(src.cols / 2.0F, src.rows / 2.0F);
    double angle = 45.0; // 45度回転
    double scale = 1.0;  // 拡大縮小倍率
    // 回転行列の取得
    cv::Mat rotMat = cv::getRotationMatrix2D(center, angle, scale);
    // 変換の適用
    cv::Mat dst;
    cv::warpAffine(src, dst, rotMat, src.size());
    cv::imshow("回転結果", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.jpg");
    if (src.empty()) {
        return -1;
    }
    cv::Mat dst;
    // 3x3の平均化フィルタを適用
    cv::blur(src, dst, cv::Size(3, 3));
    cv::imshow("平均化フィルタ後", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.jpg");
    if (src.empty()) {
        return -1;
    }
    cv::Mat dst;
    // 5x5のガウシアンカーネルを適用
    cv::GaussianBlur(src, dst, cv::Size(5, 5), 1.5);
    cv::imshow("ガウシアンフィルタ後", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("salt_and_pepper_noise.jpg");
    if (src.empty()) {
        return -1;
    }
    cv::Mat dst;
    // 3x3のメディアンフィルタを適用
    cv::medianBlur(src, dst, 3);
    cv::imshow("メディアンフィルタ後", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("photo.jpg");
    if (src.empty()) {
        return -1;
    }
    cv::Mat dst;
    // パラメータ：d=9, sigmaColor=75, sigmaSpace=75
    cv::bilateralFilter(src, dst, 9, 75, 75);
    cv::imshow("バイラテラルフィルタ後", dst);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    cv::Mat gradX, gradY, absGradX, absGradY, edgeImage;
    // X方向の勾配
    cv::Sobel(src, gradX, CV_16S, 1, 0, 3);
    cv::convertScaleAbs(gradX, absGradX);
    // Y方向の勾配
    cv::Sobel(src, gradY, CV_16S, 0, 1, 3);
    cv::convertScaleAbs(gradY, absGradY);
    // 合成
    cv::addWeighted(absGradX, 0.5, absGradY, 0.5, 0, edgeImage);
    cv::imshow("Sobelエッジ", edgeImage);
    cv::waitKey(0);
    return 0;
}

cv::Scharr(src, gradX, CV_16S, 1, 0);
cv::Scharr(src, gradY, CV_16S, 0, 1);

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

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    cv::Mat edges;
    //閾値は適宜調整
    cv::Canny(src, edges, 50, 150);
    cv::imshow("Cannyエッジ", edges);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("binary_mask.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    // 輪郭抽出
    cv::findContours(src, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
    // 輪郭を描画
    cv::Mat contourImage = cv::Mat::zeros(src.size(), CV_8UC3);
    for (size_t i = 0; i < contours.size(); i++) {
        cv::Scalar color = cv::Scalar(0, 255, 0);
        cv::drawContours(contourImage, contours, (int)i, color, 2);
    }
    cv::imshow("輪郭抽出", contourImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("contour.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(src, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
    std::vector<std::vector<cv::Point>> approxContours(contours.size());
    for (size_t i = 0; i < contours.size(); i++) {
        cv::approxPolyDP(contours[i], approxContours[i], 3, true);
    }
    cv::Mat approxImage = cv::Mat::zeros(src.size(), CV_8UC3);
    for (size_t i = 0; i < approxContours.size(); i++) {
        cv::drawContours(approxImage, approxContours, (int)i, cv::Scalar(0, 0, 255), 2);
    }
    cv::imshow("近似輪郭", approxImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("contour.png");
    if (src.empty()) {
        return -1;
    }
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(src, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    // 輪郭を赤色で描画
    cv::drawContours(src, contours, -1, cv::Scalar(0, 0, 255), 2);
    cv::imshow("輪郭描画", src);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("binary_mask.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    // 膨張
    cv::Mat dilated;
    cv::Mat element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
    cv::dilate(src, dilated, element);
    // 収縮
    cv::Mat eroded;
    cv::erode(src, eroded, element);
    cv::imshow("膨張", dilated);
    cv::imshow("収縮", eroded);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("noisy_image.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    cv::Mat opening, closing;
    cv::Mat element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5));
    // オープニング
    cv::morphologyEx(src, opening, cv::MORPH_OPEN, element);
    // クロージング
    cv::morphologyEx(src, closing, cv::MORPH_CLOSE, element);
    cv::imshow("オープニング", opening);
    cv::imshow("クロージング", closing);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat src = cv::imread("binary_mask.png", cv::IMREAD_GRAYSCALE);
    if (src.empty()) {
        return -1;
    }
    cv::Mat gradient;
    cv::Mat element = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
    // 形態学的勾配の計算
    cv::morphologyEx(src, gradient, cv::MORPH_GRADIENT, element);
    cv::imshow("形態学的勾配", gradient);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 白背景の画像作成
    cv::Mat img = cv::Mat::zeros(400, 400, CV_8UC3);
    img.setTo(cv::Scalar(255, 255, 255));
    // 線の描画(赤色、太さ2ピクセル)
    cv::line(img, cv::Point(50, 50), cv::Point(350, 350), cv::Scalar(0, 0, 255), 2);
    cv::imshow("線の描画", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::Mat::zeros(400, 400, CV_8UC3);
    img.setTo(cv::Scalar(255, 255, 255));
    // 矩形の描画(青色、線の太さ3)
    cv::rectangle(img, cv::Point(100, 100), cv::Point(300, 300), cv::Scalar(255, 0, 0), 3);
    // 塗りつぶし
    cv::rectangle(img, cv::Point(50, 50), cv::Point(150, 150), cv::Scalar(0, 255, 0), cv::FILLED);
    cv::imshow("矩形描画", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::Mat::zeros(400, 400, CV_8UC3);
    img.setTo(cv::Scalar(255, 255, 255));
    // 円の描画(緑色、半径50)
    cv::circle(img, cv::Point(200, 200), 50, cv::Scalar(0, 255, 0), 3);
    // 楕円の描画(紫色、長軸80、短軸40、角度30度)
    cv::ellipse(img, cv::Point(200, 200), cv::Size(80, 40), 30, 0, 360, cv::Scalar(255, 0, 255), 2);
    cv::imshow("円と楕円", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::Mat::zeros(400, 600, CV_8UC3);
    img.setTo(cv::Scalar(255, 255, 255));
    // 文字列の描画
    cv::putText(img, "OpenCV Drawing", cv::Point(50, 200), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 0), 3);
    cv::imshow("テキスト描画", img);
    cv::waitKey(0);
    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;
    }
    cv::Mat frame;
    while (true) {
        // フレームの読み込み
        if (!cap.read(frame)) {
            break; // 動画の終端
        }
        cv::imshow("動画再生", frame);
        if (cv::waitKey(30) >= 0) break; // 30ms待ち、キー入力で停止
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // カメラデバイス番号0を指定
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "カメラを開けませんでした。" << std::endl;
        return -1;
    }
    cv::Mat frame;
    while (true) {
        cap >> frame; // フレームの取得
        if (frame.empty()) break;
        cv::imshow("カメラ映像", frame);
        if (cv::waitKey(30) >= 0) break; // 30ms待ち、キー入力で停止
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // コーデックの設定(例：XVID)
    int fourcc = cv::VideoWriter::fourcc('X', 'V', 'I', 'D');
    double fps = 30.0;
    cv::Size frameSize(640, 480);
    // VideoWriterの作成
    cv::VideoWriter writer("output.avi", fourcc, fps, frameSize);
    if (!writer.isOpened()) {
        std::cerr << "動画ファイルの書き込みに失敗しました。" << std::endl;
        return -1;
    }
    // 例：静止画を何枚か書き出す
    for (int i = 0; i < 100; ++i) {
        cv::Mat frame(frameSize, CV_8UC3, cv::Scalar(0, 0, 255)); // 赤色のフレーム
        cv::putText(frame, "Frame " + std::to_string(i), cv::Point(50, 50),
                    cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(255, 255, 255), 2);
        writer.write(frame);
    }
    writer.release();
    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;
    }
    cv::Mat frame;
    while (true) {
        cap >> frame; // フレームの取得
        if (frame.empty()) break;
        // ここに画像処理や解析のコードを記述
        cv::imshow("動画処理", frame);
        if (cv::waitKey(30) >= 0) break; // 30ms待ち、キー入力で停止
    }
    cap.release();
    cv::destroyAllWindows();
    return 0;
}

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

int main() {
    // カラーで読み込む
    cv::Mat src = cv::imread("sample.png", cv::IMREAD_COLOR);
    if (src.empty()) {
        return -1;
    }

    // グレースケールに変換してコーナー検出に使用
    cv::Mat gray;
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);

    // Harrisコーナー検出
    cv::Mat dst, dstNorm, dstNormScaled;
    dst = cv::Mat::zeros(gray.size(), CV_32FC1);
    cv::cornerHarris(gray, dst, 2, 1, 0.05);

    // 正規化
    cv::normalize(dst, dstNorm, 0, 255, cv::NORM_MINMAX);
    cv::convertScaleAbs(dstNorm, dstNormScaled);

    // コーナーをマーク（カラー画像上に赤い点を描画）
    for (int i = 0; i < dstNorm.rows; i++) {
        for (int j = 0; j < dstNorm.cols; j++) {
            if ((int)dstNorm.at<float>(i, j) > 200) {
                cv::circle(src, cv::Point(j, i), 5, cv::Scalar(0, 0, 255), 2);
            }
        }
    }

    cv::imshow("Harrisコーナー", src);
    cv::waitKey(0);
    return 0;
}

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

int main() {
    // カラーで読み込む
    cv::Mat src = cv::imread("sample.png", cv::IMREAD_COLOR);
    if (src.empty()) {
        return -1;
    }

    // グレースケールに変換してコーナー検出に使用
    cv::Mat gray;
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);

    std::vector<cv::Point2f> corners;
    int maxCorners = 100;
    double qualityLevel = 0.01;
    double minDistance = 10;
    // Shi-Tomasiコーナー検出
    cv::goodFeaturesToTrack(gray, corners, maxCorners, qualityLevel,
                            minDistance);
    // 検出したコーナーにマーク
    cv::Mat display;
    cv::cvtColor(gray, display, cv::COLOR_GRAY2BGR);
    for (size_t i = 0; i < corners.size(); i++) {
        cv::circle(display, corners[i], 5, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Shi-Tomasiコーナー", display);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
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()) {
        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);
    // 以降、マッチング処理へ
    return 0;
}

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

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);

    // マッチャーの作成
    cv::BFMatcher matcher(cv::NORM_HAMMING);
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);

    // マッチ結果を描画
    cv::Mat img_matches;
    cv::drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);

    // 結果の表示
    cv::imshow("Matches", img_matches);
    cv::waitKey(0);

    return 0;
}

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

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);

    // FLANNに合わせてfloat型に変換
    cv::Mat descriptors1_float, descriptors2_float;
    descriptors1.convertTo(descriptors1_float, CV_32F);
    descriptors2.convertTo(descriptors2_float, CV_32F);

    // FLANNによるマッチング
    cv::FlannBasedMatcher matcher;
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1_float, descriptors2_float, matches);

    // マッチ結果を描画
    cv::Mat img_matches;
    cv::drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);

    // 表示
    cv::imshow("FLANN Matches", img_matches);
    cv::waitKey(0);

    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("search_image.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat templ = cv::imread("template.jpg", cv::IMREAD_GRAYSCALE);
    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, 0, 255), 2);
    cv::imshow("マッチング結果", img);
    cv::waitKey(0);
    return 0;
}

double minVal, maxVal;
cv::Point minLoc, maxLoc;
// 最小値・最大値とその位置を取得
cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);
// どちらを使うかは手法による
// 例：正規化相関の場合はmaxLocが最良位置
cv::Point matchLoc = maxLoc;
// マッチング位置に矩形を描画
cv::rectangle(img, matchLoc, cv::Point(matchLoc.x + templ.cols, matchLoc.y + templ.rows),
              cv::Scalar(0, 255, 0), 2);

double threshold = 0.8;
for (int y = 0; y < result.rows; y++) {
    for (int x = 0; x < result.cols; x++) {
        if (result.at<float>(y, x) >= threshold) {
            cv::rectangle(img, cv::Point(x, y),
                          cv::Point(x + templ.cols, y + templ.rows),
                          cv::Scalar(255, 0, 0), 2);
        }
    }
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat prevImg = cv::imread("frame1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat nextImg = cv::imread("frame2.jpg", cv::IMREAD_GRAYSCALE);
    if (prevImg.empty() || nextImg.empty()) {
        return -1;
    }
    // 特徴点の検出(例：Shi-Tomasi)
    std::vector<cv::Point2f> prevPts;
    cv::goodFeaturesToTrack(prevImg, prevPts, 100, 0.3, 7);
    // 追跡結果格納用
    std::vector<cv::Point2f> nextPts;
    std::vector<uchar> status;
    std::vector<float> err;
    // オプティカルフローの計算
    cv::calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err);
    // 結果の描画
    cv::Mat display;
    cv::cvtColor(prevImg, display, cv::COLOR_GRAY2BGR);
    for (size_t i = 0; i < prevPts.size(); i++) {
        if (status[i]) {
            cv::line(display, prevPts[i], nextPts[i], cv::Scalar(0, 255, 0), 2);
            cv::circle(display, nextPts[i], 3, cv::Scalar(0, 0, 255), -1);
        }
    }
    cv::imshow("Lucas-Kanade Optical Flow", display);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat prevFrame = cv::imread("frame1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat nextFrame = cv::imread("frame2.jpg", cv::IMREAD_GRAYSCALE);
    if (prevFrame.empty() || nextFrame.empty()) {
        return -1;
    }
    cv::Mat flow;
    // Farneback法による密なフロー推定
    cv::calcOpticalFlowFarneback(prevFrame, nextFrame, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
    // フローの可視化
    cv::Mat flowParts[2];
    cv::split(flow, flowParts);
    cv::Mat magnitude, angle;
    cv::cartToPolar(flowParts[0], flowParts[1], magnitude, angle, true);
    // 角度をヒートマップに変換
    cv::Mat hsv[3], hsvImage, bgrImage;
    hsv[0] = angle;
    cv::normalize(magnitude, magnitude, 0, 1, cv::NORM_MINMAX);
    hsv[1] = cv::Mat::ones(angle.size(), CV_32F);
    hsv[2] = magnitude;
    cv::merge(hsv, 3, hsvImage);
    hsvImage.convertTo(hsvImage, CV_8U, 255);
    cv::cvtColor(hsvImage, bgrImage, cv::COLOR_HSV2BGR);
    cv::imshow("Farneback Optical Flow", bgrImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("chessboard.jpg");
    if (img.empty()) {
        return -1;
    }
    cv::Mat gray;
    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
    // チェスボードのコーナー検出
    std::vector<cv::Point2f> corners;
    bool found = cv::findChessboardCorners(gray, cv::Size(9, 6), corners,
                                             cv::CALIB_CB_ADAPTIVE_THRESH | cv::CALIB_CB_NORMALIZE_IMAGE);
    if (found) {
        // コーナーを描画
        cv::drawChessboardCorners(img, cv::Size(9, 6), corners, found);
        cv::imshow("チェスボード検出", img);
        cv::waitKey(0);
    } else {
        std::cout << "チェスボードのコーナーが検出できませんでした。" << std::endl;
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    // 画像ごとのコーナー点と対応する3D座標
    std::vector<std::vector<cv::Point3f>> objectPoints; // 実世界座標
    std::vector<std::vector<cv::Point2f>> imagePoints;  // 画像座標
    // 例：1枚目の画像のコーナー点
    std::vector<cv::Point3f> objPts;
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 9; j++) {
            objPts.push_back(cv::Point3f(j, i, 0));
        }
    }
    objectPoints.push_back(objPts);
    // 画像から検出したコーナー点
    std::vector<cv::Point2f> imgPts;
    // 例：findChessboardCornersで検出した点を設定
    // 省略：実際には複数画像から検出した点を格納
    // カメラ行列と歪み係数の推定
    cv::Mat cameraMatrix, distCoeffs;
    std::vector<cv::Mat> rvecs, tvecs;
    cv::calibrateCamera(objectPoints, imagePoints, cv::Size(640, 480),
                        cameraMatrix, distCoeffs, rvecs, tvecs);
    std::cout << "カメラ行列:\n" << cameraMatrix << std::endl;
    std::cout << "歪み係数:\n" << distCoeffs << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat distorted = cv::imread("distorted.jpg");
    if (distorted.empty()) {
        return -1;
    }
    // 事前に推定したカメラ行列と歪み係数
    cv::Mat cameraMatrix = (cv::Mat_<double>(3,3) << 1000, 0, 320,
                                                      0, 1000, 240,
                                                      0, 0, 1);
    cv::Mat distCoeffs = (cv::Mat_<double>(5,1) << -0.2, 0.1, 0, 0, 0);
    cv::Mat undistorted;
    cv::undistort(distorted, undistorted, cameraMatrix, distCoeffs);
    cv::imshow("歪み補正後", undistorted);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/dnn.hpp>
#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // Caffeモデルの読み込み例
    cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "weights.caffemodel");
    if (net.empty()) {
        std::cerr << "モデルの読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 必要に応じて推論のバックエンドやターゲットを設定
    net.setPreferableBackend(cv::dnn::DNN_BACKEND_DEFAULT);
    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
    return 0;
}

#include <opencv2/dnn.hpp>
#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像の読み込み
    cv::Mat img = cv::imread("input.jpg");
    if (img.empty()) {
        return -1;
    }
    // 前処理：リサイズ、正規化
    cv::Mat blob = cv::dnn::blobFromImage(img, 1.0, cv::Size(224, 224),
                                            cv::Scalar(104, 117, 123), false, false);
    // ネットワークに入力
    cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "weights.caffemodel");
    net.setInput(blob);
    // 推論実行
    cv::Mat output = net.forward();
    // 出力結果の処理は次のセクションで
    return 0;
}