Opencv опишите подробнее алгоритмы работы программы

Mat objectImg = imread("forSearch.png", CV_LOAD_IMAGE_GRAYSCALE );
Mat sceneImg = imread("test.png", CV_LOAD_IMAGE_GRAYSCALE );
 
if(!objectImg.empty() && !sceneImg.empty())
{
 
        std::vector<cv::KeyPoint> objectKeypoints;
        std::vector<cv::KeyPoint> sceneKeypoints;
        cv::Mat objectDescriptors;
        cv::Mat sceneDescriptors;
 
        ////////////////////////////
        // EXTRACT KEYPOINTS
        ////////////////////////////
        // The detector can be any of (see OpenCV features2d.hpp):
        // cv::FeatureDetector * detector = new cv::DenseFeatureDetector();
        // cv::FeatureDetector * detector = new cv::FastFeatureDetector();
        // cv::FeatureDetector * detector = new cv::GFTTDetector();
        // cv::FeatureDetector * detector = new cv::MSER();
        // cv::FeatureDetector * detector = new cv::ORB();
        cv::FeatureDetector * detector = new cv::SIFT();
        // cv::FeatureDetector * detector = new cv::StarFeatureDetector();
        // cv::FeatureDetector * detector = new cv::SURF(600.0);
        // cv::FeatureDetector * detector = new cv::BRISK();
        detector->detect(objectImg, objectKeypoints);
        printf("Object: %d keypoints detected in ms\n", (int)objectKeypoints.size());
        detector->detect(sceneImg, sceneKeypoints);
        printf("Scene: %d keypoints detected in ms\n", (int)sceneKeypoints.size());
 
        ////////////////////////////
        // EXTRACT DESCRIPTORS
        ////////////////////////////
        // The extractor can be any of (see OpenCV features2d.hpp):
        // cv::DescriptorExtractor * extractor = new cv::BriefDescriptorExtractor();
        // cv::DescriptorExtractor * extractor = new cv::ORB();
        cv::DescriptorExtractor * extractor = new cv::SIFT();
        // cv::DescriptorExtractor * extractor = new cv::SURF(600.0);
        // cv::DescriptorExtractor * extractor = new cv::BRISK();
        // cv::DescriptorExtractor * extractor = new cv::FREAK();
        extractor->compute(objectImg, objectKeypoints, objectDescriptors);
        printf("Object: %d descriptors extracted in ms\n", objectDescriptors.rows);
        extractor->compute(sceneImg, sceneKeypoints, sceneDescriptors);
        printf("Scene: %d descriptors extracted in ms\n", sceneDescriptors.rows);
 
        ////////////////////////////
        // NEAREST NEIGHBOR MATCHING USING FLANN LIBRARY (included in OpenCV)
        ////////////////////////////
        cv::Mat results;
        cv::Mat dists;
        std::vector<std::vector<cv::DMatch> > matches;
        bool isBinaryDescriptors;
        int k=2; // find the 2 nearest neighbors
        bool useBFMatcher = false; // SET TO TRUE TO USE BRUTE FORCE MATCHER (may give better results with binary descriptors)
        if(objectDescriptors.type()==CV_8U)
        {
                // Binary descriptors detected (from ORB, Brief, BRISK, FREAK)
                printf("Binary descriptors detected...\n");
                isBinaryDescriptors = true;
                if(useBFMatcher)
                {
                        cv::BFMatcher matcher(cv::NORM_HAMMING);
                        matcher.knnMatch(objectDescriptors, sceneDescriptors, matches, k);
                }
                else
                {
                        // Create Flann LSH index
                        cv::flann::Index flannIndex(sceneDescriptors, cv::flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);
                        printf("Time creating FLANN LSH index = ms\n");
                        results = cv::Mat(objectDescriptors.rows, k, CV_32SC1); // Results index
                        dists = cv::Mat(objectDescriptors.rows, k, CV_32FC1); // Distance results are CV_32FC1 ?!?!? NOTE OpenCV doc is not clear about that...
 
                        // search (nearest neighbor)
                        flannIndex.knnSearch(objectDescriptors, results, dists, k, cv::flann::SearchParams() );
                }
        }
        else
        {
                // assume it is CV_32F
                printf("Float descriptors detected...\n");
                isBinaryDescriptors = false;
                if(useBFMatcher)
                {
                        cv::BFMatcher matcher(cv::NORM_L2);
                        matcher.knnMatch(objectDescriptors, sceneDescriptors, matches, k);
                }
                else
                {
                        // Create Flann KDTree index
                        cv::flann::Index flannIndex(sceneDescriptors, cv::flann::KDTreeIndexParams(), cvflann::FLANN_DIST_EUCLIDEAN);
                        printf("Time creating FLANN KDTree index = ms\n");
                        results = cv::Mat(objectDescriptors.rows, k, CV_32SC1); // Results index
                        dists = cv::Mat(objectDescriptors.rows, k, CV_32FC1); // Distance results are CV_32FC1
 
                        // search (nearest neighbor)
                        flannIndex.knnSearch(objectDescriptors, results, dists, k, cv::flann::SearchParams() );
                }
        }
        printf("Time nearest neighbor search = ms\n");
 
 
 
 
 
        ////////////////////////////
        // PROCESS NEAREST NEIGHBOR RESULTS
        ////////////////////////////
        // Set gui data
     /*   obWidget.setData(objectKeypoints, objectDescriptors, objectImg, "", "");
        sceneWidget.setData(sceneKeypoints, sceneDescriptors, sceneImg, "", "");
*/
        // Find correspondences by NNDR (Nearest Neighbor Distance Ratio)
        float nndrRatio = 0.6;
        std::vector<cv::Point2f> mpts_1, mpts_2; // Used for homography
        std::vector<int> indexes_1, indexes_2; // Used for homography
        std::vector<uchar> outlier_mask;  // Used for homography
        // Check if this descriptor matches with those of the objects
        if(!useBFMatcher)
        {
                for(int i=0; i<objectDescriptors.rows; ++i)
                {
                        // Apply NNDR
                        //printf("q=%d dist1=%f dist2=%f\n", i, dists.at<float>(i,0), dists.at<float>(i,1));
                        if(isBinaryDescriptors || //Binary, just take the nearest
                           dists.at<float>(i,0) <= nndrRatio * dists.at<float>(i,1))
                        {
                                mpts_1.push_back(objectKeypoints.at(i).pt);
                                indexes_1.push_back(i);
 
                                mpts_2.push_back(sceneKeypoints.at(results.at<int>(i,0)).pt);
                                indexes_2.push_back(results.at<int>(i,0));
                        }
                }
        }
        else
        {
                for(unsigned int i=0; i<matches.size(); ++i)
                {
                        // Apply NNDR
                        //printf("q=%d dist1=%f dist2=%f\n", matches.at(i).at(0).queryIdx, matches.at(i).at(0).distance, matches.at(i).at(1).distance);
                        if(isBinaryDescriptors || //Binary, just take the nearest
                           matches.at(i).at(0).distance <= nndrRatio * matches.at(i).at(1).distance)
                        {
                                mpts_1.push_back(objectKeypoints.at(matches.at(i).at(0).queryIdx).pt);
                                indexes_1.push_back(matches.at(i).at(0).queryIdx);
 
                                mpts_2.push_back(sceneKeypoints.at(matches.at(i).at(0).trainIdx).pt);
                                indexes_2.push_back(matches.at(i).at(0).trainIdx);
                        }
                }
        }
 
        // FIND HOMOGRAPHY
        unsigned int minInliers = 8;
        if(mpts_1.size() >= minInliers)
        {
 
                cv::Mat H = findHomography(mpts_1,
                                mpts_2,
                                cv::RANSAC,
                                1.0,
                                outlier_mask);
                printf("Time finding homography = ms\n");
                int inliers=0, outliers=0;
                for(unsigned int k=0; k<mpts_1.size();++k)
                {
                        if(outlier_mask.at(k))
                        {
                                ++inliers;
                        }
                        else
                        {
                                ++outliers;
                        }
                }
                QTransform hTransform(
                H.at<double>(0,0), H.at<double>(1,0), H.at<double>(2,0),
                H.at<double>(0,1), H.at<double>(1,1), H.at<double>(2,1),
                H.at<double>(0,2), H.at<double>(1,2), H.at<double>(2,2));
 
                // GUI : Change color and add homography rectangle
                QColor color(Qt::green);
                int alpha = 130;
                color.setAlpha(alpha);
                for(unsigned int k=0; k<mpts_1.size();++k)
                {
                    /*    if(outlier_mask.at(k))
                        {
                                obWidget.setKptColor(indexes_1.at(k), color);
                                sceneWidget.setKptColor(indexes_2.at(k), color);
                        }
                        else
                        {
                                obWidget.setKptColor(indexes_1.at(k), QColor(255,0,0,alpha));
                                sceneWidget.setKptColor(indexes_2.at(k), QColor(255,0,0,alpha));
                        }*/
                }
                QPen rectPen(color);
                rectPen.setWidth(4);
                /*QGraphicsRectItem * rectItem = new QGraphicsRectItem(obWidget.pixmap().rect());
                rectItem->setPen(rectPen);
                rectItem->setTransform(hTransform);
                sceneWidget.addRect(rectItem);*/
                printf("Inliers=%d Outliers=%d\n", inliers, outliers);
        }
        else
        {
                printf("Not enough matches (%d) for homography...\n", (int)mpts_1.size());
        }
 
   /*     // Wait for gui
        obWidget.setGraphicsViewMode(false);
        obWidget.setWindowTitle("Object");
        if(obWidget.pixmap().width() <= 800)
        {
                obWidget.setMinimumSize(obWidget.pixmap().width(), obWidget.pixmap().height());
        }
        else
        {
                obWidget.setMinimumSize(800, 600);
                obWidget.setAutoScale(false);
        }
 
        sceneWidget.setGraphicsViewMode(false);
        sceneWidget.setWindowTitle("Scene");
        if(sceneWidget.pixmap().width() <= 800)
        {
                sceneWidget.setMinimumSize(sceneWidget.pixmap().width(), sceneWidget.pixmap().height());
        }
        else
        {
                sceneWidget.setMinimumSize(800, 600);
                sceneWidget.setAutoScale(false);
        }*/
 
      /*  sceneWidget.show();
        obWidget.show();*/
 
        printf("Closing...\n");
 
        ////////////////////////////
        //Cleanup
        ////////////////////////////
        delete detector;
        delete extractor;