【C++】OpenCVでSIFTを活用した高精度特徴点検出とマッチング手法

cv::Ptr<cv::SIFT> sift = cv::SIFT::create(nFeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma);

#include <opencv2/opencv.hpp>

int main() {
    // 画像の読み込み(グレースケール)
    cv::Mat image = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // SIFTインスタンスの作成
    cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
    // 特徴点と記述子を格納する変数
    std::vector<cv::KeyPoint> keypoints;
    cv::Mat descriptors;
    // detectAndComputeの呼び出し
    // 画像から特徴点を検出し、記述子を計算
    sift->detectAndCompute(image, cv::noArray(), keypoints, descriptors);
    // 検出された特徴点の数を出力
    std::cout << "検出された特徴点の数: " << keypoints.size() << std::endl;
    // 特徴点の描画
    cv::Mat outputImage;
    cv::drawKeypoints(image, keypoints, outputImage);
    cv::imshow("特徴点検出結果", outputImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    // 画像の読み込み
    cv::Mat image = cv::imread("sample.jpg");
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 例として、検出された特徴点を用意
    std::vector<cv::KeyPoint> keypoints;
    // ここでは仮にいくつかのKeyPointを作成
    keypoints.emplace_back(cv::KeyPoint(100, 100, 10, -1, 0, 0, -1));
    keypoints.emplace_back(cv::KeyPoint(200, 150, 15, -1, 0, 0, -1));
    // 描画オプションの設定
    auto flags = cv::DrawMatchesFlags::DEFAULT; // デフォルト設定
    // flagsには他にも以下のオプションがある
    // cv::DrawMatchesFlags::DRAW_OVER_OUTIMG
    // cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS
    // cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS
    // 特徴点の描画
    cv::Mat outputImage;
    cv::drawKeypoints(image, keypoints, outputImage, cv::Scalar(0, 255, 0),
                      flags);
    // 表示
    cv::imshow("特徴点の可視化", outputImage);
    cv::waitKey(0);
    return 0;
}

// rich keypointsを描画する例
cv::drawKeypoints(image, keypoints, outputImage, cv::Scalar(255, 0, 0), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

#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()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 特徴点の検出と描画(例として同じ処理を繰り返す)
    cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;
    sift->detectAndCompute(img1, cv::noArray(), keypoints1, descriptors1);
    sift->detectAndCompute(img2, cv::noArray(), keypoints2, descriptors2);
    cv::Mat img1_kp, img2_kp;
    cv::drawKeypoints(img1, keypoints1, img1_kp, cv::Scalar(0, 255, 0), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
    cv::drawKeypoints(img2, keypoints2, img2_kp, cv::Scalar(0, 255, 0), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
    // 横に結合
    cv::Mat combined;
    cv::hconcat(img1_kp, img2_kp, combined);
    // 表示
    cv::imshow("比較画像", combined);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    // 例として、2つの画像の記述子を用意
    cv::Mat descriptors1, descriptors2;
    // ここでは仮に空の行列を用意
    // 実際にはdetectAndComputeで得られた記述子を使用
    // BFMatcherの作成
    cv::BFMatcher matcher(cv::NORM_L2, false); // L2ノルムを使用し、クロスマッチは無効
    // マッチングの実行
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);
    // マッチング結果の出力
    for (const auto& match : matches) {
        std::cout << "QueryIdx: " << match.queryIdx
                  << " TrainIdx: " << match.trainIdx
                  << " Distance: " << match.distance << std::endl;
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    // 例として、2つの画像の記述子を用意
    cv::Mat descriptors1, descriptors2;
    // ここでは仮に空の行列を用意
    // 実際にはdetectAndComputeで得られた記述子を使用
    // BFMatcherの作成
    cv::BFMatcher matcher(cv::NORM_L2,
                          false); // L2ノルムを使用し、クロスマッチは無効
    // マッチングの実行
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);
    // マッチング結果の出力
    for (const auto& match : matches) {
        std::cout << "QueryIdx: " << match.queryIdx
                  << " TrainIdx: " << match.trainIdx
                  << " Distance: " << match.distance << std::endl;
    }
    std::cout << "Number of matches: " << matches.size() << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    // 例として、良好なマッチングペアのポイントを抽出
    std::vector<cv::Point2f> points1, points2;
    // ここでは仮のポイントを用意
    // 実際にはマッチングペアから抽出
    // RANSACを用いてホモグラフィ行列を推定
    cv::Mat mask;
    cv::Mat H = cv::findHomography(points1, points2, cv::RANSAC, 3, mask);
    // 外れ値のマスクを確認
    for (size_t i = 0; i < mask.rows; i++) {
        if (mask.at<uchar>(i)) {
            // この対応は信頼できる
        } else {
            // この対応は外れ値
        }
    }
    // 外れ値を除いたマッチングを再構築可能
    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()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 特徴点とマッチング結果の例
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    std::vector<cv::DMatch> matches;
    // ここでは仮のデータを用意
    // 実際にはdetectAndComputeとマッチング結果を使用
    // drawMatchesの呼び出し
    cv::Mat resultImage;
    cv::drawMatches(
        img1, keypoints1,
        img2, keypoints2,
        matches,
        resultImage,
        cv::Scalar(0, 255, 0), // マッチング線の色(緑)
        cv::Scalar(255, 0, 0), // マッチング点の色(青)
        std::vector<char>(), // マッチングのマスク(省略可)
        cv::DrawMatchesFlags::DEFAULT // 描画フラグ
    );
    // 表示
    cv::imshow("マッチング結果", resultImage);
    cv::waitKey(0);
    return 0;
}

std::cout << "マッチング数: " << matches.size() << std::endl;

double totalDistance = 0.0;
for (const auto& match : matches) {
    totalDistance += match.distance;
}
double averageDistance = totalDistance / matches.size();
std::cout << "平均距離: " << averageDistance << std::endl;

cv::Mat displayImage;
resultImage.copyTo(displayImage);
cv::putText(displayImage, "Matches: " + std::to_string(matches.size()), cv::Point(10, 30),
            cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255, 255, 255), 2);
cv::putText(displayImage, "Avg Dist: " + std::to_string(averageDistance), cv::Point(10, 60),
            cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255, 255, 255), 2);
cv::imshow("マッチング結果と評価", displayImage);
cv::waitKey(0);

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    // 画像の読み込み
    cv::Mat img1 = cv::imread("image1.jpg");
    cv::Mat img2 = cv::imread("image2.jpg");
    if (img1.empty() || img2.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    // 特徴点と記述子の検出とマッチング(省略)
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;
    // detectAndComputeとマッチング処理を行う
    // マッチング結果から対応点を抽出
    std::vector<cv::DMatch> matches;
    // 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);
    }
    // ホモグラフィ行列の推定
    cv::Mat mask;
    cv::Mat H = cv::findHomography(points1, points2, cv::RANSAC, 3, mask);
    // 画像の変換とブレンディング
    cv::Mat result;
    cv::warpPerspective(img1, result, H, cv::Size(img1.cols + img2.cols, std::max(img1.rows, img2.rows)));
    cv::Mat roi(result, cv::Rect(0, 0, img2.cols, img2.rows));
    img2.copyTo(roi);
    // 結果の表示
    cv::imshow("パノラマ合成", result);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
int main() {
    cv::VideoCapture cap("video.mp4");
    if (!cap.isOpened()) {
        std::cerr << "動画のオープンに失敗しました。" << std::endl;
        return -1;
    }
    cv::Mat prevFrame, currFrame;
    std::vector<cv::KeyPoint> prevKeypoints, currKeypoints;
    cv::Mat prevDescriptors, currDescriptors;
    // 最初のフレームの取得
    cap >> prevFrame;
    cv::cvtColor(prevFrame, prevFrame, cv::COLOR_BGR2GRAY);
    cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
    // 最初の特徴点検出
    sift->detectAndCompute(prevFrame, cv::noArray(), prevKeypoints, prevDescriptors);
    while (true) {
        cap >> currFrame;
        if (currFrame.empty()) break;
        cv::cvtColor(currFrame, currFrame, cv::COLOR_BGR2GRAY);
        // 特徴点の検出と記述子の計算
        sift->detectAndCompute(currFrame, cv::noArray(), currKeypoints, currDescriptors);
        // 特徴点の追跡(マッチング)
        cv::BFMatcher matcher(cv::NORM_L2);
        std::vector<cv::DMatch> matches;
        matcher.match(prevDescriptors, currDescriptors, matches);
        // マッチング結果から動きの推定やトラッキング
        // 例：良好なマッチのみを抽出し、動きの平均を計算
        // 次のフレームの準備
        prevFrame = currFrame.clone();
        prevKeypoints = currKeypoints;
        prevDescriptors = currDescriptors;
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <omp.h>
#include <vector>
int main() {
    std::vector<cv::Mat> images; // 複数画像のリスト
    // 画像の読み込み(省略)
    std::vector<std::vector<cv::KeyPoint>> allKeypoints(images.size());
    std::vector<cv::Mat> allDescriptors(images.size());
    #pragma omp parallel for
    for (int i = 0; i < images.size(); ++i) {
        cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
        sift->detectAndCompute(images[i], cv::noArray(), allKeypoints[i], allDescriptors[i]);
    }
    // 以降の処理
    return 0;
}

#include <opencv2/opencv.hpp>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
class ThreadPool {
public:
    ThreadPool(size_t num_threads);
    ~ThreadPool();
    void enqueue(std::function<void()> task);
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};
ThreadPool::ThreadPool(size_t num_threads) : stop(false) {
    for (size_t i = 0; i < num_threads; ++i) {
        workers.emplace_back([this] {
            while (true) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(this->queue_mutex);
                    this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                    if (this->stop && this->tasks.empty()) return;
                    task = std::move(this->tasks.front());
                    this->tasks.pop();
                }
                task();
            }
        });
    }
}
void ThreadPool::enqueue(std::function<void()> task) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        tasks.push(task);
    }
    condition.notify_one();
}
ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread &worker : workers) {
        worker.join();
    }
}
// 使用例
int main() {
    ThreadPool pool(4); // 4スレッドのプールを作成
    // 画像リスト
    std::vector<cv::Mat> images; // 画像の読み込みは省略
    for (auto &img : images) {
        pool.enqueue([&img]() {
            cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
            std::vector<cv::KeyPoint> keypoints;
            cv::Mat descriptors;
            sift->detectAndCompute(img, cv::noArray(), keypoints, descriptors);
            // 追加処理
        });
    }
    // すべてのタスク完了まで待つ
    // デストラクタ呼び出しで自動的に待機
    return 0;
}

#include <opencv2/opencv.hpp>
#include <opencv2/cudaimgproc.hpp>
#include <opencv2/cudafeatures2d.hpp>
int main() {
    // 画像の読み込み
    cv::Mat img_host = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    if (img_host.empty()) return -1;
    // GPUメモリに転送
    cv::cuda::GpuMat img_gpu;
    img_gpu.upload(img_host);
    // CUDA SIFTの作成
    cv::Ptr<cv::cuda::SIFT> sift = cv::cuda::SIFT::create();
    // 特徴点と記述子の検出
    std::vector<cv::KeyPoint> keypoints;
    cv::cuda::GpuMat descriptors_gpu;
    sift->detectAndComputeAsync(img_gpu, cv::cuda::GpuMat(), keypoints, descriptors_gpu);
    // 結果をホストにダウンロード
    cv::Mat descriptors;
    descriptors_gpu.download(descriptors);
    // 特徴点の描画(CPU側で行う)
    cv::Mat output;
    cv::drawKeypoints(img_host, keypoints, output);
    cv::imshow("GPU SIFT", output);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<double> contrastThresholds = {0.01, 0.04, 0.1};
    for (double threshold : contrastThresholds) {
        cv::Ptr<cv::SIFT> sift = cv::SIFT::create(0, 3, threshold);
        std::vector<cv::KeyPoint> keypoints;
        cv::Mat descriptors;
        sift->detectAndCompute(image, cv::noArray(), keypoints, descriptors);
        // 検出された特徴点の数を出力
        std::cout << "contrastThreshold = " << threshold
                  << " で検出された特徴点数: " << keypoints.size() << std::endl;
        // 描画
        cv::Mat output;
        cv::drawKeypoints(image, keypoints, output, cv::Scalar(0, 255, 0),
                          cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
        std::string windowName = "ContrastThreshold_" + std::to_string(threshold);
        cv::imshow(windowName, output);
        cv::waitKey(0);
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
int main() {
    cv::Mat image = cv::imread("sample.jpg", cv::IMREAD_GRAYSCALE);
    if (image.empty()) {
        std::cerr << "画像の読み込みに失敗しました。" << std::endl;
        return -1;
    }
    std::vector<std::pair<int, int>> paramCombinations = {
        {3, 3},
        {4, 3},
        {3, 4},
        {4, 4}
    };
    for (const auto& params : paramCombinations) {
        int nOctaves = 2; // 固定
        int octaveLayers = params.first;
        int nOctaveLayers = params.second;
        cv::Ptr<cv::SIFT> sift = cv::SIFT::create(0, octaveLayers, 0.04);
        std::vector<cv::KeyPoint> keypoints;
        cv::Mat descriptors;
        sift->detectAndCompute(image, cv::noArray(), keypoints, descriptors);
        std::cout << "octaveLayers = " << octaveLayers
                  << ", layers = " << nOctaveLayers
                  << " で検出された特徴点数: " << keypoints.size() << std::endl;
        // 描画
        cv::Mat output;
        cv::drawKeypoints(image, keypoints, output, cv::Scalar(255, 0, 0),
                          cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
        std::string windowName = "Octaves_" + std::to_string(octaveLayers) +
                                 "_Layers_" + std::to_string(nOctaveLayers);
        cv::imshow(windowName, output);
        cv::waitKey(0);
    }
    return 0;
}