object recognition in real time on Android with FAST detector

Question

The aim of this work is to extract real-time key points from an existing image in a video scene processFrame has the execution that does not work, due to match, is that I can just display the key points of correspondence in the form of circles on the image in real time

class Sample1View extends SampleViewBase {
    public static final int     VIEW_MODE_RGBA   = 0;
    public static final int  VIEW_MODE_BLUE  = 1; 
    public static final int  VIEW_MODE_YELLOW = 2;
    public static final int  VIEW_MODE_DE = 3;
    private Mat mYuv;
    private Mat mRgba;
    private Mat mGraySubmat;
    private Mat mResult;
    private Mat mIntermediateMat;
 private Bitmap mBitmap;
 private int mViewMode;
 private Mat mColor;
 private Mat mHsv;
 TimingLogger timings;
   private Mat img1;
    private Mat descriptors;
    private MatOfKeyPoint keypoints;
    private FeatureDetector detector;
    private DescriptorExtractor descriptor;
    private DescriptorMatcher matcher;

 private static final String TAG ="Sample::View";

    public Sample1View(Context context) {
        super(context);
        mViewMode = VIEW_MODE_RGBA;

 try {
 img1=Utils.loadResource(getContext(), R.drawable.wings);
 } catch (IOException e) {
 // TODO Auto-generated catch block
 Log.w("Activity::LoadResource","Unable to load resource R.drawable.wings");
 e.printStackTrace();
 }
        descriptors = new Mat();
        keypoints = new MatOfKeyPoint();
        detector = FeatureDetector.create(FeatureDetector.FAST);
        detector.detect(img1, keypoints);
        descriptor = DescriptorExtractor.create(DescriptorExtractor.ORB);
        descriptor.compute(img1, keypoints, descriptors);
        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
    }

 @Override
 protected void onPreviewStarted(int previewWidth, int previewHeight) {
     Log.i(TAG, "preview Started");
     synchronized (this) {
         mYuv = new Mat(getFrameHeight() + getFrameHeight() / 2, getFrameWidth(), CvType.CV_8UC1);
         mGraySubmat = mYuv.submat(0, getFrameHeight(), 0, getFrameWidth());
         mRgba = new Mat();
         mIntermediateMat = new Mat();
         mBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Bitmap.Config.ARGB_8888); 
         mHsv = new Mat();
         mColor = new Mat();
         mResult = new Mat();
         }
 }

 @Override
 protected void onPreviewStopped() {
     Log.i(TAG, "preview Stopped");
     if(mBitmap != null) {
   mBitmap.recycle();
  }

  synchronized (this) {
            // Explicitly deallocate Mats
            if (mYuv != null)
                mYuv.release();
            if (mRgba != null)
                mRgba.release();
            if (mGraySubmat != null)
                mGraySubmat.release();
            if (mIntermediateMat != null)
                mIntermediateMat.release();
            mYuv = null;
            mRgba = null;
            mGraySubmat = null;
            mIntermediateMat = null;
            if (mResult != null)
             mResult.release();
            if (mHsv != null)
             mHsv.release();
            if (mColor != null)
             mColor.release();
            mColor = null;
         mResult = null;
         mHsv = null;
        }
    }

// cvt_YUVtoRGBtoHSV :

    @Override
    protected Bitmap processFrame(byte[] data) {

        mYuv.put(0, 0, data);
        final int viewMode = mViewMode;

                 ColorDetection.cvt_YUVtoRGBtoHSV(mYuv,mGraySubmat);

      MatOfKeyPoint mKeyPoints = new MatOfKeyPoint();
    MatOfDMatch  matches = new MatOfDMatch();
      detector.detect(mGraySubmat, mKeyPoints);
      descriptor.compute(mGraySubmat, mKeyPoints, mIntermediateMat);
      matcher.match(mIntermediateMat, descriptors, matches);
      mIntermediateMat2.create(resultSize, CvType.CV_8UC1);

      Features2d.drawMatches(mGraySubmat, mKeyPoints, mGraySubmat, mKeyPoints, matches, mIntermediateMat2);
      Imgproc.resize(mIntermediateMat2, mIntermediateMat2, mRgba.size());
      Imgproc.cvtColor(mIntermediateMat2, mRgba, Imgproc.COLOR_RGBA2BGRA, 4);
        break;
        }
    Bitmap bmp = mBitmap;

    try {
      Utils.matToBitmap(mRgba, bmp);

    } catch(Exception e) {
        Log.e("org.opencv.samples.*", "Utils.matToBitmap() throws an exception: " + e.getMessage());
        bmp.recycle();
        bmp = null;
    }
    return bmp;
    }

    public void setViewMode(int viewMode) {
     mViewMode = viewMode;
    }
}

and that in the Log

CvException [org.opencv.core.CvException: /home/reports/ci/slave/50-SDK/opencv/modules/features2d/src/draw.cpp:207: error: (-215) i1 >= 0 && i1 < static_cast(keypoints1.size()) in function void cv::drawMatches(const cv::Mat&, const std::vector&, const cv::Mat&, const std::vector&, const std::vector&, cv::Mat&, const Scalar&, const Scalar&, const std::vector&, int)

Nagy Attila Nagy Attila · Accepted Answer · 2014-01-31T17:51:45

This post is a little old but I give an answer to it yet.

Your drawMatches function's first four parameter is incorrect. The first two and the second two are the same.
You can change the first four parameters of drawMatches from (mGraySubmat, mKeyPoints, mGraySubmat, mKeyPoints, ...);
to
(mGraySubmat, mKeyPoints, img1, keypoints, ...);
or
(img1, keypoints, mGraySubmat, mKeyPoints, ...);
Use that one which is working for you.

For other readers if they have the same problem they can try to change the first two parameters with the second two parameters.
Ex.:
(image1, keypointsImage1, image2, keypointsImage2, ...);
to
(image2, keypointsImage2, image1, keypointsImage1, ...);

For me it's fixed my error.

object recognition in real time on Android with FAST detector

1 Answers