Stereo Rectify get incorrect result! [closed]

edit

I am working on stereo calibration with these steps: 1. findChessborad -> cornerSubPix 2. stereoCalibrate to get R T E F 3.undistortPoints and computeCorrespondEpilines 4.stereoRectify to get R1 R2 P1 P2 Q 5.initUndistortRectifyMap to get remap matrix 6 remap

all the steps followed the cpp example given in the opencv package. one pair of images I used as below:

the result I get is:

if I use : findFundamentalMat and stereoRectifyUncalibrated instead of stereorectify to get R1 R2 P1 P2 will get a correct result.

here is my code snapshot:

//FOR STD LIB
#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <iterator>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sstream>

//FOR OPENCVLIB
#include "opencv2/opencv.hpp"
#include "opencv2/calib3d.hpp"
#include "opencv2/core/core.hpp"

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv/cvaux.hpp"
//using namespace std;
//using namespace cv;


#define infinite 1e400
#define numImagePairs 10

const std::string PathPrefix = "/home/roby/Developer/projects/Calibration_rectify/res/";
typedef std::vector<std::string> ImageNameList;
typedef std::vector<cv::Point2f> PointList;
typedef std::vector<PointList> LEFT_PointVec;
typedef std::vector<PointList> RIGHT_PointVec;
typedef std::vector<std::vector<cv::Point3f> > Point3DList;
const cv::Size CHECKERBOARD_SIZE = cv::Size(7,6);


#define BYTE unsigned char

int main(int argc, const char * argv[])
{
    ImageNameList rightCameraList;
    ImageNameList leftCameraList;

    ImageNameList goodrightCameraList;
    ImageNameList goodleftCameraList;

    LEFT_PointVec leftCameraPTvec;
    RIGHT_PointVec rightCameraPTvec;
    Point3DList objectPoints;

    int numGoodImgPairs = numImagePairs;
    const float squareSize = 1.f;  // Set this to your actual square size
    cv::Size imageSize;

    //load image name
    std::ostringstream ss;

    for (int i = 1; i <= numImagePairs; i++) {
    ss << i;
        rightCameraList.push_back(PathPrefix + "right/right"+ss.str() +".png");
        leftCameraList.push_back(PathPrefix + "left/left"+ss.str() +".png");
        ss.str(""); //clear stream content
    }

    for (int i = 0; i < numImagePairs; i++) {
        cv::Mat rightimg = cv::imread(rightCameraList[i],0);
        cv::Mat leftimg = cv::imread(leftCameraList[i],0);
        if (rightimg.size != leftimg.size) {
            std::cout<<"Left Image size != Right Image Size"<<std::endl;
            return 0;
        }else{
            imageSize = rightimg.size();
        }

        rightimg.convertTo(rightimg, CV_8U);
        leftimg.convertTo(leftimg, CV_8U);

        PointList right_ptList;
        PointList left_ptList;

        if (cv::findChessboardCorners(rightimg, CHECKERBOARD_SIZE, right_ptList)) {
            if (cv::findChessboardCorners(leftimg, CHECKERBOARD_SIZE, left_ptList)) {
                cv::cornerSubPix(rightimg, right_ptList, cv::Size(11,11), cv::Size(-1,-1),
                                 cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS,
                                          30, 0.01));
                cv::cornerSubPix(leftimg, left_ptList, cv::Size(11,11), cv::Size(-1,-1),
                                 cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS,
                                          30, 0.01));
                rightCameraPTvec.push_back(right_ptList);
                leftCameraPTvec.push_back(left_ptList);
                goodleftCameraList.push_back(leftCameraList[i]);
                goodrightCameraList.push_back(rightCameraList[i]);
            }else{
                numGoodImgPairs--;
                std::cout<<"CHESSBOARD NOT FOUND in LEFT IMG!"<<std::endl;
            }
        }else{
            numGoodImgPairs--;
            std::cout<<"CHESSBOARD NOT FOUND in RIGHT IMG!"<<std::endl;
        }
    }

    if (numGoodImgPairs < 2) {
        std::cout<<"Error: too little pairs to run the calibration"<<std::endl;
        return 0;
    }
    objectPoints.resize(numGoodImgPairs);

    for( int i = 0; i < numGoodImgPairs; i++ )
    {
        for( int j = 0; j < CHECKERBOARD_SIZE.height; j++ )
            for( int k = 0; k < CHECKERBOARD_SIZE.width; k++ )
                objectPoints[i].push_back(cv::Point3f(k*squareSize, j*squareSize, 0));
    }
    cv::Mat cameraMatrix[2], distCoeffs[2];
    cameraMatrix[0] = cv::Mat ...