Jak używać dopasowania funkcji opencv do wykrywania fałszowania plików copy-move

Question

W moim projekcie opencv chcę wykryć fałszerstwa kopiowania w obrazie. Wiem, jak użyć FLANNU opencv do dopasowywania funkcji w 2 różnych obrazach, ale jestem tak zdezorientowany, jak używać FLANN do wykrywania fałszerstwa-fałszerstwa w obrazie.

P.S1: Otrzymuję punkty końcowe i deskryptory obrazu oraz utknąłem w klasie dopasowania elementów.

P.S2: Typ dopasowania funkcji nie jest dla mnie ważny.

Z góry dziękuję.

Aktualizacja:

tych zdjęć jest przykładem tego, co muszę

i tam jest kod, który pasuje do cech dwóch obrazów i zrobić coś podobnego na dwa obrazy (nie jeden), kod w rodzimym formacie opencv Android jest jak poniżej:

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

Nie wiem, czy dobrze jest używać punktów kluczowych do tego problemu. Wolałbym przetestować template matching (używając przesuwanego okna na twoim obrazie jako łatkę). W porównaniu z punktami kluczowymi, ta metoda ma tę wadę, że jest wrażliwa na rotację i skalę.

Jeśli chcesz użyć keypoints można:

• znaleźć zestaw keypoints (SURF przesiać, czy cokolwiek chcesz),
• obliczyć wynik dopasowania z każdym innym keypoints, z knnMatch Funkcja Miernika Siły Brute (cv::BFMatcher),

• utrzymuje zgodność między punktami różniczkowymi, tj. Punktami, których odległość jest większa niż zero (lub próg).

  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);