title: object recognition in real time on Android with FAST detector
body: <p>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</p>
  
  <pre><code>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;
          }
      }
  </code></pre>
  
  <p>// cvt_YUVtoRGBtoHSV :</p>
  
  <pre><code>    @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;
      }
  }
  </code></pre>
  
  <p>and that in the Log</p>
  
  <p>CvException [org.opencv.core.CvException: /home/reports/ci/slave/50-SDK/opencv/modules/features2d/src/draw.cpp:207: error: (-215) i1 >= 0 &amp;&amp; i1 &lt; static_cast(keypoints1.size()) in function void cv::drawMatches(const cv::Mat&amp;, const std::vector&amp;, const cv::Mat&amp;, const std::vector&amp;, const std::vector&amp;, cv::Mat&amp;, const Scalar&amp;, const Scalar&amp;, const std::vector&amp;, int)</p>