OpenCV cv :: findHomography lỗi runtime

Question

Tôi đang sử dụng để biên dịch và chạy mã từ Features2D + Homography to find a known object hướng dẫn, và tôi nhận được lỗi này

OpenCV Error: Assertion failed (npoints >= 0 && points2.checkVector(2) == npoint 
s && points1.type() == points2.type()) in unknown function, file c:\Users\vp\wor 
k\ocv\opencv\modules\calib3d\src\fundam.cpp, line 1062 

thời gian chạy. sau khi gỡ lỗi, tôi thấy rằng chương trình đang gặp sự cố tại hàm findHomography.

Unhandled exception at 0x760ab727 in OpenCVTemplateMatch.exe: Microsoft C++ exception: cv::Exception at memory location 0x0029eb3c.. 

trong Introduction của OpenCV, các "cv Namespace" chương nói rằng

Một số trong những cái tên bên ngoài OpenCV hiện tại hoặc tương lai có thể xung đột với STL hoặc các thư viện khác. Trong trường hợp này, hãy sử dụng các công cụ chỉ định không gian tên rõ ràng để giải quyết xung đột tên:

Tôi đã thay đổi mã của mình và sử dụng ở mọi nơi, không giải quyết được. Nếu bạn có thể, hãy giúp tôi trong vấn đề này, hoặc nói rằng chức năng làm điều tương tự như findHomography, và không sụp đổ chương trình.

Và đây là mã của tôi

#include <stdio.h> 
#include <iostream> 
#include "opencv2/core/core.hpp" 
#include "opencv2/features2d/features2d.hpp" 
#include "opencv2/highgui/highgui.hpp" 
#include "opencv2/calib3d/calib3d.hpp" 

void readme(); 

/** @function main */ 
int main(int argc, char** argv) 
{ 
    if(argc != 3) 
    { readme(); return -1; } 

    cv::Mat img_object = cv::imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE); 
    cv::Mat img_scene = cv::imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE); 

    if(!img_object.data || !img_scene.data) 
    { std::cout<< " --(!) Error reading images " << std::endl; return -1; } 

    //-- Step 1: Detect the keypoints using SURF Detector 
    int minHessian = 400; 

    cv::SurfFeatureDetector detector(minHessian); 

    std::vector<cv::KeyPoint> keypoints_object, keypoints_scene; 

    detector.detect(img_object, keypoints_object); 
    detector.detect(img_scene, keypoints_scene); 

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

    cv::Mat descriptors_object, descriptors_scene; 

    extractor.compute(img_object, keypoints_object, descriptors_object); 
    extractor.compute(img_scene, keypoints_scene, descriptors_scene); 

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

    double max_dist = 0; double min_dist = 100; 

    //-- Quick calculation of max and min distances between keypoints 
    for(int i = 0; i < descriptors_object.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 3*min_dist) 
    std::vector<cv::DMatch> good_matches; 

    for(int i = 0; i < descriptors_object.rows; i++) 
    { if(matches[i].distance < 3*min_dist) 
    { good_matches.push_back(matches[i]); } 
    } 

    cv::Mat img_matches; 
    cv::drawMatches(img_object, keypoints_object, img_scene, keypoints_scene, 
     good_matches, img_matches, cv::Scalar::all(-1), cv::Scalar::all(-1), 
     std::vector<char>(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS); 

    //-- Localize the object 
    std::vector<cv::Point2f> obj; 
    std::vector<cv::Point2f> scene; 

    for(int i = 0; i < good_matches.size(); i++) 
    { 
     //-- Get the keypoints from the good matches 
     obj.push_back(keypoints_object[ good_matches[i].queryIdx ].pt); 
     scene.push_back(keypoints_scene[ good_matches[i].trainIdx ].pt); 
    } 

    cv::Mat H = cv::findHomography(obj, scene, CV_RANSAC); 

    //-- Get the corners from the image_1 (the object to be "detected") 
    std::vector<cv::Point2f> obj_corners(4); 
    obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint(img_object.cols, 0); 
    obj_corners[2] = cvPoint(img_object.cols, img_object.rows); obj_corners[3] = cvPoint(0, img_object.rows); 
    std::vector<cv::Point2f> scene_corners(4); 

    cv::perspectiveTransform(obj_corners, scene_corners, H); 

    //-- Draw lines between the corners (the mapped object in the scene - image_2) 
    cv::line(img_matches, scene_corners[0] + cv::Point2f(img_object.cols, 0), scene_corners[1] + cv::Point2f(img_object.cols, 0), cv::Scalar(0, 255, 0), 4); 
    cv::line(img_matches, scene_corners[1] + cv::Point2f(img_object.cols, 0), scene_corners[2] + cv::Point2f(img_object.cols, 0), cv::Scalar(0, 255, 0), 4); 
    cv::line(img_matches, scene_corners[2] + cv::Point2f(img_object.cols, 0), scene_corners[3] + cv::Point2f(img_object.cols, 0), cv::Scalar(0, 255, 0), 4); 
    cv::line(img_matches, scene_corners[3] + cv::Point2f(img_object.cols, 0), scene_corners[0] + cv::Point2f(img_object.cols, 0), cv::Scalar(0, 255, 0), 4); 

    //-- Show detected matches 
    cv::imshow("Good Matches & Object detection", img_matches); 

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

/** @function readme */ 
void readme() 
{ std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; } 

Answer 1

Hôm nay tôi chạy vào cùng một vấn đề với mã ví dụ này. @ toán học-cà phê đã đúng không có tính năng trích xuất, do đó obj và cảnh trống rỗng. Tôi thay thế các hình ảnh thử nghiệm và nó đã làm việc. Từ hình ảnh kiểu kết cấu, bạn không thể trích xuất các tính năng SURF.

Một cách khác là giảm thông số minHessianve.g. `int minHessian = 20;

hoặc sử dụng các máy dò tính năng NHANH bằng cách thay đổi một vài dòng:

//-- Step 1: Detect the keypoints using SURF Detector 
    int minHessian = 15; 

    FastFeatureDetector detector(minHessian); 

Answer 2

tôi đã cùng một vấn đề và tôi đi theo giải pháp của MMH. Chỉ cần viết

cv::Mat H = cv::findHomography(cv::Mat(obj), cv::Mat(scene), CV_RANSAC); cv::perspectiveTransform(cv::Mat(obj_corners), cv::Mat(scene_corners), H);

giải quyết được sự cố.

Answer 3

Câu trả lời thực tế là trong thông báo lỗi:

npoints >= 0 && points2.checkVector(2) == npoints && points1.type() == points2.type() 

Nhân bản dịch có thể đọc được, bạn phải thực hiện đầy đủ những khẳng định:

• đầu vào của bạn phải có một số dương của điểm (trong thực tế findHomography cần 4 điểm trở lên).

• Danh sách các điểm 'đối tượng' và 'cảnh' của bạn phải có cùng số điểm.

• Danh sách các điểm 'đối tượng' và 'cảnh' của bạn phải có cùng một loại điểm.

Answer 4

Nhiều khả năng, vấn đề là ở đây:

if(matches[i].distance < 3*min_dist) 

Các bất bình đẳng nghiêm ngặt không phải là những gì bạn muốn. Nếu min_dist == 0, một trận đấu rất tốt, bạn sẽ bỏ qua tất cả các điểm khoảng cách bằng không.Thay thế bằng:

if(matches[i].distance <= 3*min_dist) 

và bạn sẽ thấy kết quả tốt cho hình ảnh phù hợp.

Để kết thúc tốt đẹp, tôi cũng muốn nói thêm, ví dụ .:

if (good_matches.size() == 0) 
{ 
    std::cout<< " --(!) No good matches found " << std::endl; return -2; 
} 

Answer 5

bạn cần phải thêm một điều kiện trước khi findHomography

if(obj.size()>3){ 
    ///-- Get the corners from the image_1 (the object to be "detected") 
    vector<Point2f> obj_corners(4); 
    obj_corners[0] = Point(0,0); obj_corners[1] = Point(img_object.cols, 0); 
    obj_corners[2] = Point(img_object.cols, img_object.rows); obj_corners[3] = Point(0, img_object.rows); 

    Mat H = findHomography(obj, scene,CV_RANSAC ); 
    perspectiveTransform(obj_corners, scene_corners, H); 
    ///-- Draw lines between the corners (the mapped object in the scene - image_2) 
    for(int i = 0; i < 4; ++i) 
     line(fram_tmp, scene_corners[i]+offset, scene_corners[(i + 1) % 4]+offset, Scalar(0, 255, 0), 4); 
}