OpenCV3 安卓应用编程：1~6 全

$ git clone git://code.opencv.org/opencv.git <opencv_source>
$ cd <opencv_source>/platforms
$ sh ./scripts/cmake_android_arm.sh
$ cd build_android_arm
$ make -j8

#!/bin/sh
cd `dirname $0`/..
mkdir -p build_android_arm
cd build_android_arm
cmake -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON - DCMAKE_TOOLCHAIN_FILE=../android/android.toolchain.cmake $@ ../..

$ adb install <opencv>/apk/OpenCV_3.0.0_Manager_3.00_armeabi-v7a.apk

$ adb devices

sudo sh -c "adb kill-server && start-server"

$ cd /etc/udev/rules.d/
$ sudo touch 51-android.rules
$ sudo chmod a+r 51-android-rules

$ sudo gedit 51-android-rules

SUBSYSTEM=="usb", ATTR{idVendor}=="<vendor_id>", MODE="0666", GROUP="plugdev"

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=
  "http://schemas.android.com/apk/res/android"
  package="com.nummist.secondsight"
  android:versionCode="1"
  android:versionName="1.0">
  <uses-sdk
    android:minSdkVersion="8"
    android:targetSdkVersion="22" />
  <uses-permission android:name="android.permission.CAMERA" />
  <uses-permission android:name=
    "android.permission.WRITE_EXTERNAL_STORAGE" />
  <uses-feature android:name="android.hardware.camera" />
  <uses-feature android:name="android.hardware.camera.autofocus"
    android:required="false" />
  <uses-feature android:name="android.hardware.camera.flash"
    android:required="false" />
  <application
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme">
    <activity
      android:name="com.nummist.secondsight.CameraActivity"
      android:label="@string/app_name"
      android:screenOrientation="landscape">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name=
          "android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
    <activity
      android:name="com.nummist.secondsight.LabActivity"
      android:label="@string/app_name"
      android:screenOrientation="landscape">
    </activity>
  </application>
</manifest>

<menu xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto">
  <item
    android:id="@+id/menu_next_camera"
    app:showAsAction="ifRoom|withText"    android:title="@string/menu_next_camera"{ }/>
  <item
    android:id="@+id/menu_take_photo"
    app:showAsAction="always|withText"
    android:title="@string/menu_take_photo"{ }/>
</menu>

<menu xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto">>>
  <item
    android:id="@+id/menu_delete"
    app:showAsAction="ifRoom|withText"
    android:title="@string/delete" />
  <item
    android:id="@+id/menu_edit"
    app:showAsAction="ifRoom|withText"
    android:title="@string/edit" />
  <item
    android:id="@+id/menu_share"
    app:showAsAction="ifRoom|withText"
    android:title="@string/share" />
</menu>

<style name="AppBaseTheme"
        parent="Theme.AppCompat.Light.DarkActionBar">

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="app_name">Second Sight</string>
  <string name="delete">Delete</string>
  <string name="edit">Edit</string>
  <string name="menu_next_camera">Next Cam</string>
  <string name="menu_take_photo">Take Photo</string>
  <string name="menu_image_size">Size</string>
  <string name="photo_delete_prompt_message">This photo is saved
    in your Gallery. Do you want to delete it?</string>
  <string name="photo_delete_prompt_title">Delete photo?</string>
  <string name="photo_error_message">Failed to save photo</string>
  <string name="photo_edit_chooser_title">Edit photo
    with&#8230;</string>
  <string name="photo_send_chooser_title">Share photo
    with&#8230;</string>
  <string name="photo_send_extra_subject">My photo from Second
    Sight</string>
  <string name="photo_send_extra_text">Check out my photo from the Second Sight app! http://nummist.com/opencv/</string>
  <string name="share">Share</string>
</resources>

// Use the deprecated Camera class.
@SuppressWarnings("deprecation")
public class CameraActivity extends ActionBarActivity
    implements CvCameraViewListener2 {
  // A tag for log output.
  private static final String TAG =
    CameraActivity.class.getSimpleName();
  // A key for storing the index of the active camera.
  private static final String STATE_CAMERA_INDEX = "cameraIndex";
  // A key for storing the index of the active image size.
  private static final String STATE_IMAGE_SIZE_INDEX =
    "imageSizeIndex";
  // An ID for items in the image size submenu.
  private static final int MENU_GROUP_ID_SIZE = 2;
  // The index of the active camera.
  private int mCameraIndex;
  // The index of the active image size.
  private int mImageSizeIndex;
  // Whether the active camera is front-facing.
  // If so, the camera view should be mirrored.
  private boolean mIsCameraFrontFacing;
  // The number of cameras on the device.
  private int mNumCameras;
  // The camera view.
  private CameraBridgeViewBase mCameraView;
  // The image sizes supported by the active camera.
  private List<Size> mSupportedImageSizes;
  // Whether the next camera frame should be saved as a photo.
  private boolean mIsPhotoPending;
  // A matrix that is used when saving photos.
  private Mat mBgr;
  // Whether an asynchronous menu action is in progress.
  // If so, menu interaction should be disabled.
  private boolean mIsMenuLocked;
  // The OpenCV loader callback.
  private BaseLoaderCallback mLoaderCallback =
    new BaseLoaderCallback(this) {
@Override
public void onManagerConnected(final int status) {
  switch (status) {
  case LoaderCallbackInterface.SUCCESS:
    Log.d(TAG, "OpenCV loaded successfully");
    mCameraView.enableView();
    mBgr = new Mat();
    break;
  default:
    super.onManagerConnected(status);
    break;
  }
}

// Suppress backward incompatibility errors because we provide
  // backward-compatible fallbacks.
  @SuppressLint("NewApi")
  @Override
  protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Window window = getWindow();
    window.addFlags(
      WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    if (savedInstanceState != null) {
      mCameraIndex = savedInstanceState.getInt(
        STATE_CAMERA_INDEX, 0);
      mImageSizeIndex = savedInstanceState.getInt(
        STATE_IMAGE_SIZE_INDEX, 0);
    } else {
      mCameraIndex = 0;
      mImageSizeIndex = 0;
    }
    final Camera camera;
    if (Build.VERSION.SDK_INT >=
      Build.VERSION_CODES.GINGERBREAD) {
      CameraInfo cameraInfo = new CameraInfo();
      Camera.getCameraInfo(mCameraIndex, cameraInfo);
      mIsCameraFrontFacing =
        (cameraInfo.facing ==
          CameraInfo.CAMERA_FACING_FRONT);
      mNumCameras = Camera.getNumberOfCameras();
      camera = Camera.open(mCameraIndex);
    } else { // pre-Gingerbread
      // Assume there is only 1 camera and it is rear-facing.
      mIsCameraFrontFacing = false;
      mNumCameras = 1;
      camera = Camera.open();
    }
    final Parameters parameters = camera.getParameters();
    camera.release();
    mSupportedImageSizes =
      parameters.getSupportedPreviewSizes();
    final Size size = mSupportedImageSizes.get(mImageSizeIndex);
    mCameraView = new JavaCameraView(this, mCameraIndex);
    mCameraView.setMaxFrameSize(size.width, size.height);
    mCameraView.setCvCameraViewListener(this);
    setContentView(mCameraView);
  }
  public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the current camera index.
    savedInstanceState.putInt(STATE_CAMERA_INDEX, mCameraIndex);
    // Save the current image size index.
    savedInstanceState.putInt(STATE_IMAGE_SIZE_INDEX,
      mImageSizeIndex);
    super.onSaveInstanceState(savedInstanceState);
  }

// Suppress backward incompatibility errors because we provide
  // backward-compatible fallbacks.
  @SuppressLint("NewApi")
  @Override
  public void recreate() {
    if (Build.VERSION.SDK_INT >=
      Build.VERSION_CODES.HONEYCOMB) {
      super.recreate();
    } else {
      finish();
      startActivity(getIntent());
    }
  }

@Override
  public void onPause() {
    if (mCameraView != null) {
      mCameraView.disableView();
    }
    super.onPause();
  }
  @Override
  public void onResume() {
    super.onResume();
    OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0,
      this, mLoaderCallback);
    mIsMenuLocked = false;
  }
  @Override
  public void onDestroy() {
    if (mCameraView != null) {
      mCameraView.disableView();
    }
    super.onDestroy();
  }

@Override
  public boolean onCreateOptionsMenu(final Menu menu) {
    getMenuInflater().inflate(R.menu.activity_camera, menu);
    if (mNumCameras < 2) {
      // Remove the option to switch cameras, since there is
      // only 1.
      menu.removeItem(R.id.menu_next_camera);
    }
    int numSupportedImageSizes = mSupportedImageSizes.size();
    if (numSupportedImageSizes > 1) {
      final SubMenu sizeSubMenu = menu.addSubMenu(
        R.string.menu_image_size);
      for (int i = 0; i < numSupportedImageSizes; i++) {
        final Size size = mSupportedImageSizes.get(i);
        sizeSubMenu.add(MENU_GROUP_ID_SIZE, i, Menu.NONE,
          String.format("%dx%d", size.width, size.height));
      }
    }
    return true;
  }
  // Suppress backward incompatibility errors because we provide
  // backward-compatible fallbacks (for recreate).
  @SuppressLint("NewApi")
  @Override
  public boolean onOptionsItemSelected(final MenuItem item) {
    if (mIsMenuLocked) {
      return true;
    }
    if (item.getGroupId() == MENU_GROUP_ID_SIZE) {
      mImageSizeIndex = item.getItemId();
      recreate();
      return true;
    }
    switch (item.getItemId()) {
    case R.id.menu_next_camera:
      mIsMenuLocked = true;
      // With another camera index, recreate the activity.
      mCameraIndex++;
      if (mCameraIndex == mNumCameras) {
        mCameraIndex = 0;
      }
      mImageSizeIndex = 0;
      recreate();
      return true;
    case R.id.menu_take_photo:
      mIsMenuLocked = true;
      // Next frame, take the photo.
      mIsPhotoPending = true;
      return true;
    default:
      return super.onOptionsItemSelected(item);
    }
  }

@Override
  public void onCameraViewStarted(final int width,
    final int height) {
  }
  @Override
  public void onCameraViewStopped() {
  }
  @Override
  public Mat onCameraFrame(final CvCameraViewFrame inputFrame) {
    final Mat rgba = inputFrame.rgba();
    if (mIsPhotoPending) {
      mIsPhotoPending = false;
      takePhoto(rgba);
    }
    if (mIsCameraFrontFacing) {
      // Mirror (horizontally flip) the preview.
      Core.flip(rgba, rgba, 1);
    }
    return rgba;
  }

private void takePhoto(final Mat rgba) {
    // Determine the path and metadata for the photo.
    final long currentTimeMillis = System.currentTimeMillis();
    final String appName = getString(R.string.app_name);
    final String galleryPath =
      Environment.getExternalStoragePublicDirectory(
        Environment.DIRECTORY_PICTURES).toString();
    final String albumPath = galleryPath + File.separator +
      appName;
    final String photoPath = albumPath + File.separator +
      currentTimeMillis + LabActivity.PHOTO_FILE_EXTENSION;
    final ContentValues values = new ContentValues();
    values.put(MediaStore.MediaColumns.DATA, photoPath);
    values.put(Images.Media.MIME_TYPE,
      LabActivity.PHOTO_MIME_TYPE);
    values.put(Images.Media.TITLE, appName);
    values.put(Images.Media.DESCRIPTION, appName);
    values.put(Images.Media.DATE_TAKEN, currentTimeMillis);
    // Ensure that the album directory exists.
    File album = new File(albumPath);
    if (!album.isDirectory() && !album.mkdirs()) {
      Log.e(TAG, "Failed to create album directory at " +
        albumPath);
      onTakePhotoFailed();
      return;
    }
    // Try to create the photo.
    Imgproc.cvtColor(rgba, mBgr, Imgproc.COLOR_RGBA2BGR, 3);
    if (!Imgcodecs.imwrite(photoPath, mBgr)) {
      Log.e(TAG, "Failed to save photo to " + photoPath);
      onTakePhotoFailed();
    }
    Log.d(TAG, "Photo saved successfully to " + photoPath);
    // Try to insert the photo into the MediaStore.
    Uri uri;
    try {
      uri = getContentResolver().insert(
        Images.Media.EXTERNAL_CONTENT_URI, values);
    } catch (final Exception e) {
      Log.e(TAG, "Failed to insert photo into MediaStore");
      e.printStackTrace();
      // Since the insertion failed, delete the photo.
      File photo = new File(photoPath);
      if (!photo.delete()) {
        Log.e(TAG, "Failed to delete non-inserted photo");
      }
      onTakePhotoFailed();
      return;
    }
    // Open the photo in LabActivity.
    final Intent intent = new Intent(this, LabActivity.class);
    intent.putExtra(LabActivity.EXTRA_PHOTO_URI, uri);
    intent.putExtra(LabActivity.EXTRA_PHOTO_DATA_PATH,
      photoPath);
    startActivity(intent);
  }
  private void onTakePhotoFailed() {
    mIsMenuLocked = false;
    // Show an error message.
    final String errorMessage =
      getString(R.string.photo_error_message);
    runOnUiThread(new Runnable() {
      @Override
      public void run() {
        Toast.makeText(CameraActivity.this, errorMessage,
          Toast.LENGTH_SHORT).show();
      }
    });
  }
}

public class LabActivity extends ActionBarActivityActionBarActivity {
  public static final String PHOTO_FILE_EXTENSION = ".png";
  public static final String PHOTO_MIME_TYPE = "image/png";
  public static final String EXTRA_PHOTO_URI =
    "com.nummist.secondsight.LabActivity.extra.PHOTO_URI";
  public static final String EXTRA_PHOTO_DATA_PATH =
    "com.nummist.secondsight.LabActivity.extra.PHOTO_DATA_PATH";
  private Uri mUri;
  private String mDataPath;
  @Override
  protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Intent intent = getIntent();
    mUri = intent.getParcelableExtra(EXTRA_PHOTO_URI);
    mDataPath = intent.getStringExtra(EXTRA_PHOTO_DATA_PATH);
    final ImageView imageView = new ImageView(this);
    imageView.setImageURI(mUri);
    setContentView(imageView);
  }

@Override
  public boolean onCreateOptionsMenu(final Menu menu) {
    getMenuInflater().inflate(R.menu.activity_lab, menu);
    return true;
  }
  @Override
  public boolean onOptionsItemSelected(final MenuItem item) {
    switch (item.getItemId()) {
    case R.id.menu_delete:
      deletePhoto();
      return true;
    case R.id.menu_edit:
      editPhoto();
      return true;
    case R.id.menu_share:
      sharePhoto();
      return true;
    default:
      return super.onOptionsItemSelected(item);
    }
  }
}

/*
   * Show a confirmation dialog. On confirmation, the photo is
   * deleted and the activity finishes.
   */
  private void deletePhoto() {
    final AlertDialog.Builder alert = new AlertDialog.Builder(
      LabActivity.this);
    alert.setTitle(R.string.photo_delete_prompt_title);
    alert.setMessage(R.string.photo_delete_prompt_message);
    alert.setCancelable(false);
    alert.setPositiveButton(R.string.delete,
  new DialogInterface.OnClickListener() {
  @Override
  public void onClick(final DialogInterface dialog,
    final int which) {
    getContentResolver().delete(
      Images.Media.EXTERNAL_CONTENT_URI,
      MediaStore.MediaColumns.DATA + "=?",
      new String[] { mDataPath });
    finish();
  }
});
    alert.setNegativeButton(android.R.string.cancel, null);
    alert.show();
  }

/*
   * Show a chooser so that the user may pick an app for editing
   * the photo.
   */
  private void editPhoto() {
    final Intent intent = new Intent(Intent.ACTION_EDIT);
    intent.setDataAndType(mUri, PHOTO_MIME_TYPE);
    startActivity(Intent.createChooser(intent,
      getString(R.string.photo_edit_chooser_title)));
  }

/*
   * Show a chooser so that the user may pick an app for sending
   * the photo.
   */
  private void sharePhoto() {
    final Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setType(PHOTO_MIME_TYPE);
    intent.putExtra(Intent.EXTRA_STREAM, mUri);
    intent.putExtra(Intent.EXTRA_SUBJECT,
      getString(R.string.photo_send_extra_subject));
    intent.putExtra(Intent.EXTRA_TEXT,
      getString(R.string.photo_send_extra_text));
    startActivity(Intent.createChooser(intent,
      getString(R.string.photo_send_chooser_title)));
  }
}

public interface Filter {
  public abstract void apply(final Mat src, final Mat dst);
}

public class NoneFilter implements Filter {
  @Override
  public void apply(final Mat src, final Mat dst) {
    // Do nothing.
  }
}

dst.r = funcR(src.r, src.g, src.b)
dst.g = funcG(src.r, src.g, src.b)
dst.b = funcB(src.r, src.g, src.b)

public class RecolorRCFilter implements Filter {
  private final ArrayList<Mat> mChannels = new ArrayList<Mat>(4);
  @Override
  public void apply(final Mat src, final Mat dst) {
    Core.split(src, mChannels);
    final Mat g = mChannels.get(1);
    final Mat b = mChannels.get(2);
    // dst.g = 0.5 * src.g + 0.5 * src.b
    Core.addWeighted(g, 0.5, b, 0.5, 0.0, g);
    // dst.b = dst.g
    mChannels.set(2, g);
    Core.merge(mChannels, dst);
  }
}

// dst.b = min(dst.r, dst.g, dst.b)
    Core.min(b, r, b);
    Core.min(b, g, b);

// dst.b = max(dst.r, dst.g, dst.b)
    Core.max(b, r, b);
    Core.max(b, g, b);

dst.r = funcR(src.r) where funcR interpolates pointsR
dst.g = funcG(src.g) where funcG interpolates pointsG
dst.b = funcB(src.b) where funcB interpolates pointsB

public class CurveFilter implements Filter {
  // The lookup table.
  private final Mat mLUT = new MatOfInt();
  public CurveFilter(
    final double[] vValIn, final double[] vValOut,
    final double[] rValIn, final double[] rValOut,
    final double[] gValIn, final double[] gValOut,
    final double[] bValIn, final double[] bValOut) {
    // Create the interpolation functions.
    UnivariateFunction vFunc = newFunc(vValIn, vValOut);
    UnivariateFunction rFunc = newFunc(rValIn, rValOut);
    UnivariateFunction gFunc = newFunc(gValIn, gValOut);
    UnivariateFunction bFunc = newFunc(bValIn, bValOut);
    // Create and populate the lookup table.
    mLUT.create(256, 1, CvType.CV_8UC4);
    for (int i = 0; i < 256; i++) {
      final double v = vFunc.value(i);
      final double r = rFunc.value(v);
      final double g = gFunc.value(v);
      final double b = bFunc.value(v);
      mLUT.put(i, 0, r, g, b, i); // alpha is unchanged
    }
  }
  @Override
  public void apply(final Mat src, final Mat dst) {
    // Apply the lookup table.
    Core.LUT(src, mLUT, dst);
  }
  private UnivariateFunction newFunc(final double[] valIn,
    final double[] valOut) {
    UnivariateInterpolator interpolator;
    if (valIn.length > 2) {
      interpolator = new SplineInterpolator();
    } else {
      interpolator = new LinearInterpolator();
    }
    return interpolator.interpolate(valIn, valOut);
  }
}

public class PortraCurveFilter extends CurveFilter {
  public PortraCurveFilter() {
    super(
      new double[] { 0, 23, 157, 255 }, // vValIn
      new double[] { 0, 20, 173, 255 }, // vValOut
      new double[] { 0, 69, 213, 255 }, // rValIn
      new double[] { 0, 69, 218, 255 }, // rValOut
      new double[] { 0, 52, 189, 255 }, // gValIn
      new double[] { 0, 47, 196, 255 }, // gValOut
      new double[] { 0, 41, 231, 255 }, // bValIn
      new double[] { 0, 46, 228, 255 }); // bValOut
  }
}

new double[] { 0, 255 }, // vValIn
      new double[] { 0, 255 }, // vValOut
      new double[] { 0, 59, 202, 255 }, // rValIn
      new double[] { 0, 54, 210, 255 }, // rValOut
      new double[] { 0, 27, 196, 255 }, // gValIn
      new double[] { 0, 21, 207, 255 }, // gValOut
      new double[] { 0, 35, 205, 255 }, // bValIn
      new double[] { 0, 25, 227, 255 }); // bValOut

new double[] { 0, 128, 221, 255 }, // vValIn
      new double[] { 0, 118, 215, 255 }, // vValOut
      new double[] { 0, 25, 122, 165, 255 }, // rValIn
      new double[] { 0, 21, 153, 206, 255 }, // rValOut
      new double[] { 0, 25, 95, 181, 255 }, // gValIn
      new double[] { 0, 21, 102, 208, 255 }, // gValOut
      new double[] { 0, 35, 205, 255 }, // bValIn
      new double[] { 0, 25, 227, 255 }); // bValOut

new double[] { 0, 255 }, // vValIn
      new double[] { 0, 255 }, // vValOut
      new double[] { 0, 56, 211, 255 }, // rValIn
      new double[] { 0, 22, 255, 255 }, // rValOut
      new double[] { 0, 56, 208, 255 }, // gValIn
      new double[] { 0, 39, 226, 255 }, // gValOut
      new double[] { 0, 255 }, // bValIn
      new double[] { 20, 235 }); // bValOut

{{ 0, -1,  0},
 {-1,  4, -1},
 { 0, -1,  0}}

{{ 0, -1,  0},
 {-1,  5, -1},
 { 0, -1,  0}}

{{0.04, 0.04, 0.04, 0.04, 0.04},
 {0.04, 0.04, 0.04, 0.04, 0.04},
 {0.04, 0.04, 0.04, 0.04, 0.04},
 {0.04, 0.04, 0.04, 0.04, 0.04},
 {0.04, 0.04, 0.04, 0.04, 0.04}}

{{ -3,  0,   3},
 {-10,  0,  10},
 { -3,  0,   3}}

{{ -3, -10, -3},
 {  0,   0,  0},
 {  3,  10,  3}}

public class StrokeEdgesFilter implements Filter {
  private final Mat mKernel = new MatOfInt(
    0, 0,   1, 0, 0,
    0, 1,   2, 1, 0,
    1, 2, -16, 2, 1,
    0, 1,   2, 1, 0,
    0, 0,   1, 0, 0
  );
  private final Mat mEdges = new Mat();
  @Override
  public void apply(final Mat src, final Mat dst) {
    Imgproc.filter2D(src, mEdges, -1, mKernel);
    Core.bitwise_not(mEdges, mEdges);
    Core.multiply(src, mEdges, dst, 1.0/255.0);
  }
}

<string name="menu_next_curve_filter">Next Curve</string>
<string name="menu_next_mixer_filter">Next Mixer</string>
<string name="menu_next_convolution_filter">Next Kernel</string>

<menu xmlns:android="http://schemas.android.com/apk/res/android">
  <item
    android:id="@+id/menu_next_curve_filter"
    app:showAsAction="ifRoom|withText"
    android:title="@string/menu_next_curve_filter" />
  <item
    android:id="@+id/menu_next_mixer_filter"
    app:showAsAction="ifRoom|withText"
    android:title="@string/menu_next_mixer_filter" />
  <item
    android:id="@+id/menu_next_convolution_filter"
    app:showAsAction="ifRoom|withText"
    android:title="@string/menu_next_convolution_filter" />
  <item
    android:id="@+id/menu_next_camera"
    app:showAsAction="ifRoom|withText"
    android:title="@string/menu_next_camera" />
  <item
    android:id="@+id/menu_take_photo"
    app:showAsAction="always|withText"
    android:title="@string/menu_take_photo" />
</menu>

// Keys for storing the indices of the active filters.
private static final String STATE_CURVE_FILTER_INDEX =
  "curveFilterIndex";
private static final String STATE_MIXER_FILTER_INDEX =
  "mixerFilterIndex";
private static final String STATE_CONVOLUTION_FILTER_INDEX =
  "convolutionFilterIndex";
// The filters.
private Filter[] mCurveFilters;
private Filter[] mMixerFilters;
private Filter[] mConvolutionFilters;
// The indices of the active filters.
private int mCurveFilterIndex;
private int mMixerFilterIndex;
private int mConvolutionFilterIndex;

private BaseLoaderCallback mLoaderCallback =
  new BaseLoaderCallback(this) {
  @Override
  public void onManagerConnected(final int status) {
    switch (status) {
    case LoaderCallbackInterface.SUCCESS:
      Log.d(TAG, "OpenCV loaded successfully");
      mCameraView.enableView();
      mBgr = new Mat();
      mCurveFilters = new Filter[] {
        new NoneFilter(),
        new PortraCurveFilter(),
        new ProviaCurveFilter(),
        new VelviaCurveFilter(),
        new CrossProcessCurveFilter()
      };
      mMixerFilters = new Filter[] {
        new NoneFilter(),
        new RecolorRCFilter(),
        new RecolorRGVFilter(),
        new RecolorCMVFilter()
      };
      mConvolutionFilters = new Filter[] {
        new NoneFilter(),
        new StrokeEdgesFilter()
      };
      break;
    default:
      super.onManagerConnected(status);
      break;
    }
  }
};

protected void onCreate(final Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  final Window window = getWindow();
  window.addFlags(
    WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  if (savedInstanceState != null) {
    mCameraIndex = savedInstanceState.getInt(
      STATE_CAMERA_INDEX, 0);
    mImageSizeIndex = savedInstanceState.getInt(
      STATE_IMAGE_SIZE_INDEX, 0);
    mCurveFilterIndex = savedInstanceState.getInt(
      STATE_CURVE_FILTER_INDEX, 0);
    mMixerFilterIndex = savedInstanceState.getInt(
      STATE_MIXER_FILTER_INDEX, 0);
    mConvolutionFilterIndex = savedInstanceState.getInt(
      STATE_CONVOLUTION_FILTER_INDEX, 0);
  } else {
    mCameraIndex = 0;
    mImageSizeIndex = 0;
    mCurveFilterIndex = 0;
    mMixerFilterIndex = 0;
    mConvolutionFilterIndex = 0;
  }
  // ...
}

public void onSaveInstanceState(Bundle savedInstanceState) {
  // Save the current camera index.
  savedInstanceState.putInt(STATE_CAMERA_INDEX, mCameraIndex);
  // Save the current image size index.
  savedInstanceState.putInt(STATE_IMAGE_SIZE_INDEX,
    mImageSizeIndex);
  // Save the current filter indices.
  savedInstanceState.putInt(STATE_CURVE_FILTER_INDEX,
    mCurveFilterIndex);
  savedInstanceState.putInt(STATE_MIXER_FILTER_INDEX,
    mMixerFilterIndex);
  savedInstanceState.putInt(STATE_CONVOLUTION_FILTER_INDEX,
    mConvolutionFilterIndex);
  super.onSaveInstanceState(savedInstanceState);
}

public boolean onOptionsItemSelected(final MenuItem item) {
  if (mIsMenuLocked) {
    return true;
  }
  if (item.getGroupId() == MENU_GROUP_ID_SIZE) {
    mImageSizeIndex = item.getItemId();
    recreate();
    return true;
  }
  switch (item.getItemId()) {
  case R.id.menu_next_curve_filter:
    mCurveFilterIndex++;
    if (mCurveFilterIndex == mCurveFilters.length) {
      mCurveFilterIndex = 0;
    }
    return true;
  case R.id.menu_next_mixer_filter:
    mMixerFilterIndex++;
    if (mMixerFilterIndex == mMixerFilters.length) {
      mMixerFilterIndex = 0;
    }
    return true;
  case R.id.menu_next_convolution_filter:
    mConvolutionFilterIndex++;
    if (mConvolutionFilterIndex ==
      mConvolutionFilters.length) {
      mConvolutionFilterIndex = 0;
    }
    return true;
  // ...
  default:
    return super.onOptionsItemSelected(item);
  }
}

public Mat onCameraFrame(final CvCameraViewFrame inputFrame) {
  final Mat rgba = inputFrame.rgba();
  // Apply the active filters.
  mCurveFilters[mCurveFilterIndex].apply(rgba, rgba);
  mMixerFilters[mMixerFilterIndex].apply(rgba, rgba);
  mConvolutionFilters[mConvolutionFilterIndex].apply(
    rgba, rgba);
  if (mIsPhotoPending) {
    mIsPhotoPending = false;
    takePhoto(rgba);
  }
  if (mIsCameraFrontFacing) {
    // Mirror (horizontally flip) the preview.
    Core.flip(rgba, rgba, 1);
  }
  return rgba;
}

grayValue(r, g, b) = (0.299 * r) + (0.587 * g) + (0.114 * b)

public class ImageDetectionFilter implements Filter {
  // The reference image (this detector's target).
  private final Mat mReferenceImage;
  // Features of the reference image.
  private final MatOfKeyPoint mReferenceKeypoints =
    new MatOfKeyPoint();
  // Descriptors of the reference image's features.
  private final Mat mReferenceDescriptors = new Mat();
  // The corner coordinates of the reference image, in pixels.
  // CvType defines the color depth, number of channels, and
  // channel layout in the image. Here, each point is represented
  // by two 32-bit floats.
  private final Mat mReferenceCorners =
    new Mat(4, 1, CvType.CV_32FC2);
  // Features of the scene (the current frame).
  private final MatOfKeyPoint mSceneKeypoints =
    new MatOfKeyPoint();
  // Descriptors of the scene's features.
  private final Mat mSceneDescriptors = new Mat();
  // Tentative corner coordinates detected in the scene, in
  // pixels.
  private final Mat mCandidateSceneCorners =
    new Mat(4, 1, CvType.CV_32FC2);
  // Good corner coordinates detected in the scene, in pixels.
  private final Mat mSceneCorners = new Mat(4, 1,
    CvType.CV_32FC2);
  // The good detected corner coordinates, in pixels, as integers.
  private final MatOfPoint mIntSceneCorners = new MatOfPoint();
  // A grayscale version of the scene.
  private final Mat mGraySrc = new Mat();
  // Tentative matches of scene features and reference features.
  private final MatOfDMatch mMatches = new MatOfDMatch();
  // A feature detector, which finds features in images.
  private final FeatureDetector mFeatureDetector =
    FeatureDetector.create(FeatureDetector.ORB);
  // A descriptor extractor, which creates descriptors of
  // features.
  private final DescriptorExtractor mDescriptorExtractor =
    DescriptorExtractor.create(DescriptorExtractor.ORB);
  // A descriptor matcher, which matches features based on their
  // descriptors.
  private final DescriptorMatcher mDescriptorMatcher =
    DescriptorMatcher.create(
      DescriptorMatcher.BRUTEFORCE_HAMMINGLUT);
  // The color of the outline drawn around the detected image.
  private final Scalar mLineColor = new Scalar(0, 255, 0);

public ImageDetectionFilter(final Context context,
    final int referenceImageResourceID) throws IOException {
    // Load the reference image from the app's resources.
    // It is loaded in BGR (blue, green, red) format.
    mReferenceImage = Utils.loadResource(context,
      referenceImageResourceID,
      Imgcodecs.CV_LOAD_IMAGE_COLOR);
    // Create grayscale and RGBA versions of the reference image.
    final Mat referenceImageGray = new Mat();
    Imgproc.cvtColor(mReferenceImage, referenceImageGray,
      Imgproc.COLOR_BGR2GRAY);
    Imgproc.cvtColor(mReferenceImage, mReferenceImage,
      Imgproc.COLOR_BGR2RGBA);
    // Store the reference image's corner coordinates, in pixels.
    mReferenceCorners.put(0, 0,
      new double[] {0.0, 0.0});
    mReferenceCorners.put(1, 0,
      new double[] {referenceImageGray.cols(), 0.0});
    mReferenceCorners.put(2, 0,
      new double[] {referenceImageGray.cols(),
      referenceImageGray.rows()});
    mReferenceCorners.put(3, 0,
      new double[] {0.0, referenceImageGray.rows()});
    // Detect the reference features and compute their
    // descriptors.
    mFeatureDetector.detect(referenceImageGray,
      mReferenceKeypoints);
    mDescriptorExtractor.compute(referenceImageGray,
      mReferenceKeypoints, mReferenceDescriptors);
  }

@Override
  public void apply(final Mat src, final Mat dst) {
    // Convert the scene to grayscale.
    Imgproc.cvtColor(src, mGraySrc, Imgproc.COLOR_RGBA2GRAY);
    // Detect the scene features, compute their descriptors,
    // and match the scene descriptors to reference descriptors.
    mFeatureDetector.detect(mGraySrc, mSceneKeypoints);
    mDescriptorExtractor.compute(mGraySrc, mSceneKeypoints,
      mSceneDescriptors);
    mDescriptorMatcher.match(mSceneDescriptors,
      mReferenceDescriptors, mMatches);
    // Attempt to find the target image's corners in the scene.
    findSceneCorners();
    // If the corners have been found, draw an outline around the
    // target image.
    // Else, draw a thumbnail of the target image.    draw(src, dst);
  }

private void findSceneCorners() {
    List<DMatch> matchesList = mMatches.toList();
    if (matchesList.size() < 4) {
      // There are too few matches to find the homography.
      return;
    }
    List<KeyPoint> referenceKeypointsList =
      mReferenceKeypoints.toList();
    List<KeyPoint> sceneKeypointsList =
      mSceneKeypoints.toList();
    // Calculate the max and min distances between keypoints.
    double maxDist = 0.0;
    double minDist = Double.MAX_VALUE;
    for(DMatch match : matchesList) {
      double dist = match.distance;
      if (dist < minDist) {
        minDist = dist;
      }
      if (dist > maxDist) {
        maxDist = dist;
      }
    }
    // The thresholds for minDist are chosen subjectively
    // based on testing. The unit is not related to pixel
    // distances; it is related to the number of failed tests
    // for similarity between the matched descriptors.
    if (minDist > 50.0) {
      // The target is completely lost.
      // Discard any previously found corners.
      mSceneCorners.create(0, 0, mSceneCorners.type());
      return;
    } else if (minDist > 25.0) {
      // The target is lost but maybe it is still close.
      // Keep any previously found corners.
      return;
    }
    // Identify "good" keypoints based on match distance.
    ArrayList<Point> goodReferencePointsList =
      new ArrayList<Point>();
    ArrayList<Point> goodScenePointsList =
      new ArrayList<Point>();
    double maxGoodMatchDist = 1.75 * minDist;
    for(DMatch match : matchesList) {
      if (match.distance < maxGoodMatchDist) {
        goodReferencePointsList.add(
          referenceKeypointsList.get(match.trainIdx).pt);
        goodScenePointsList.add(
          sceneKeypointsList.get(match.queryIdx).pt);
      }
    }
    if (goodReferencePointsList.size() < 4 ||
        goodScenePointsList.size() < 4) {
      // There are too few good points to find the homography.
      return;
    }
    // There are enough good points to find the homography.
    // (Otherwise, the method would have already returned.)
    // Convert the matched points to MatOfPoint2f format, as
    // required by the Calib3d.findHomography function.
    MatOfPoint2f goodReferencePoints = new MatOfPoint2f();
    goodReferencePoints.fromList(goodReferencePointsList);
    MatOfPoint2f goodScenePoints = new MatOfPoint2f();
    goodScenePoints.fromList(goodScenePointsList);
    // Find the homography.
    Mat homography = Calib3d.findHomography(
      goodReferencePoints, goodScenePoints);
    // Use the homography to project the reference corner
    // coordinates into scene coordinates.
    Core.perspectiveTransform(mReferenceCorners,
      mCandidateSceneCorners, homography);
    // Convert the scene corners to integer format, as required
    // by the Imgproc.isContourConvex function.
    mCandidateSceneCorners.convertTo(mIntSceneCorners,
      CvType.CV_32S);
    // Check whether the corners form a convex polygon. If not,
    // (that is, if the corners form a concave polygon), the
    // detection result is invalid because no real perspective can
    // make the corners of a rectangular image look like a concave
    // polygon!
    if (Imgproc.isContourConvex(mIntSceneCorners)) {
      // The corners form a convex polygon, so record them as
      // valid scene corners.
      mCandidateSceneCorners.copyTo(mSceneCorners);
    }
  }

protected void draw(Mat src, Mat dst) {
    if (dst != src) {
      src.copyTo(dst);
    }
    if (mSceneCorners.height() < 4) {
      // The target has not been found.
      // Draw a thumbnail of the target in the upper-left
      // corner so that the user knows what it is.
      // Compute the thumbnail's larger dimension as half the
      // video frame's smaller dimension.
      int height = mReferenceImage.height();
      int width = mReferenceImage.width();
      int maxDimension = Math.min(dst.width(),
        dst.height()) / 2;
      double aspectRatio = width / (double)height;
      if (height > width) {
        height = maxDimension;
        width = (int)(height * aspectRatio);
      } else {
        width = maxDimension;
        height = (int)(width / aspectRatio);
      }
      // Select the region of interest (ROI) where the thumbnail
      // will be drawn.
      Mat dstROI = dst.submat(0, height, 0, width);
      // Copy a resized reference image into the ROI.
      Imgproc.resize(mReferenceImage, dstROI, dstROI.size(),
        0.0, 0.0, Imgproc.INTER_AREA);
      return;
    }
    // Outline the found target in green.
    Imgproc.line(dst, new Point(mSceneCorners.get(0, 0)),
      new Point(mSceneCorners.get(1, 0)), mLineColor, 4);
    Imgproc.line(dst, new Point(mSceneCorners.get(1, 0)),
      new Point(mSceneCorners.get(2, 0)), mLineColor, 4);
    Imgproc.line(dst, new Point(mSceneCorners.get(2, 0)),
      new Point(mSceneCorners.get(3, 0)), mLineColor, 4);
    Imgproc.line(dst, new Point(mSceneCorners.get(3,0)),
      new Point(mSceneCorners.get(0, 0)), mLineColor, 4);
  }
}

<string name="menu_next_image_detection_filter">Next
    Tracker</string>

<menu xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto">
  <item
    android:id="@+id/menu_next_image_detection_filter"
    app:showAsAction="ifRoom|withText"
    android:title="@string/menu_next_image_detection_filter" />
  <!-- ... -->
</menu>

// Keys for storing the indices of the active filters.
  private static final String STATE_IMAGE_DETECTION_FILTER_INDEX =
    "imageDetectionFilterIndex";
  private static final String STATE_CURVE_FILTER_INDEX =
    "curveFilterIndex";
  private static final String STATE_MIXER_FILTER_INDEX =
    "mixerFilterIndex";
  private static final String STATE_CONVOLUTION_FILTER_INDEX =
    "convolutionFilterIndex";
  // The filters.
  private Filter[] mImageDetectionFilters;
  private Filter[] mCurveFilters;
  private Filter[] mMixerFilters;
  private Filter[] mConvolutionFilters;
  // The indices of the active filters.
  private int mImageDetectionFilterIndex;
  private int mCurveFilterIndex;
  private int mMixerFilterIndex;
  private int mConvolutionFilterIndex;

public void onManagerConnected(final int status) {
      switch (status) {
        case LoaderCallbackInterface.SUCCESS:
          Log.d(TAG, "OpenCV loaded successfully");
          mCameraView.enableView();
          mBgr = new Mat();
          final Filter starryNight;
          try {
            starryNight = new ImageDetectionFilter(
              CameraActivity.this,
              R.drawable.starry_night);
          } catch (IOException e) {
            Log.e(TAG, "Failed to load drawable: " +
              "starry_night");
            e.printStackTrace();
            break;
          }
         final Filter akbarHunting;
         try {
           akbarHunting = new ImageDetectionFilter(
             CameraActivity.this,
             R.drawable.akbar_hunting_with_cheetahs);
         } catch (IOException e) {
           Log.e(TAG, "Failed to load drawable: " +
             "akbar_hunting_with_cheetahs");
           e.printStackTrace();
           break;
         }
          mImageDetectionFilters = new Filter[] {
            new NoneFilter(),
            starryNight,
            akbarHunting
          };
          // ...
      }
    }
  };

protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Window window = getWindow();
    window.addFlags(
      WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    if (savedInstanceState != null) {
      mCameraIndex = savedInstanceState.getInt(
        STATE_CAMERA_INDEX, 0);
      mImageSizeIndex = savedInstanceState.getInt(
        STATE_IMAGE_SIZE_INDEX, 0);
 mImageDetectionFilterIndex =
 savedInstanceState.getInt(
 STATE_IMAGE_DETECTION_FILTER_INDEX, 0);
      mCurveFilterIndex = savedInstanceState.getInt(
        STATE_CURVE_FILTER_INDEX, 0);
      mMixerFilterIndex = savedInstanceState.getInt(
        STATE_MIXER_FILTER_INDEX, 0);
      mConvolutionFilterIndex = savedInstanceState.getInt(
        STATE_CONVOLUTION_FILTER_INDEX, 0);
    } else {
      mCameraIndex = 0;
      mImageSizeIndex = 0;
      mImageDetectionFilterIndex = 0;
      mCurveFilterIndex = 0;
      mMixerFilterIndex = 0;
      mConvolutionFilterIndex = 0;
    }
    // ...
  }

public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the current camera index.
    savedInstanceState.putInt(STATE_CAMERA_INDEX, mCameraIndex);
    // Save the current image size index.
    savedInstanceState.putInt(STATE_IMAGE_SIZE_INDEX,
      mImageSizeIndex);
    // Save the current filter indices.
    savedInstanceState.putInt(STATE_IMAGE_DETECTION_FILTER_INDEX,
      mImageDetectionFilterIndex);
    savedInstanceState.putInt(STATE_CURVE_FILTER_INDEX,
      mCurveFilterIndex);
    savedInstanceState.putInt(STATE_MIXER_FILTER_INDEX,
      mMixerFilterIndex);
    savedInstanceState.putInt(STATE_CONVOLUTION_FILTER_INDEX,
      mConvolutionFilterIndex);
    super.onSaveInstanceState(savedInstanceState);
  }

public boolean onOptionsItemSelected(final MenuItem item) {
    if (mIsMenuLocked) {
      return true;
    }
    if (item.getGroupId() == MENU_GROUP_ID_SIZE) {
      mImageSizeIndex = item.getItemId();
      recreate();
      return true;
    }
    switch (item.getItemId()) {
    case R.id.menu_next_image_detection_filter:
      mImageDetectionFilterIndex++;
      if (mImageDetectionFilterIndex ==
        mImageDetectionFilters.length) {
        mImageDetectionFilterIndex = 0;
      }
      return true;
    // ...
    default:
      return super.onOptionsItemSelected(item);
    }
  }

public Mat onCameraFrame(final CvCameraViewFrame inputFrame) {
    final Mat rgba = inputFrame.rgba();
    // Apply the active filters.
    if (mImageDetectionFilters != null) {
      mImageDetectionFilters[mImageDetectionFilterIndex].apply(
        rgba, rgba);
    }
    if (mCurveFilters != null) {
      mCurveFilters[mCurveFilterIndex].apply(rgba, rgba);
    }
    if (mMixerFilters != null) {
      mMixerFilters[mMixerFilterIndex].apply(rgba, rgba);
    }
    if (mConvolutionFilters != null) {
      mConvolutionFilters[mConvolutionFilterIndex].apply(
        rgba, rgba);
    }
    if (mIsPhotoPending) {
      mIsPhotoPending = false;
      takePhoto(rgba);
    }
    if (mIsCameraFrontFacing) {
      // Mirror (horizontally flip) the preview.
      Core.flip(rgba, rgba, 1);
    }
    return rgba;
  }

public interface ARFilter extends Filter {
  public float[] getGLPose();
}

public class NoneARFilter extends NoneFilter implements ARFilter {
  @Override
  public float[] getGLPose() {
    return null;
  }
}

// Use the deprecated Camera class.
@SuppressWarnings("deprecation")
public class CameraProjectionAdapter {
  float mFOVY = 45f; // equivalent in 35mm photography: 28mm lens
  float mFOVX = 60f; // equivalent in 35mm photography: 28mm lens
  int mHeightPx = 480;
  int mWidthPx = 640;
  float mNear = 0.1f;
  float mFar = 10f;
  final float[] mProjectionGL = new float[16];
  boolean mProjectionDirtyGL = true;
  MatOfDouble mProjectionCV;
  boolean mProjectionDirtyCV = true;

public void setCameraParameters(
    final Parameters cameraParameters, final Size imageSize) {
    mFOVY = cameraParameters.getVerticalViewAngle();
    mFOVX = cameraParameters.getHorizontalViewAngle();
    mHeightPx = imageSizeimageSize.height;
    mWidthPx = imageSizeimageSize.width;
    mProjectionDirtyGL = true;
    mProjectionDirtyCV = true;
  }

public float getAspectRatio() {
    return (float)mWidthPx / (float)mHeightPx;
  }

public void setClipDistances(float near, float far) {
    mNear = near;
    mFar = far;
    mProjectionDirtyGL = true;
  }

public float[] getProjectionGL() {
    if (mProjectionDirtyGL) {
      final float right =
        (float)Math.tan(0.5f * mFOVX * Math.PI / 180f) * mNear;
      // Calculate vertical bounds based on horizontal bounds
      // and the image's aspect ratio. Some aspect ratios will
      // be crop modes that do not use the full vertical FOV
      // reported by Camera.Paremeters.
      final float top = right / getAspectRatio();
      Matrix.frustumM(mProjectionGL, 0,
        -right, right, -top, top, mNear, mFar);
      mProjectionDirtyGL = false;
    }
    return mProjectionGL;
  }

public MatOfDouble getProjectionCV() {
    if (mProjectionDirtyCV) {
      if (mProjectionCV == null) {
        mProjectionCV = new MatOfDouble();
        mProjectionCV.create(3, 3, CvType.CV_64FC1);
      }
      // Calculate focal length using the aspect ratio of the
      // FOV values reported by Camera.Parameters. This is not
      // necessarily the same as the image's current aspect
      // ratio, which might be a crop mode.
      final float fovAspectRatio = mFOVX / mFOVY;
      double diagonalPx = Math.sqrt(
        (Math.pow(mWidthPx, 2.0) +
          Math.pow(mWidthPx / fovAspectRaio, 2.0)));
      double diagonalFOV = Math.sqrt(
        (Math.pow(mFOVX, 2.0) +
          Math.pow(mFOVY, 2.0)));
      double focalLengthPx = diagonalPx /
        (2.0 * Math.tan(0.5 * diagonalFOV * Math.PI / 180f));
      mProjectionCV.put(0, 0, focalLengthPx);
      mProjectionCV.put(0, 1, 0.0);
      mProjectionCV.put(0, 2, 0.5 * mWidthPx);
      mProjectionCV.put(1, 0, 0.0);
      mProjectionCV.put(1, 1, focalLengthPx);
      mProjectionCV.put(1, 2, 0.5 * mHeightPx);
      mProjectionCV.put(2, 0, 0.0);
      mProjectionCV.put(2, 1, 0.0);
      mProjectionCV.put(2, 2, 1.0);
    }
    return mProjectionCV;
  }
}

public class ImageDetectionFilter implements ARFilter {
  // ...
  // The reference image's corner coordinates, in 3D, in real
  // units.
  private final MatOfPoint3f mReferenceCorners3D =
    new MatOfPoint3f();
  // Good corner coordinates detected in the scene, in // pixels.
  private final MatOfPoint2f mSceneCorners2D =
    new MatOfPoint2f();
  // Distortion coefficients of the camera's lens.
  // Assume no distortion.
  private final MatOfDouble mDistCoeffs =
 new MatOfDouble(0.0, 0.0, 0.0, 0.0);
  // An adaptor that provides the camera's projection matrix.
  private final CameraProjectionAdapter mCameraProjectionAdapter;
  // The Euler angles of the detected target.
  private final MatOfDouble mRVec = new MatOfDouble();
  // The XYZ coordinates of the detected target.
  private final MatOfDouble mTVec = new MatOfDouble();
  // The rotation matrix of the detected target.
  private final MatOfDouble mRotation = new MatOfDouble();
  // The OpenGL pose matrix of the detected target.
  private final float[] mGLPose = new float[16];
  // Whether the target is currently detected.
  private boolean mTargetFound = false;

public ImageDetectionFilter(final Context context,
    final int referenceImageResourceID,
    final CameraProjectionAdapter cameraProjectionAdapter,
    final double realSize)
        throws IOException {
    // ...
    // Compute the image's width and height in real units, based
    // on the specified real size of the image's smaller
    // dimension.
    final double aspectRatio = (double)referenceImageGray.cols() 
      /(double)referenceImageGray.rows();
    final double halfRealWidth;
    final double halfRealHeight;
    if (referenceImageGray.cols() > referenceImageGray.rows()) {
      halfRealHeight = 0.5f * realSize;
      halfRealWidth = halfRealHeight * aspectRatio;
    } else {
      halfRealWidth = 0.5f * realSize;
      halfRealHeight = halfRealWidth / aspectRatio;
    }
    // Define the printed image so that it normally lies in the
    // xy plane (like a painting or poster on a wall).
    // That is, +z normally points out of the page toward the
    // viewer.
    mReferenceCorners3D.fromArray(
      new Point3(-halfRealWidth, -halfRealHeight, 0.0),
      new Point3( halfRealWidth, -halfRealHeight, 0.0),
      new Point3( halfRealWidth,  halfRealHeight, 0.0),
      new Point3(-halfRealWidth,  halfRealHeight, 0.0));
    mCameraProjectionAdapter = cameraProjectionAdapter;
  }

@Override
  public float[] getGLPose() {
    return (mTargetFound ? mGLPose : null);
  }

@Override
  public void apply(final Mat src, final Mat dst) {
    // Convert the scene to grayscale.
    Imgproc.cvtColor(src, mGraySrc, Imgproc.COLOR_RGBA2GRAY);
    // Detect the scene features, compute their descriptors,
    // and match the scene descriptors to reference descriptors.
    mFeatureDetector.detect(mGraySrc, mSceneKeypoints);
    mDescriptorExtractor.compute(mGraySrc, mSceneKeypoints,
      mSceneDescriptors);
    mDescriptorMatcher.match(mSceneDescriptors,
      mReferenceDescriptors, mMatches);
    // Attempt to find the target image's 3D pose in the // scene.
    findPose();
    // If the pose has not been found, draw a thumbnail of the
    // target image.
    draw(src, dst);
  }

private void findPose() {
    // ...
    if (minDist > 50.0) {
      // The target is completely lost.
      mTargetFound = false;
      return;
    } else if (minDist > 25.0) {
      // The target is lost but maybe it is still close.
      // Keep using any previously found pose.
      return;
    }
    // ...
    // Convert the scene corners to integer format, as required
       // by the Imgproc.isContourConvex function.
    mCandidateSceneCorners.convertTo(mIntSceneCorners,
      CvType.CV_32S);
    // Check whether the corners form a convex polygon. If not,
    // (that is, if the corners form a concave polygon), the
    // detection result is invalid because no real perspective 
    // can make the corners of a rectangular image look like a 
    // concave polygon!
    if (!Imgproc.isContourConvex(mIntSceneCorners)) {
      return;
    }
    double[] sceneCorner0 = mCandidateSceneCorners.get(0, 0);
    double[] sceneCorner1 = mCandidateSceneCorners.get(1, 0);
    double[] sceneCorner2 = mCandidateSceneCorners.get(2, 0);
    double[] sceneCorner3 = mCandidateSceneCorners.get(3, 0);
    mSceneCorners2D.fromArray(
      new Point(sceneCorner0[0], sceneCorner0[1]),
      new Point(sceneCorner1[0], sceneCorner1[1]),
      new Point(sceneCorner2[0], sceneCorner2[1]),
      new Point(sceneCorner3[0], sceneCorner3[1]));
    MatOfDouble projection =
      mCameraProjectionAdapter.getProjectionCV();
    // Find the target's Euler angles and XYZ coordinates.
    Calib3d.solvePnP(mReferenceCorners3D mSceneCorners2D, 
      projection, mDistCoeffs, mRVec, mTVec);
    // Positive y is up in OpenGL, down in OpenCV.
    // Positive z is backward in OpenGL, forward in OpenCV.
    // Positive angles are counter-clockwise in OpenGL,
    // clockwise in OpenCV.
    // Thus, x angles are negated but y and z angles are
    // double-negated (that is, unchanged).
    // Meanwhile, y and z positions are negated.
    double[] rVecArray = mRVec.toArray();
    rVecArray[0] *= -1.0; // negate x angle
    mRVec.fromArray(rVecArray);
    // Convert the Euler angles to a 3x3 rotation matrix.
    Calib3d.Rodrigues(mRVec, mRotation);
    double[] tVecArray = mTVec.toArray();
    // OpenCV's matrix format is transposed, relative to
    // OpenGL's matrix format.
    mGLPose[0]  =  (float)mRotation.get(0, 0)[0];
    mGLPose[1]  =  (float)mRotation.get(0, 1)[0];
    mGLPose[2]  =  (float)mRotation.get(0, 2)[0];
    mGLPose[3]  =  0f;
    mGLPose[4]  =  (float)mRotation.get(1, 0)[0];
    mGLPose[5]  =  (float)mRotation.get(1, 1)[0];
    mGLPose[6]  =  (float)mRotation.get(1, 2)[0];
    mGLPose[7]  =  0f;
    mGLPose[8]  =  (float)mRotation.get(2, 0)[0];
    mGLPose[9]  =  (float)mRotation.get(2, 1)[0];
    mGLPose[10] =  (float)mRotation.get(2, 2)[0];
    mGLPose[11] =  0f;
    mGLPose[12] =  (float)tVecArray[0];
    mGLPose[13] = -(float)tVecArray[1]; // negate y position
    mGLPose[14] = -(float)tVecArray[2]; // negate z position
    mGLPose[15] =  1f;
    mTargetFound = true;
  }

protected void draw(Mat src, Mat dst) {
    if (dst != src) {
      src.copyTo(dst);
    }
    if (!mTargetFound) {
      // The target has not been found.
      // Draw a thumbnail of the target in the upper-left
      // corner so that the user knows what it is.
      // Compute the thumbnail's larger dimension as half the
      // video frame's smaller dimension.
      int height = mReferenceImage.height();
      int width = mReferenceImage.width();
      int maxDimension = Math.min(dst.width(),
        dst.height()) / 2;
      double aspectRatio = width / (double)height;
      if (height > width) {
        height = maxDimension;
        width = (int)(height * aspectRatio);
      } else {
        width = maxDimension;
        height = (int)(width / aspectRatio);
      }
      // Select the region of interest (ROI) where the thumbnail
      // will be drawn.
      Mat dstROI = dst.submat(0, height, 0, width);
      // Copy a resized reference image into the ROI.
      Imgproc.resize(mReferenceImage, dstROI, dstROI.size(),
        0.0, 0.0, Imgproc.INTER_AREA);
    }
  }
}

public class ARCubeRenderer implements GLSurfaceView.Renderer {
  public ARFilter filter;
  public CameraProjectionAdapter cameraProjectionAdapter;
  public float scale = 1f;
  private int mSurfaceWidth;
  private int mSurfaceHeight;
  private static final ByteBuffer VERTICES;
  private static final ByteBuffer COLORS;
  private static final ByteBuffer TRIANGLES;

static {
    VERTICES = ByteBuffer.allocateDirect(96);
    VERTICES.order(ByteOrder.nativeOrder());
    VERTICES.asFloatBuffer().put(new float[] {
      // Front.
      -0.5f, -0.5f,  0.5f,
       0.5f, -0.5f,  0.5f,
       0.5f,  0.5f,  0.5f,
      -0.5f,  0.5f,  0.5f,
      // Back.
      -0.5f, -0.5f, -0.5f,
       0.5f, -0.5f, -0.5f,
       0.5f,  0.5f, -0.5f,
      -0.5f,  0.5f, -0.5f
    });
    VERTICES.position(0);

COLORS = ByteBuffer.allocateDirect(32);
    final byte maxColor = (byte)255;
    COLORS.put(new byte[] {
      // Front.
      maxColor, 0, 0, maxColor,        // red
      maxColor, maxColor, 0, maxColor, // yellow
      maxColor, maxColor, 0, maxColor, // yellow
      maxColor, 0, 0, maxColor,        // red
      // Back.
      0, maxColor, 0, maxColor,        // green
      0, 0, maxColor, maxColor,        // blue
      0, 0, maxColor, maxColor,        // blue
      0, maxColor, 0, maxColor         // green
    });
    COLORS.position(0);

TRIANGLES = ByteBuffer.allocateDirect(36);
    TRIANGLES.put(new byte[] {
      // Front.
      0,  1,  2,  2,  3,  0,
      3,  2,  6,  6,  7,  3,
      7,  6,  5,  5,  4,  7,
      // Back.
      4,  5,  1,  1,  0,  4,
      4,  0,  3,  3,  7,  4,
      1,  5,  6,  6,  2,  1
    });
    TRIANGLES.position(0);
  }

@Override
  public void onSurfaceCreated(final GL10 gl,
    final EGLConfig config) {
    gl.glClearColor(0f, 0f, 0f, 0f); // transparent
    gl.glEnable(GL10.GL_CULL_FACE);
  }

@Override
  public void onSurfaceChanged(final GL10 gl, final int width,
    final int height) {
    mSurfaceWidth = width;
    mSurfaceHeight = height;
  }
}

@Override
  public void onDrawFrame(final GL10 gl) {
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT |
      GL10.GL_DEPTH_BUFFER_BIT);
    if (filter == null) {
      return;
    }
    if (cameraProjectionAdapter == null) {
      return;
    }
    float[] pose = filter.getGLPose();
    if (pose == null) {
      return;
    }
    final int adjustedWidth = (int)(mSurfaceHeight *
      cameraProjectionAdapter.getAspectRatio());
    final int marginX = (mSurfaceWidth - adjustedWidth) / 2;
    gl.glViewport(marginX, 0, adjustedWidth, mSurfaceHeight);
    gl.glMatrixMode(GL10.GL_PROJECTION);
    float[] projection =
      cameraProjectionAdapter.getProjectionGL();
    gl.glLoadMatrixf(projection, 0);
    gl.glMatrixMode(GL10.GL_MODELVIEW);
    gl.glLoadMatrixf(pose, 0);
    gl.glScalef(scale, scale, scale);
    // Move the cube forward so that it is not halfway inside
    // the image.
    gl.glTranslatef(0f, 0f, 0.5f);
    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
    gl.glVertexPointer(3, GL11.GL_FLOAT, 0, VERTICES);
    gl.glColorPointer(4, GL11.GL_UNSIGNED_BYTE, 0, COLORS);
    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
    gl.glDrawElements(GL10.GL_TRIANGLES, 36,
      GL10.GL_UNSIGNED_BYTE, TRIANGLES);
    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
  }

// The filters.
  private ARFilter[] mImageDetectionFilters;
  private Filter[] mCurveFilters;
  private Filter[] mMixerFilters;
  private Filter[] mConvolutionFilters;
  // ...
  // The camera view.
  private CameraBridgeViewBase mCameraView;
  // An adapter between the video camera and projection // matrix.
  private CameraProjectionAdapter mCameraProjectionAdapter;
  // The renderer for 3D augmentations.
  private ARCubeRenderer mARRenderer;

public void onManagerConnected(final int status) {
      switch (status) {
      case LoaderCallbackInterface.SUCCESS:
        Log.d(TAG, "OpenCV loaded successfully");
        mCameraView.enableView();
        mBgr = new Mat();
        final ARFilter starryNight;
        try {
          // Define The Starry Night to be 1.0 units // tall
          starryNight = new ImageDetectionFilter(
            CameraActivity.this,
            R.drawable.starry_night,
            mCameraProjectionAdapter, 1.0);
        } catch (IOException e) {
          Log.e(TAG, "Failed to load drawable: " +
            "starry_night");
          e.printStackTrace();
          break;
        }
        final ARFilter akbarHunting;
        try {
          // Define Akbar Hunting with Cheetahs to be 1.0
          // units wide.
          akbarHunting = new ImageDetectionFilter(
            CameraActivity.this,
            R.drawable.akbar_hunting_with_cheetahs,
            mCameraProjectionAdapter, 1.0);
        } catch (IOException e) {
          Log.e(TAG, "Failed to load drawable: " +
            "akbar_hunting_with_cheetahs");
          e.printStackTrace();
          break;
        }
        mImageDetectionFilters = new ARFilter[] {
          new NoneARFilter(),
          starryNight,
          akbarHunting
        };
        // ...
      }
    }

protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // ...
    final FrameLayout layout = new FrameLayout(this);
    layout.setLayoutParams(new FrameLayout.LayoutParams(
      FrameLayout.LayoutParams.MATCH_PARENT,
      FrameLayout.LayoutParams.MATCH_PARENT));
    setContentView(layout);
    mCameraView = new JavaCameraView(this, mCameraIndex);
    mCameraView.setCvCameraViewListener(this);
    mCameraView.setLayoutParams(
 new FrameLayout.LayoutParams(
 FrameLayout.LayoutParams.MATCH_PARENT,
 FrameLayout.LayoutParams.MATCH_PARENT));
    layout.addView(mCameraView);
    GLSurfaceView glSurfaceView =
 new GLSurfaceView(this);
    glSurfaceView.getHolder().setFormat(
      PixelFormat.TRANSPARENT);
    glSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 0, 0);
    glSurfaceView.setZOrderOnTop(true);
    glSurfaceView.setLayoutParams(new
FrameLayout.LayoutParams(
FrameLayout.LayoutParams.MATCH_PARENT,
FrameLayout.LayoutParams.MATCH_PARENT));
    layout.addView(glSurfaceView);
    mCameraProjectionAdapter =
 new CameraProjectionAdapter();
    mARRenderer = new ARCubeRenderer();
    mARRenderer.cameraProjectionAdapter =
      mCameraProjectionAdapter;
    // Earlier, we defined the printed image's size as 
    // 1.0 unit.
    // Define the cube to be half this size.
    mARRenderer.scale = 0.5f;
    glSurfaceView.setRenderer(mARRenderer);
    final Camera camera;
    if (Build.VERSION.SDK_INT >=
      Build.VERSION_CODES.GINGERBREAD) {
      CameraInfo cameraInfo = new CameraInfo();
      Camera.getCameraInfo(mCameraIndex, cameraInfo);
      mIsCameraFrontFacing = (cameraInfo.facing ==
        CameraInfo.CAMERA_FACING_FRONT);
      mNumCameras = Camera.getNumberOfCameras();
      camera = Camera.open(mCameraIndex);
    } else { // pre-Gingerbread
      // Assume there is only 1 camera and it is rear-facing.
      mIsCameraFrontFacing = false;
      mNumCameras = 1;
      camera = Camera.open();
    }
    final Parameters parameters = camera.getParameters();
    camera.release();
    mSupportedImageSizes = parameters.getSupportedPreviewSizes();
    final Size size = mSupportedImageSizes.get(mImageSizeIndex);
    mCameraProjectionAdapter.setCameraParameters(
      parameters, size);
    // Earlier, we defined the printed image's size as     // 1.0 unit.
    // Leave the near and far clip distances at their default
    // values, which are 0.1 (one-tenth the image size) 
    // and 10.0 (ten times the image size).
    mCameraView.setMaxFrameSize(size.width, size.height);
    mCameraView.setCvCameraViewListener(this);
  }

@Override
    public void onManagerConnected(final int status) {
      switch (status) {
      case LoaderCallbackInterface.SUCCESS:
        Log.d(TAG, "OpenCV loaded successfully");
        mCameraView.enableView();
        mCameraView.enableFpsMeter();
        //...