- (NSArray *)findObjectByTemple:(UIImage *)temple InFrameArray:(NSArray *)frameArray {
   Mat templeMat = [self cvMatFromImage:temple];

   NSMutableArray *frameArrayWithDetectedTemple = [[NSMutableArray alloc] init];

   for (UIImage *frame in frameArray) {
       Mat frameMat = [self cvMatFromImage:frame];

       //-- Step 1: Detect the keypoints using SURF Detector
       Ptr<FeatureDetector> detector = ORB::create();

       vector<KeyPoint> keypointsTemple, keypointsFrame;

       detector->detect(templeMat, keypointsTemple);
       detector->detect(frameMat, keypointsFrame);

       //-- Step 2: Calculate descriptors (feature vectors)
       Ptr<DescriptorExtractor> extractor = ORB::create();

       Mat descriptorsTemple, descriptorsFrame;

       extractor->compute(templeMat, keypointsTemple, descriptorsTemple);
       extractor->compute(frameMat, keypointsFrame, descriptorsFrame);

       //-- Step 3: Matching descriptor vectors using FLANN matcher
       Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce");
       vector<DMatch> matches;
       matcher->match(descriptorsTemple, descriptorsFrame, matches);

       double maxDist = 0;
       double minDist = 100;

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

           if (dist > maxDist)
               maxDist = dist;
       }

       //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )
       vector<DMatch> goodMatches;

       for (int i = 0; i < descriptorsTemple.rows; i++) {
           if (matches[i].distance < 3 * minDist) {
               goodMatches.push_back(matches[i]);
           }
       }

       Mat imgMatches;
       drawMatches(templeMat, keypointsTemple, frameMat, keypointsFrame, goodMatches, imgMatches, Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

       //-- Localize the object
       vector<Point2f> object;
       vector<Point2f> scene;

       for (int i = 0; i < goodMatches.size(); i++) {
           //-- Get the keypoints from the good matches
           object.push_back(keypointsTemple[goodMatches[i].queryIdx].pt);
           scene.push_back(keypointsFrame[goodMatches[i].trainIdx].pt);
       }

       Mat H = findHomography(object, scene, CV_RANSAC);

       //-- Get the corners from the image_1 ( the object to be "detected" )
       vector<Point2f> objectCorners(4);
       objectCorners[0] = cvPoint(0, 0);
       objectCorners[1] = cvPoint(templeMat.cols, 0);
       objectCorners[2] = cvPoint(templeMat.cols, templeMat.rows);
       objectCorners[3] = cvPoint(0, templeMat.rows);
       vector<Point2f> sceneCorners(4);

       perspectiveTransform(objectCorners, sceneCorners, H);

       //-- Draw lines between the corners (the mapped object in the scene - image_2 )
       line(imgMatches, sceneCorners[0] + Point2f(templeMat.cols, 0), sceneCorners[1] + Point2f(templeMat.cols, 0), Scalar(0, 255, 0), 4);
       line(imgMatches, sceneCorners[1] + Point2f(templeMat.cols, 0), sceneCorners[2] + Point2f(templeMat.cols, 0), Scalar(0, 255, 0), 4);
       line(imgMatches, sceneCorners[2] + Point2f(templeMat.cols, 0), sceneCorners[3] + Point2f(templeMat.cols, 0), Scalar(0, 255, 0), 4);
       line(imgMatches, sceneCorners[3] + Point2f(templeMat.cols, 0), sceneCorners[0] + Point2f(templeMat.cols, 0), Scalar(0, 255, 0), 4);

       //-- Show detected matches
       [frameArrayWithDetectedTemple addObject:[self imageFromCVMat:imgMatches]];
       break;
   }
   return frameArrayWithDetectedTemple;
}

[12:29]
#import <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>