Android – SURF description faster with FAST detection

androidopencvsiftsurf

for my master thesis, i am running some test on the SIFT SURF en FAST algoritms for logo detection on smartphones.

when i simply time the detection, description en matching for some methods i get the following results.

For a SURF detector and SURF descriptor:

180 keypoints found

1,994 seconds keypoint calculation time (SURF)
4,516 seconds description time (SURF)
0.282 seconds matching time (SURF)

when I use a FAST detector in stead of the SURF detector

319 keypoints found

0.023 seconds keypoint calculation time (FAST)
1.295 seconds description time (SURF)
0.397 seconds matching time (SURF)

The FAST detector is much faster than the SURF detector, and even detects almost twice as many keypoints 100 times faster. These results are predictable.

The next step though is not a predicted result. How is it possible that de SURF descriptor is faster with the 319 FAST keypoints then with the 180 SURF keypoints?

From what I know, the description has no relation with the detection algorithm… yet these results are not as predicted.

does any one know how this is possible?

here is the code:

    FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
    //FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
    Imgproc.cvtColor(image1, image1, Imgproc.COLOR_RGBA2RGB);
    Imgproc.cvtColor(image2, image2, Imgproc.COLOR_RGBA2RGB);

    DescriptorExtractor SurfExtractor = DescriptorExtractor
    .create(DescriptorExtractor.SURF);


    //extract keypoints
    long time= System.currentTimeMillis();
    detector.detect(image1, keypoints);
    Log.d("LOG!", "number of query Keypoints= " + keypoints.size());
    detector.detect(image2, logoKeypoints);
    Log.d("LOG!", "number of logo Keypoints= " + logoKeypoints.size());
    Log.d("LOG!", "keypoint calculation time elapsed" + (System.currentTimeMillis() -time));

    //Descript keypoints
    long time2 = System.currentTimeMillis();
    Mat descriptors = new Mat();
    Mat logoDescriptors = new Mat();
    Log.d("LOG!", "logo type" + image2.type() + "  intype" + image1.type());
    SurfExtractor.compute(image1, keypoints, descriptors);
    SurfExtractor.compute(image2, logoKeypoints, logoDescriptors);
    Log.d("LOG!", "Description time elapsed" + (System.currentTimeMillis()- time2));

Best Answer

AFAIK the most time consuming part of SURF descriptor extraction is subpixel extraction of patch having (2.8*keypoint.size x 2.8*keypoint.size) size around the every keypoint.

So here is my guess: keypoints found by FAST detector always have their size equal to 7 but SURF detector can find keypoints of much bigger size. So 180 "big" keypoints are processed longer than 319 "small".

Related Solutions

Android – Fling gesture detection on grid layout

Thanks to Code Shogun, whose code I adapted to my situation.

Let your activity implementOnClickListener as usual:

public class SelectFilterActivity extends Activity implements OnClickListener {

  private static final int SWIPE_MIN_DISTANCE = 120;
  private static final int SWIPE_MAX_OFF_PATH = 250;
  private static final int SWIPE_THRESHOLD_VELOCITY = 200;
  private GestureDetector gestureDetector;
  View.OnTouchListener gestureListener;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    /* ... */

    // Gesture detection
    gestureDetector = new GestureDetector(this, new MyGestureDetector());
    gestureListener = new View.OnTouchListener() {
      public boolean onTouch(View v, MotionEvent event) {
        return gestureDetector.onTouchEvent(event);
      }
    };

  }

  class MyGestureDetector extends SimpleOnGestureListener {
    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
      try {
        if (Math.abs(e1.getY() - e2.getY()) > SWIPE_MAX_OFF_PATH)
          return false;
        // right to left swipe
        if(e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
          Toast.makeText(SelectFilterActivity.this, "Left Swipe", Toast.LENGTH_SHORT).show();
        } else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
          Toast.makeText(SelectFilterActivity.this, "Right Swipe", Toast.LENGTH_SHORT).show();
        }
      } catch (Exception e) {
         // nothing
      }
      return false;
    }

    @Override
    public boolean onDown(MotionEvent e) {
      return true;
    }
  }
}

Attach your gesture listener to all the views you add to the main layout;

// Do this for each view added to the grid
imageView.setOnClickListener(SelectFilterActivity.this); 
imageView.setOnTouchListener(gestureListener);

Watch in awe as your overridden methods are hit, both the onClick(View v) of the activity and the onFling of the gesture listener.

public void onClick(View v) {
  Filter f = (Filter) v.getTag();
  FilterFullscreenActivity.show(this, input, f);
}

The post 'fling' dance is optional but encouraged.

C++ – OpenCV (C++) using SIFT descriptors increases the number of detected features

First of all, as you can see in the documentation cv::DescriptorExtractor::compute take a std::vector<cv::Keypoints> in argument which in non const. It means that this vector can be modified by cv::DescriptorExtractor::compute. In practice, KeyPointsFilter::runByImageBorder and KeyPointsFilter::runByKeypointSize (two non-const functions) will be applied to the vector and will remove the keypoint for which a descriptor cannot be computed. No re-extraction of keypoints will be done. You should post the few lines of code you are using for further diagnostic.

Well, I finally found where the problem occurs: cv::SiftDescriptorExtractor::compute method calls SIFT::operator() which (re)calculate orientation of features and also duplicates the points with several dominant orientations. Solution could be to change descriptorParams.recalculateAngles to false.

Best Answer

Related Solutions

Android – Fling gesture detection on grid layout

C++ – OpenCV (C++) using SIFT descriptors increases the number of detected features

Related Topic