ओपनसीवी - छवि सिलाई

Question

मैं इनपुट छवियों को सिलाई करने के लिए निम्नलिखित कोड का उपयोग कर रहा हूं। अज्ञात के लिए आउटपुट परिणाम बकवास है! ऐसा लगता है कि होमोग्राफी मैट्रिक्स गलत है (या गलत तरीके से प्रभावित है) क्योंकि परिवर्तित छवि "शोषित स्टार" की तरह है! मैंने उस भाग पर टिप्पणी की है जो मुझे लगता है कि समस्या का स्रोत है लेकिन मुझे इसका एहसास नहीं हो सकता है। कोई मदद या बिंदु सराहना की है!

आपका दिन शुभ हो, अली

void Stitch2Image(IplImage *mImage1, IplImage *mImage2) 
{ 

    // Convert input images to gray 
    IplImage* gray1 = cvCreateImage(cvSize(mImage1->width, mImage1->height), 8, 1); 

    cvCvtColor(mImage1, gray1, CV_BGR2GRAY); 
    IplImage* gray2 = cvCreateImage(cvSize(mImage2->width, mImage2->height), 8, 1); 

    cvCvtColor(mImage2, gray2, CV_BGR2GRAY); 
    // Convert gray images to Mat 
    Mat img1(gray1); 
    Mat img2(gray2); 
    // Detect FAST keypoints and BRIEF features in the first image 
    FastFeatureDetector detector(50); 
    BriefDescriptorExtractor descriptorExtractor; 
    BruteForceMatcher<L1<uchar> > descriptorMatcher; 
    vector<KeyPoint> keypoints1; 
    detector.detect(img1, keypoints1); 
    Mat descriptors1; 
    descriptorExtractor.compute(img1, keypoints1, descriptors1); 

/* Detect FAST keypoints and BRIEF features in the second image*/ 


    vector<KeyPoint> keypoints2; 
    detector.detect(img1, keypoints2); 
    Mat descriptors2; 
    descriptorExtractor.compute(img2, keypoints2, descriptors2); 
    vector<DMatch> matches; 
    descriptorMatcher.match(descriptors1, descriptors2, matches); 
    if (matches.size()==0) 
      return; 
    vector<Point2f> points1, points2; 
    for(size_t q = 0; q < matches.size(); q++) 
    { 
      points1.push_back(keypoints1[matches[q].queryIdx].pt); 
      points2.push_back(keypoints2[matches[q].trainIdx].pt); 
    } 
    // Create the result image 
    result = cvCreateImage(cvSize(mImage2->width * 2, mImage2->height), 8, 3); 
    cvZero(result); 

    // Copy the second image in the result image 

    cvSetImageROI(result, cvRect(mImage2->width, 0, mImage2->width, mImage2->height)); 
    cvCopy(mImage2, result); 
    cvResetImageROI(result); 

    // Create warp image 
    IplImage* warpImage = cvCloneImage(result); 
    cvZero(warpImage); 

    /************************** Is there anything wrong here!? *******************/ 
    // Find homography matrix 
    Mat H = findHomography(Mat(points1), Mat(points2), 8, 3.0); 
    CvMat HH = H; // Is this line converted correctly? 
    // Transform warp image 
    cvWarpPerspective(mImage1, warpImage, &HH); 
    // Blend 
    blend(result, warpImage); 
    /*******************************************************************************/ 

    cvReleaseImage(&gray1); 
    cvReleaseImage(&gray2); 
    cvReleaseImage(&warpImage); 
} 

Answer 1

यह मैं आप की कोशिश करने का क्या सुझाव है कि इस क्रम में, यह है:

1) का प्रयोग करें CV_RANSAC homography के लिए विकल्प। http://opencv.willowgarage.com/documentation/cpp/calib3d_camera_calibration_and_3d_reconstruction.html

2) अन्य वर्णनकर्ताओं, विशेष रूप से एसआईएफटी या एसयूआरएफ को आजमाएं जो ओपनसीवी के साथ शिप करते हैं। कुछ छवियों के लिए तेज़ या BRIEF वर्णनकर्ता पर्याप्त भेदभाव नहीं कर रहे हैं। संपादित करें (अगस्त '12): ओआरबी डिस्क्रिप्टर, जो बीआरईईएफ पर आधारित हैं, काफी अच्छे और तेज़ हैं!

3) होमोग्राफी मैट्रिक्स (डीबग मोड में चरणबद्ध करें या इसे प्रिंट करें) को देखने का प्रयास करें और देखें कि यह संगत है या नहीं।

4) यदि उपर्युक्त आपको कोई सुराग नहीं देता है, तो बनाए गए मैचों को देखने का प्रयास करें। क्या यह एक छवि में एक बिंदु से मेल खाता है जिसमें दूसरी छवि में कई बिंदु हैं? यदि ऐसा है तो समस्या फिर से वर्णक या डिटेक्टर के साथ होना चाहिए।

मेरा झुकाव यह है कि यह वर्णनकर्ता (इसलिए 1) या 2) इसे ठीक करना चाहिए)।

Answer 2

आपकी होमोग्राफी, गलत मैचों के आधार पर गणना की जा सकती है और इस प्रकार खराब आवंटन का प्रतिनिधित्व करती है। मैं अपनी पंक्तियों के बीच परस्पर निर्भरता की अतिरिक्त जांच के माध्यम से मैट्रिक्स को पथ करने का सुझाव देता हूं।

bool cvExtCheckTransformValid(const Mat& T){ 

    // Check the shape of the matrix 
    if (T.empty()) 
     return false; 
    if (T.rows != 3) 
     return false; 
    if (T.cols != 3) 
     return false; 

    // Check for linear dependency. 
    Mat tmp; 
    T.row(0).copyTo(tmp); 
    tmp /= T.row(1); 
    Scalar mean; 
    Scalar stddev; 
    meanStdDev(tmp,mean,stddev); 
    double X = abs(stddev[0]/mean[0]); 
    printf("std of H:%g\n",X); 
    if (X < 0.8) 
     return false; 

    return true;  
} 

Answer 3

इसके अलावा BruteForceMatcher में आलोचनात्मक अंतर के बजाय एल 1 दूरी के लिए स्विच:

आप नीचे दिए गए कोड का उपयोग कर सकते हैं। BRIEF वर्णनकर्ताओं को हैमिंग दूरी का उपयोग करके तुलना की जानी चाहिए।