content: package com.example.akshika.opencvtest;
  
  import android.Manifest;
  import android.app.Activity;
  import android.content.pm.PackageManager;
  import android.content.res.AssetManager;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.os.Bundle;
  import android.support.v4.app.ActivityCompat;
  import android.support.v4.content.ContextCompat;
  import android.support.v7.app.AppCompatActivity;
  import android.util.Log;
  import android.view.SurfaceView;
  import android.view.WindowManager;
  import android.widget.TextView;
  
  import org.opencv.android.BaseLoaderCallback;
  import org.opencv.android.CameraBridgeViewBase;
  import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
  import org.opencv.android.LoaderCallbackInterface;
  import org.opencv.android.OpenCVLoader;
  import org.opencv.android.Utils;
  import org.opencv.core.DMatch;
  import org.opencv.core.Mat;
  import org.opencv.core.MatOfByte;
  import org.opencv.core.MatOfDMatch;
  import org.opencv.core.MatOfKeyPoint;
  import org.opencv.core.Scalar;
  import org.opencv.features2d.DescriptorExtractor;
  import org.opencv.features2d.DescriptorMatcher;
  import org.opencv.features2d.FeatureDetector;
  import org.opencv.features2d.Features2d;
  import org.opencv.imgproc.Imgproc;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.LinkedList;
  import java.util.List;
  
  
  public class MainActivity extends Activity implements CameraBridgeViewBase.CvCameraViewListener2 {
  
      private static final String TAG = "OCVSample::Activity";
      private static final int REQUEST_PERMISSION = 100;
      private int w, h;
      private CameraBridgeViewBase mOpenCvCameraView;
      TextView tvName;
      Scalar RED = new Scalar(255, 0, 0);
      Scalar GREEN = new Scalar(0, 255, 0);
      FeatureDetector detector;
      DescriptorExtractor descriptor;
      DescriptorMatcher matcher;
      Mat descriptors2,descriptors1;
      Mat img1;
      MatOfKeyPoint keypoints1,keypoints2;
  
      static {
          if (!OpenCVLoader.initDebug())
              Log.d("ERROR", "Unable to load OpenCV");
          else
              Log.d("SUCCESS", "OpenCV loaded");
      }
  
      private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
          @Override
          public void onManagerConnected(int status) {
              switch (status) {
                  case LoaderCallbackInterface.SUCCESS: {
                      Log.i(TAG, "OpenCV loaded successfully");
                      mOpenCvCameraView.enableView();
                      try {
                          initializeOpenCVDependencies();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  break;
                  default: {
                      super.onManagerConnected(status);
                  }
                  break;
              }
          }
      };
  
      private void initializeOpenCVDependencies() throws IOException {
          mOpenCvCameraView.enableView();
          detector = FeatureDetector.create(FeatureDetector.ORB);
          descriptor = DescriptorExtractor.create(DescriptorExtractor.ORB);
          matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
          img1 = new Mat();
          AssetManager assetManager = getAssets();
          InputStream istr = assetManager.open("a.jpeg");
          Bitmap bitmap = BitmapFactory.decodeStream(istr);
          Utils.bitmapToMat(bitmap, img1);
          Imgproc.cvtColor(img1, img1, Imgproc.COLOR_RGB2GRAY);
          img1.convertTo(img1, 0); //converting the image to match with the type of the cameras image
          descriptors1 = new Mat();
          keypoints1 = new MatOfKeyPoint();
          detector.detect(img1, keypoints1);
          descriptor.compute(img1, keypoints1, descriptors1);
  
      }
  
  
      public MainActivity() {
  
          Log.i(TAG, "Instantiated new " + this.getClass());
      }
  
      /**
       * Called when the activity is first created.
       */
      @Override
      public void onCreate(Bundle savedInstanceState) {
  
          Log.i(TAG, "called onCreate");
          super.onCreate(savedInstanceState);
          getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
          setContentView(R.layout.layout);
  
          if(ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
              ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, REQUEST_PERMISSION);
          }
  
          mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.tutorial1_activity_java_surface_view);
          mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
          mOpenCvCameraView.setCvCameraViewListener(this);
          tvName = (TextView) findViewById(R.id.text1);
  
      }
  
      @Override
      public void onPause() {
          super.onPause();
          if (mOpenCvCameraView != null)
              mOpenCvCameraView.disableView();
      }
  
      @Override
      public void onResume() {
          super.onResume();
          if (!OpenCVLoader.initDebug()) {
              Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
              OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
          } else {
              Log.d(TAG, "OpenCV library found inside package. Using it!");
              mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
          }
      }
  
      public void onDestroy() {
          super.onDestroy();
          if (mOpenCvCameraView != null)
              mOpenCvCameraView.disableView();
      }
  
      public void onCameraViewStarted(int width, int height) {
          w = width;
          h = height;
      }
  
      public void onCameraViewStopped() {
      }
  
      public Mat recognize(Mat aInputFrame) {
  
          Imgproc.cvtColor(aInputFrame, aInputFrame, Imgproc.COLOR_RGB2GRAY);
          descriptors2 = new Mat();
          keypoints2 = new MatOfKeyPoint();
          detector.detect(aInputFrame, keypoints2);
          descriptor.compute(aInputFrame, keypoints2, descriptors2);
  
          // Matching
          MatOfDMatch matches = new MatOfDMatch();
          if (img1.type() == aInputFrame.type()) {
              matcher.match(descriptors1, descriptors2, matches);
          } else {
              return aInputFrame;
          }
          List<DMatch> matchesList = matches.toList();
  
          Double max_dist = 0.0;
          Double min_dist = 100.0;
  
          for (int i = 0; i < matchesList.size(); i++) {
              Double dist = (double) matchesList.get(i).distance;
              if (dist < min_dist)
                  min_dist = dist;
              if (dist > max_dist)
                  max_dist = dist;
          }
  
          LinkedList<DMatch> good_matches = new LinkedList<DMatch>();
          for (int i = 0; i < matchesList.size(); i++) {
              if (matchesList.get(i).distance <= (1.5 * min_dist))
                  good_matches.addLast(matchesList.get(i));
          }
  
          MatOfDMatch goodMatches = new MatOfDMatch();
          goodMatches.fromList(good_matches);
          Mat outputImg = new Mat();
          MatOfByte drawnMatches = new MatOfByte();
          if (aInputFrame.empty() || aInputFrame.cols() < 1 || aInputFrame.rows() < 1) {
              return aInputFrame;
          }
          Features2d.drawMatches(img1, keypoints1, aInputFrame, keypoints2, goodMatches, outputImg, GREEN, RED, drawnMatches, Features2d.NOT_DRAW_SINGLE_POINTS);
          Imgproc.resize(outputImg, outputImg, aInputFrame.size());
  
          return outputImg;
      }
  
      public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
          return recognize(inputFrame.rgba());
  
      }
  }