カメラに関する情報なしの2つの画像からの3D再構成

Question

私はこの分野の新人で、2D画像から3Dで単純なシーンをモデル化しようとしていますが、カメラに関する情報がありません。 つのオプション があることを知っています。

• 2つの画像があり、XMLからロードしたカメラのモデル（イントリシクス）を知っています。たとえば、loadXMLFromFile() => stereoRectify() => reprojectImageTo3D()

• 持っていませんが、カメラを調整できます=> stereoCalibrate() => stereoRectify() => reprojectImageTo3D()

• カメラを調整できません（2つの画像を撮影したカメラがないためです）、SURF、SIFTなどの両方の画像でペアのキーポイントを見つける必要があります（任意のblobを使用できます）検出器）、次にこれらのキーポイントの記述子を計算し、その記述子に従って画像の右と左のキーポイントを照合し、それらから基本行列を見つけます。処理ははるかに難しく、次のようになります。

  1. キーポイントを検出（SURF、SIFT）=>
  2. 記述子の抽出（SURF、SIFT）=>
  3. 記述子を比較して一致させる（BruteForce、Flannベースのアプローチ）=>
  4. これらのペアから基本的なマット（findFundamentalMat()）を見つける=>
  5. stereoRectifyUncalibrated() =>
  6. reprojectImageTo3D()

私は最後のアプローチを使用しており、私の質問は次のとおりです。

1）正しいですか？

2）よろしければ、最後のステップstereoRectifyUncalibrated() => reprojectImageTo3D()に疑問があります。 reprojectImageTo3D()関数のシグネチャは次のとおりです。

_void reprojectImageTo3D(InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int depth=-1 )

cv::reprojectImageTo3D(imgDisparity8U, xyz, Q, true) (in my code)
_

パラメーター：

• disparity –入力シングルチャネル8ビット符号なし、16ビット符号付き、32ビット符号付き、または32ビット浮動小数点ディスパリティイメージ。
• __3dImage_ – disparityと同じサイズの3チャネル浮動小数点画像を出力します。 _3dImage(x,y)の各要素には、視差マップから計算された点_(x,y)_の3D座標が含まれています。
• Q – stereoRectify()で取得できる4x4透視変換行列。
• handleMissingValues –関数が欠損値（つまり、視差が計算されなかったポイント）を処理するかどうかを示します。 _handleMissingValues=true_の場合、外れ値に対応する視差が最小のピクセル（StereoBM::operator()を参照）は、非常に大きなZ値（現在は10000に設定）を持つ3Dポイントに変換されます。
• ddepth –オプションの出力配列の深さ。 -1の場合、出力イメージは_CV_32F_深度になります。 ddepthは、_CV_16S_、_CV_32S_または `CV_32F 'にも設定できます。

Qマトリックスを取得するにはどうすればよいですか？ Q、_H1_および_H2_を使用してFマトリックスを取得することは可能ですか？

3）カメラをキャリブレーションせずにxyz座標を取得する別の方法はありますか？

私のコードは：

_#include <opencv2/core/core.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/contrib/contrib.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <conio.h>
#include <opencv/cv.h>
#include <opencv/cxcore.h>
#include <opencv/cvaux.h>


using namespace cv;
using namespace std;

int main(int argc, char *argv[]){

    // Read the images
    Mat imgLeft = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
    Mat imgRight = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );

    // check
    if (!imgLeft.data || !imgRight.data)
            return 0;

    // 1] find pair keypoints on both images (SURF, SIFT):::::::::::::::::::::::::::::

    // vector of keypoints
    std::vector<cv::KeyPoint> keypointsLeft;
    std::vector<cv::KeyPoint> keypointsRight;

    // Construct the SURF feature detector object
    cv::SiftFeatureDetector sift(
            0.01, // feature threshold
            10); // threshold to reduce
                // sensitivity to lines
                // Detect the SURF features

    // Detection of the SIFT features
    sift.detect(imgLeft,keypointsLeft);
    sift.detect(imgRight,keypointsRight);

    std::cout << "Number of SURF points (1): " << keypointsLeft.size() << std::endl;
    std::cout << "Number of SURF points (2): " << keypointsRight.size() << std::endl;

    // 2] compute descriptors of these keypoints (SURF,SIFT) ::::::::::::::::::::::::::

    // Construction of the SURF descriptor extractor
    cv::SurfDescriptorExtractor surfDesc;

    // Extraction of the SURF descriptors
    cv::Mat descriptorsLeft, descriptorsRight;
    surfDesc.compute(imgLeft,keypointsLeft,descriptorsLeft);
    surfDesc.compute(imgRight,keypointsRight,descriptorsRight);

    std::cout << "descriptor matrix size: " << descriptorsLeft.rows << " by " << descriptorsLeft.cols << std::endl;

    // 3] matching keypoints from image right and image left according to their descriptors (BruteForce, Flann based approaches)

    // Construction of the matcher
    cv::BruteForceMatcher<cv::L2<float> > matcher;

    // Match the two image descriptors
    std::vector<cv::DMatch> matches;
    matcher.match(descriptorsLeft,descriptorsRight, matches);

    std::cout << "Number of matched points: " << matches.size() << std::endl;


    // 4] find the fundamental mat ::::::::::::::::::::::::::::::::::::::::::::::::::::

    // Convert 1 vector of keypoints into
    // 2 vectors of Point2f for compute F matrix
    // with cv::findFundamentalMat() function
    std::vector<int> pointIndexesLeft;
    std::vector<int> pointIndexesRight;
    for (std::vector<cv::DMatch>::const_iterator it= matches.begin(); it!= matches.end(); ++it) {

         // Get the indexes of the selected matched keypoints
         pointIndexesLeft.Push_back(it->queryIdx);
         pointIndexesRight.Push_back(it->trainIdx);
    }

    // Convert keypoints into Point2f
    std::vector<cv::Point2f> selPointsLeft, selPointsRight;
    cv::KeyPoint::convert(keypointsLeft,selPointsLeft,pointIndexesLeft);
    cv::KeyPoint::convert(keypointsRight,selPointsRight,pointIndexesRight);

    /* check by drawing the points
    std::vector<cv::Point2f>::const_iterator it= selPointsLeft.begin();
    while (it!=selPointsLeft.end()) {

            // draw a circle at each corner location
            cv::circle(imgLeft,*it,3,cv::Scalar(255,255,255),2);
            ++it;
    }

    it= selPointsRight.begin();
    while (it!=selPointsRight.end()) {

            // draw a circle at each corner location
            cv::circle(imgRight,*it,3,cv::Scalar(255,255,255),2);
            ++it;
    } */

    // Compute F matrix from n>=8 matches
    cv::Mat fundemental= cv::findFundamentalMat(
            cv::Mat(selPointsLeft), // points in first image
            cv::Mat(selPointsRight), // points in second image
            CV_FM_RANSAC);       // 8-point method

    std::cout << "F-Matrix size= " << fundemental.rows << "," << fundemental.cols << std::endl;

    /* draw the left points corresponding epipolar lines in right image
    std::vector<cv::Vec3f> linesLeft;
    cv::computeCorrespondEpilines(
            cv::Mat(selPointsLeft), // image points
            1,                      // in image 1 (can also be 2)
            fundemental,            // F matrix
            linesLeft);             // vector of epipolar lines

    // for all epipolar lines
    for (vector<cv::Vec3f>::const_iterator it= linesLeft.begin(); it!=linesLeft.end(); ++it) {

        // draw the epipolar line between first and last column
        cv::line(imgRight,cv::Point(0,-(*it)[2]/(*it)[1]),cv::Point(imgRight.cols,-((*it)[2]+(*it)[0]*imgRight.cols)/(*it)[1]),cv::Scalar(255,255,255));
    }

    // draw the left points corresponding epipolar lines in left image
    std::vector<cv::Vec3f> linesRight;
    cv::computeCorrespondEpilines(cv::Mat(selPointsRight),2,fundemental,linesRight);
    for (vector<cv::Vec3f>::const_iterator it= linesRight.begin(); it!=linesRight.end(); ++it) {

        // draw the epipolar line between first and last column
        cv::line(imgLeft,cv::Point(0,-(*it)[2]/(*it)[1]), cv::Point(imgLeft.cols,-((*it)[2]+(*it)[0]*imgLeft.cols)/(*it)[1]), cv::Scalar(255,255,255));
    }

    // Display the images with points and epipolar lines
    cv::namedWindow("Right Image Epilines");
    cv::imshow("Right Image Epilines",imgRight);
    cv::namedWindow("Left Image Epilines");
    cv::imshow("Left Image Epilines",imgLeft);
    */

    // 5] stereoRectifyUncalibrated()::::::::::::::::::::::::::::::::::::::::::::::::::

    //H1, H2 – The output rectification homography matrices for the first and for the second images.
    cv::Mat H1(4,4, imgRight.type());
    cv::Mat H2(4,4, imgRight.type());
    cv::stereoRectifyUncalibrated(selPointsRight, selPointsLeft, fundemental, imgRight.size(), H1, H2);


    // create the image in which we will save our disparities
    Mat imgDisparity16S = Mat( imgLeft.rows, imgLeft.cols, CV_16S );
    Mat imgDisparity8U = Mat( imgLeft.rows, imgLeft.cols, CV_8UC1 );

    // Call the constructor for StereoBM
    int ndisparities = 16*5;      // < Range of disparity >
    int SADWindowSize = 5;        // < Size of the block window > Must be odd. Is the 
                                  // size of averaging window used to match pixel  
                                  // blocks(larger values mean better robustness to
                                  // noise, but yield blurry disparity maps)

    StereoBM sbm( StereoBM::BASIC_PRESET,
        ndisparities,
        SADWindowSize );

    // Calculate the disparity image
    sbm( imgLeft, imgRight, imgDisparity16S, CV_16S );

    // Check its extreme values
    double minVal; double maxVal;

    minMaxLoc( imgDisparity16S, &minVal, &maxVal );

    printf("Min disp: %f Max value: %f \n", minVal, maxVal);

    // Display it as a CV_8UC1 image
    imgDisparity16S.convertTo( imgDisparity8U, CV_8UC1, 255/(maxVal - minVal));

    namedWindow( "windowDisparity", CV_WINDOW_NORMAL );
    imshow( "windowDisparity", imgDisparity8U );


    // 6] reprojectImageTo3D() :::::::::::::::::::::::::::::::::::::::::::::::::::::

    //Mat xyz;
    //cv::reprojectImageTo3D(imgDisparity8U, xyz, Q, true);

    //How can I get the Q matrix? Is possibile to obtain the Q matrix with 
    //F, H1 and H2 or in another way?
    //Is there another way for obtain the xyz coordinates?

    cv::waitKey();
    return 0;
}
_

Answer 1

StereoRectifyUncalibratedは、オブジェクト空間での修正変換ではなく、単に平面透視変換を計算します。 Q行列を抽出するには、この平面変換をオブジェクト空間変換に変換する必要があります。カメラのキャリブレーションパラメーターの一部が必要です（カメラの組み込み関数など）。この主題に関して進行中のいくつかの研究トピックがあるかもしれません。

カメラの組み込みを推定し、カメラの相対的な向きを抽出してフローを正しく機能させるためのいくつかの手順を追加する必要がある場合があります。アクティブな照明方法が使用されていない場合、カメラのキャリブレーションパラメーターはシーンの適切な3D構造を抽出するために不可欠であると思います。

また、すべての推定値をより正確な値に絞り込むには、バンドル調整ベースのソリューションが必要です。

Answer 2

1. 手順は私には問題ありません。

2. 私の知る限り、画像ベースの3Dモデリングに関しては、カメラは明示的に調整されているか、暗黙的に調整されています。カメラを明示的に調整する必要はありません。とにかくそれらのものを利用します。対応するポイントペアのマッチングは、間違いなく頻繁に使用されるアプローチです。

Answer 3

画像を修正してQを取得するには、StereoRectifyを使用する必要があると思います。この関数には、2つのカメラ間の回転と平行移動の2つのパラメーター（RおよびT）が必要です。したがって、solvePnPを使用してパラメーターを計算できます。この関数には、特定のオブジェクトの3D実座標と、画像内の2D点および対応する点が必要です