ven's profile - activity

I'm new to opencv and its developing. i used SIFT descriptor and FLANN matcher to identify the good key points. I'm using Flea2 camera images. I dont have insentric parameters. so i moved to stereoRectifyUncalibrated function. I calculated fundamental metrix correctly and my images are CV_8UC3 type.

Error :Assertion failed: (unsigned)CV_MAT_DEPTH(type) <= CV_64F, file C :\builds\2_4_PackSlave-win32-vc12-shared\opencv\modules\core\include\opencv2/cor e/types_c.h, line 737

please find below the code i used.

void Destriptor::extract_features_using_dector()
{
    int minHessian = 400;

    SurfFeatureDetector detector(0.01,10); // i changed minHessian value into 0.01 & 100

    //std::vector<KeyPoint> keypoints_1, keypoints_2;

    detector.detect(input_right, keypoints_right);
    detector.detect(input_center, keypoints_center);

    //-- Step 2: Calculate descriptors (feature vectors)
    SurfDescriptorExtractor extractor;

    Mat descriptors_1, descriptors_2;

    extractor.compute(input_right, keypoints_right, descriptor_right);
    extractor.compute(input_center, keypoints_center, descriptor_center);

    //-- Step 3: Matching descriptor vectors using FLANN matcher
    FlannBasedMatcher matcher;
    std::vector< DMatch > matches;
    matcher.match(descriptor_right, descriptor_center, matches);

    double max_dist = 0; double min_dist = 100;

    //-- Quick calculation of max and min distances between keypoints
    for (int i = 0; i < descriptor_right.rows; i++)
    {
        double dist = matches[i].distance;
        if (dist < min_dist) min_dist = dist;
        if (dist > max_dist) max_dist = dist;
    }

    printf("-- Max dist : %f \n", max_dist);
    printf("-- Min dist : %f \n", min_dist);

    //-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist,
    //-- or a small arbitary value ( 0.02 ) in the event that min_dist is very
    //-- small)
    //-- PS.- radiusMatch can also be used here.
    std::vector< DMatch > good_matches;

    for (int i = 0; i < descriptor_right.rows; i++)
    {
        //here i change octaves and layers then i achieved more 
        if (matches[i].distance <= max(4 * min_dist, 0.02))
        {
            good_matches.push_back(matches[i]);
        }
    }

    //-- Draw only "good" matches
    Mat img_matches;

    // the draw method Change the Flag from default to rich then visible key points with maches DrawMatchesFlags::DEFAULT
    //scale and oriantation as well
    drawMatches(input_right, keypoints_right, input_center, keypoints_center,
        good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
        vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
//-- Show detected matches
    imshow("Good Matches", img_matches);

    float xr, yr; // for store x and y cordinates for right pixels
    float xc, yc; // for store x and y cordinates for center pixels

    for (int i = 0; i < (int)good_matches.size(); i++)
    {
        //printf("-- Good Match [%d] Keypoint 1: %d  -- Keypoint 2: %d  \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx);
        xr = keypoints_right[good_matches[i].queryIdx].pt.x;
        yr = keypoints_right[good_matches[i].queryIdx].pt.y;

        printf("key points of right image x-> %f y-> %f \n", xr, yr);

        xc = keypoints_center[good_matches[i].trainIdx].pt.x;
        yc = keypoints_center[good_matches[i].trainIdx].pt.y;

        printf("key point of center image x-> %f y-> %f \n ", xc, yc);

        printf("\n");

    }

    // print number of good maches
    printf("Number of good machers %i \n", good_matches.size());

    //create fundamental matrix
    // convert 1 vector of keypoint info
    //2 vectors of Point2f for compute F matrix

    vector<int> pointIndexesCenter;
    vector<int> pointIndexesRight;
    for (vector<DMatch>::const_iterator it = good_matches.begin(); it != good_matches.end(); ++it) {

        // Get the indexes of the selected matched keypoints
        pointIndexesCenter.push_back(it->queryIdx);
        pointIndexesRight.push_back(it->trainIdx);
    }
    // Convert keypoints into Point2f

    vector<Point2f ...