Come utilizzare la funzionalità di opencv corrispondente per il rilevamento della contraffazione copia-spostamento

Question

Nel mio progetto opencv, voglio rilevare la falsificazione di copia-spostamento in un'immagine. So come usare l'opencv FLANN per la corrispondenza delle funzioni in 2 immagini diverse, ma sono diventato così confuso su come usare FLANN per il rilevamento di falsietà di copia-spostamento in un'immagine.

P.S1: Ricevo i punti chiave e i descrittori dell'immagine e sono bloccato utilizzando la classe di corrispondenza delle funzionalità.

P.S2: il tipo di corrispondenza delle funzionalità non è importante per me.

Grazie in anticipo.

Aggiornamento:

queste immagini è un esempio di che cosa ho bisogno

e v'è un codice che corrisponde caratteristiche di due immagini e fare qualcosa di simile sul due immagini (non una sola), il codice in formato opencv nativo Android è come di seguito:

vector<KeyPoint> keypoints; 
     Mat descriptors; 

     // Create a SIFT keypoint detector. 
     SiftFeatureDetector detector; 
     detector.detect(image_gray, keypoints); 
     LOGI("Detected %d Keypoints ...", (int) keypoints.size()); 

     // Compute feature description. 
     detector.compute(image, keypoints, descriptors); 
     LOGI("Compute Feature ..."); 


     FlannBasedMatcher matcher; 
     std::vector<DMatch> matches; 
     matcher.match(descriptors, descriptors, matches); 

     double max_dist = 0; double min_dist = 100; 

     //-- Quick calculation of max and min distances between keypoints 
      for(int i = 0; i < descriptors.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 < descriptors.rows; i++) 
      { if(matches[i].distance <= max(2*min_dist, 0.02)) 
      { good_matches.push_back(matches[i]); } 
      } 

      //-- Draw only "good" matches 
      Mat img_matches; 
      drawMatches(image, keypoints, image, keypoints, 
         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); 
      imwrite(imgOutFile, img_matches); 

Answer 1

Non so se sia una buona idea utilizzare i punti chiave per questo problema. Preferisco testare template matching (usando una finestra scorrevole sull'immagine come patch). Rispetto ai keypoints, questo metodo ha lo svantaggio di essere sensibile alla rotazione e alla scala.

Se si desidera utilizzare punti chiave, è possibile:

• trovare una serie di punti chiave (SURF, setacciare, o quello che vuole),
• calcolare il punteggio di corrispondenza con tutti gli altri punti chiave, con il knnMatch funzione Brute Force Matcher (cv::BFMatcher),

• mantenere le corrispondenze tra punti distinti, ovvero punti la cui distanza è maggiore di zero (o una soglia).

  int nknn = 10; // max number of matches for each keypoint 
  double minDist = 0.5; // distance threshold 
  
  // Match each keypoint with every other keypoints 
  cv::BFMatcher matcher(cv::NORM_L2, false); 
  std::vector< std::vector<cv::DMatch> > matches; 
  matcher.knnMatch(descriptors, descriptors, matches, nknn); 
  
  double max_dist = 0; double min_dist = 100; 
  
  //-- Quick calculation of max and min distances between keypoints 
  for(int i = 0; i < descriptors.rows; i++) 
  { 
      double dist = matches[i].distance; 
      if(dist < min_dist) min_dist = dist; 
      if(dist > max_dist) max_dist = dist; 
  } 
  
  // Compute distance and store distant matches 
  std::vector<cv::DMatch> good_matches; 
  for (int i = 0; i < matches.size(); i++) 
  { 
      for (int j = 0; j < matches[i].size(); j++) 
      { 
       // The METRIC distance 
       if(matches[i][j].distance> max(2*min_dist, 0.02)) 
        continue; 
  
       // The PIXELIC distance 
       Point2f pt1 = keypoints[queryIdx].pt; 
       Point2f pt2 = keypoints[trainIdx].pt; 
  
       double dist = cv::norm(pt1 - pt2); 
       if (dist > minDist) 
        good_matches.push_back(matches[i][j]); 
      } 
  } 
  
  Mat img_matches; 
  drawMatches(image_gray, keypoints, image_gray, keypoints, good_matches, img_matches);