Se agrega openCV y se prepara el entorno para integrar código en opencv.

.idea/gradle.xml

@@ -6,11 +6,12 @@
         <option name="distributionType" value="LOCAL" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="gradleHome" value="$APPLICATION_HOME_DIR$/gradle/gradle-2.4" />
-        <option name="gradleJvm" value="1.8" />
+        <option name="gradleJvm" value="1.7" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
             <option value="$PROJECT_DIR$/app" />
+            <option value="$PROJECT_DIR$/openCVLibrary2411" />
           </set>
         </option>
       </GradleProjectSettings>

.idea/misc.xml

@@ -54,7 +54,7 @@
     <ConfirmationsSetting value="0" id="Add" />
     <ConfirmationsSetting value="0" id="Remove" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" assert-keyword="true" jdk-15="true" project-jdk-name="1.7" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">

.idea/modules.xml

@@ -2,8 +2,9 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/EarRecognition.iml" filepath="$PROJECT_DIR$/EarRecognition.iml" />
       <module fileurl="file://$PROJECT_DIR$/app/app.iml" filepath="$PROJECT_DIR$/app/app.iml" />
-      <module fileurl="file://$PROJECT_DIR$/ear-recognition.iml" filepath="$PROJECT_DIR$/ear-recognition.iml" />
+      <module fileurl="file://$PROJECT_DIR$/openCVLibrary2411/openCVLibrary2411.iml" filepath="$PROJECT_DIR$/openCVLibrary2411/openCVLibrary2411.iml" />
     </modules>
   </component>
 </project>
\ No newline at end of file

app/app.iml

 <?xml version="1.0" encoding="UTF-8"?>
-<module external.linked.project.id=":app" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$/.." external.system.id="GRADLE" external.system.module.group="ear-recognition" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
+<module external.linked.project.id=":app" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$/.." external.system.id="GRADLE" external.system.module.group="EarRecognition" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
   <component name="FacetManager">
     <facet type="android-gradle" name="Android-Gradle">
       <configuration>
@@ -88,7 +88,7 @@
       <excludeFolder url="file://$MODULE_DIR$/build/outputs" />
       <excludeFolder url="file://$MODULE_DIR$/build/tmp" />
     </content>
-    <orderEntry type="jdk" jdkName="Android API 21 Platform (1)" jdkType="Android SDK" />
+    <orderEntry type="jdk" jdkName="Android API 21 Platform" jdkType="Android SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" exported="" name="support-v4-22.0.0" level="project" />
     <orderEntry type="library" exported="" name="support-annotations-22.0.0" level="project" />

app/src/main/AndroidManifest.xml

@@ -11,7 +11,7 @@
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:theme="@style/AppTheme" >
-        <activity
+       <!-- <activity
             android:name=".MainActivity"
             android:label="@string/app_name" >
             <intent-filter>
@@ -19,10 +19,16 @@
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
-        </activity>
+        </activity> -->
         <activity
             android:name=".CameraActivity"
-            android:label="@string/title_activity_camera" >
+            android:label="@string/app_name"
+            android:screenOrientation="portrait">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
         </activity>
     </application>
 

app/src/main/java/com/aluxoft/earrecognition/CameraActivity.java

@@ -33,30 +33,46 @@ public class CameraActivity extends ActionBarActivity {
     private static final int REQUEST_IMAGE_CAPTURE = 1;
     private static final int SELECT_PICTURE = 0;
     private String mCurrentPhotoPath;
-    private int previewWidth = 200;
-    private int previewHeight = 200;
+    private int previewWidth = 150;
+    private int previewHeight = 150;
+    private ImageView previewImage1;
+    private ImageView previewImage2;
     private ImageView previewImage;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_camera);
-        previewImage = (ImageView)findViewById(R.id.imageView);
+        previewImage1 = (ImageView)findViewById(R.id.imageView);
+        previewImage2 = (ImageView)findViewById(R.id.imageView2);
         final Button takeButton = (Button)findViewById(R.id.button);
         takeButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
+                previewImage = previewImage1;
                 takePhoto(takeButton);
             }
         });
 
+
         final Button pickButton = (Button)findViewById(R.id.button2);
         pickButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                pickPhoto(pickButton);
+                previewImage = previewImage2;
+                takePhoto(takeButton);
+            }
+        });
+
+        final Button processButton = (Button) findViewById(R.id.button3);
+        processButton.setOnClickListener(new View.OnClickListener(){
+            @Override
+            public void onClick(View v) {
+                // do opencv magic here...
+                
             }
         });
+
     }
 
     public void pickPhoto(View view) {

app/src/main/res/layout/activity_camera.xml

-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
-    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
-    android:paddingRight="@dimen/activity_horizontal_margin"
-    android:paddingTop="@dimen/activity_vertical_margin"
-    android:paddingBottom="@dimen/activity_vertical_margin"
-    tools:context="com.aluxoft.earrecognition.CameraActivity">
+<ScrollView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent">
+    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
+        android:layout_height="wrap_content" android:paddingLeft="@dimen/activity_horizontal_margin"
+        android:paddingRight="@dimen/activity_horizontal_margin"
+        android:paddingTop="@dimen/activity_vertical_margin"
+        android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity"
+        android:id="@+id/MainActivity">
 
-    <Button
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Take button"
-        android:id="@+id/button"
-        android:layout_centerHorizontal="true" />
+        <Button
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Cargar primera imagen"
+            android:id="@+id/button"
+            android:layout_marginTop="47dp"
+            android:layout_alignParentTop="true"
+            android:layout_alignParentLeft="true"
+            android:layout_alignParentStart="true"
+            android:layout_alignRight="@+id/button2"
+            android:layout_alignEnd="@+id/button2" />
 
-    <ImageView
-        android:layout_width="200dp"
-        android:layout_height="200dp"
-        android:id="@+id/imageView"
-        android:layout_centerVertical="true"
-        android:layout_centerHorizontal="true" />
+        <Button
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Cargar segunda imagen"
+            android:id="@+id/button2"
+            android:layout_centerVertical="true"
+            android:layout_alignParentLeft="true"
+            android:layout_alignParentStart="true"
+            android:layout_below="@+id/imageView"/>
 
-    <Button
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Pick Button"
-        android:id="@+id/button2"
-        android:layout_below="@+id/button"
-        android:layout_centerHorizontal="true" />
+        <ImageView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:id="@+id/imageView"
+            android:layout_below="@+id/button"
+            android:layout_alignParentLeft="true"
+            android:layout_alignParentStart="true"
+            android:layout_alignRight="@+id/button"
+            android:layout_alignEnd="@+id/button"
+            android:maxHeight="150dp" />
 
-</RelativeLayout>
+        <ImageView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:id="@+id/imageView2"
+            android:layout_below="@+id/button2"
+            android:layout_alignParentLeft="true"
+            android:layout_alignParentStart="true"
+            android:layout_alignRight="@+id/button2"
+            android:layout_alignEnd="@+id/button2"
+            android:maxHeight="150dp" />
+
+        <Button
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Procesar"
+            android:id="@+id/button3"
+            android:layout_below="@+id/imageView2"
+            android:layout_alignParentLeft="true" />
+
+
+    </RelativeLayout>
+</ScrollView>
\ No newline at end of file

ear-recognition.iml

-<?xml version="1.0" encoding="UTF-8"?>
-<module external.linked.project.id="ear-recognition" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
-  <component name="FacetManager">
-    <facet type="java-gradle" name="Java-Gradle">
-      <configuration>
-        <option name="BUILD_FOLDER_PATH" value="$MODULE_DIR$/build" />
-        <option name="BUILDABLE" value="false" />
-      </configuration>
-    </facet>
-  </component>
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_7" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.gradle" />
-    </content>
-    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file

import-summary.txt

+ECLIPSE ANDROID PROJECT IMPORT SUMMARY
+======================================
+
+Ignored Files:
+--------------
+The following files were *not* copied into the new Gradle project; you
+should evaluate whether these are still needed in your project and if
+so manually move them:
+
+* javadoc/
+* javadoc/allclasses-frame.html
+* javadoc/allclasses-noframe.html
+* javadoc/constant-values.html
+* javadoc/help-doc.html
+* javadoc/index-all.html
+* javadoc/index.html
+* javadoc/org/
+* javadoc/org/opencv/
+* javadoc/org/opencv/android/
+* javadoc/org/opencv/android/BaseLoaderCallback.html
+* javadoc/org/opencv/android/CameraBridgeViewBase.CvCameraViewFrame.html
+* javadoc/org/opencv/android/CameraBridgeViewBase.CvCameraViewListener.html
+* javadoc/org/opencv/android/CameraBridgeViewBase.CvCameraViewListener2.html
+* javadoc/org/opencv/android/CameraBridgeViewBase.ListItemAccessor.html
+* javadoc/org/opencv/android/CameraBridgeViewBase.html
+* javadoc/org/opencv/android/FpsMeter.html
+* javadoc/org/opencv/android/InstallCallbackInterface.html
+* javadoc/org/opencv/android/JavaCameraView.JavaCameraSizeAccessor.html
+* javadoc/org/opencv/android/JavaCameraView.html
+* javadoc/org/opencv/android/LoaderCallbackInterface.html
+* javadoc/org/opencv/android/NativeCameraView.OpenCvSizeAccessor.html
+* javadoc/org/opencv/android/NativeCameraView.html
+* javadoc/org/opencv/android/OpenCVLoader.html
+* javadoc/org/opencv/android/Utils.html
+* javadoc/org/opencv/android/package-frame.html
+* javadoc/org/opencv/android/package-summary.html
+* javadoc/org/opencv/android/package-tree.html
+* javadoc/org/opencv/calib3d/
+* javadoc/org/opencv/calib3d/Calib3d.html
+* javadoc/org/opencv/calib3d/StereoBM.html
+* javadoc/org/opencv/calib3d/StereoSGBM.html
+* javadoc/org/opencv/calib3d/package-frame.html
+* javadoc/org/opencv/calib3d/package-summary.html
+* javadoc/org/opencv/calib3d/package-tree.html
+* javadoc/org/opencv/core/
+* javadoc/org/opencv/core/Algorithm.html
+* javadoc/org/opencv/core/Core.MinMaxLocResult.html
+* javadoc/org/opencv/core/Core.html
+* javadoc/org/opencv/core/CvException.html
+* javadoc/org/opencv/core/CvType.html
+* javadoc/org/opencv/core/Mat.html
+* javadoc/org/opencv/core/MatOfByte.html
+* javadoc/org/opencv/core/MatOfDMatch.html
+* javadoc/org/opencv/core/MatOfDouble.html
+* javadoc/org/opencv/core/MatOfFloat.html
+* javadoc/org/opencv/core/MatOfFloat4.html
+* javadoc/org/opencv/core/MatOfFloat6.html
+* javadoc/org/opencv/core/MatOfInt.html
+* javadoc/org/opencv/core/MatOfInt4.html
+* javadoc/org/opencv/core/MatOfKeyPoint.html
+* javadoc/org/opencv/core/MatOfPoint.html
+* javadoc/org/opencv/core/MatOfPoint2f.html
+* javadoc/org/opencv/core/MatOfPoint3.html
+* javadoc/org/opencv/core/MatOfPoint3f.html
+* javadoc/org/opencv/core/MatOfRect.html
+* javadoc/org/opencv/core/Point.html
+* javadoc/org/opencv/core/Point3.html
+* javadoc/org/opencv/core/Range.html
+* javadoc/org/opencv/core/Rect.html
+* javadoc/org/opencv/core/RotatedRect.html
+* javadoc/org/opencv/core/Scalar.html
+* javadoc/org/opencv/core/Size.html
+* javadoc/org/opencv/core/TermCriteria.html
+* javadoc/org/opencv/core/package-frame.html
+* javadoc/org/opencv/core/package-summary.html
+* javadoc/org/opencv/core/package-tree.html
+* javadoc/org/opencv/features2d/
+* javadoc/org/opencv/features2d/DMatch.html
+* javadoc/org/opencv/features2d/DescriptorExtractor.html
+* javadoc/org/opencv/features2d/DescriptorMatcher.html
+* javadoc/org/opencv/features2d/FeatureDetector.html
+* javadoc/org/opencv/features2d/Features2d.html
+* javadoc/org/opencv/features2d/GenericDescriptorMatcher.html
+* javadoc/org/opencv/features2d/KeyPoint.html
+* javadoc/org/opencv/features2d/package-frame.html
+* javadoc/org/opencv/features2d/package-summary.html
+* javadoc/org/opencv/features2d/package-tree.html
+* javadoc/org/opencv/highgui/
+* javadoc/org/opencv/highgui/Highgui.html
+* javadoc/org/opencv/highgui/VideoCapture.html
+* javadoc/org/opencv/highgui/package-frame.html
+* javadoc/org/opencv/highgui/package-summary.html
+* javadoc/org/opencv/highgui/package-tree.html
+* javadoc/org/opencv/imgproc/
+* javadoc/org/opencv/imgproc/CLAHE.html
+* javadoc/org/opencv/imgproc/Imgproc.html
+* javadoc/org/opencv/imgproc/Moments.html
+* javadoc/org/opencv/imgproc/Subdiv2D.html
+* javadoc/org/opencv/imgproc/package-frame.html
+* javadoc/org/opencv/imgproc/package-summary.html
+* javadoc/org/opencv/imgproc/package-tree.html
+* javadoc/org/opencv/ml/
+* javadoc/org/opencv/ml/CvANN_MLP.html
+* javadoc/org/opencv/ml/CvANN_MLP_TrainParams.html
+* javadoc/org/opencv/ml/CvBoost.html
+* javadoc/org/opencv/ml/CvBoostParams.html
+* javadoc/org/opencv/ml/CvDTree.html
+* javadoc/org/opencv/ml/CvDTreeParams.html
+* javadoc/org/opencv/ml/CvERTrees.html
+* javadoc/org/opencv/ml/CvGBTrees.html
+* javadoc/org/opencv/ml/CvGBTreesParams.html
+* javadoc/org/opencv/ml/CvKNearest.html
+* javadoc/org/opencv/ml/CvNormalBayesClassifier.html
+* javadoc/org/opencv/ml/CvParamGrid.html
+* javadoc/org/opencv/ml/CvRTParams.html
+* javadoc/org/opencv/ml/CvRTrees.html
+* javadoc/org/opencv/ml/CvSVM.html
+* javadoc/org/opencv/ml/CvSVMParams.html
+* javadoc/org/opencv/ml/CvStatModel.html
+* javadoc/org/opencv/ml/EM.html
+* javadoc/org/opencv/ml/Ml.html
+* javadoc/org/opencv/ml/package-frame.html
+* javadoc/org/opencv/ml/package-summary.html
+* javadoc/org/opencv/ml/package-tree.html
+* javadoc/org/opencv/objdetect/
+* javadoc/org/opencv/objdetect/CascadeClassifier.html
+* javadoc/org/opencv/objdetect/HOGDescriptor.html
+* javadoc/org/opencv/objdetect/Objdetect.html
+* javadoc/org/opencv/objdetect/package-frame.html
+* javadoc/org/opencv/objdetect/package-summary.html
+* javadoc/org/opencv/objdetect/package-tree.html
+* javadoc/org/opencv/photo/
+* javadoc/org/opencv/photo/Photo.html
+* javadoc/org/opencv/photo/package-frame.html
+* javadoc/org/opencv/photo/package-summary.html
+* javadoc/org/opencv/photo/package-tree.html
+* javadoc/org/opencv/utils/
+* javadoc/org/opencv/utils/Converters.html
+* javadoc/org/opencv/utils/package-frame.html
+* javadoc/org/opencv/utils/package-summary.html
+* javadoc/org/opencv/utils/package-tree.html
+* javadoc/org/opencv/video/
+* javadoc/org/opencv/video/BackgroundSubtractor.html
+* javadoc/org/opencv/video/BackgroundSubtractorMOG.html
+* javadoc/org/opencv/video/BackgroundSubtractorMOG2.html
+* javadoc/org/opencv/video/KalmanFilter.html
+* javadoc/org/opencv/video/Video.html
+* javadoc/org/opencv/video/package-frame.html
+* javadoc/org/opencv/video/package-summary.html
+* javadoc/org/opencv/video/package-tree.html
+* javadoc/overview-frame.html
+* javadoc/overview-summary.html
+* javadoc/overview-tree.html
+* javadoc/package-list
+* javadoc/resources/
+* javadoc/resources/inherit.gif
+* javadoc/serialized-form.html
+* javadoc/stylesheet.css
+
+Moved Files:
+------------
+Android Gradle projects use a different directory structure than ADT
+Eclipse projects. Here's how the projects were restructured:
+
+* AndroidManifest.xml => openCVLibrary2411/src/main/AndroidManifest.xml
+* lint.xml => openCVLibrary2411/lint.xml
+* res/ => openCVLibrary2411/src/main/res/
+* src/ => openCVLibrary2411/src/main/java/
+* src/org/opencv/engine/OpenCVEngineInterface.aidl => openCVLibrary2411/src/main/aidl/org/opencv/engine/OpenCVEngineInterface.aidl
+
+Next Steps:
+-----------
+You can now build the project. The Gradle project needs network
+connectivity to download dependencies.
+
+Bugs:
+-----
+If for some reason your project does not build, and you determine that
+it is due to a bug or limitation of the Eclipse to Gradle importer,
+please file a bug at http://b.android.com with category
+Component-Tools.
+
+(This import summary is for your information only, and can be deleted
+after import once you are satisfied with the results.)

openCVLibrary2411/.gitignore

-build
+build/*

openCVLibrary2411/lint.xml

+<?xml version="1.0" encoding="utf-8"?>
+<lint>
+    <issue id="InlinedApi">
+        <ignore path="src\org\opencv\android\JavaCameraView.java" />
+    </issue>
+    <issue id="NewApi">
+        <ignore path="src\org\opencv\android\JavaCameraView.java" />
+    </issue>
+</lint>

openCVLibrary2411/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv"
+      android:versionCode="24110"
+      android:versionName="2.4.11">
+
+    <uses-sdk android:minSdkVersion="8" />
+</manifest>

openCVLibrary2411/src/main/aidl/org/opencv/engine/OpenCVEngineInterface.aidl

+package org.opencv.engine;
+
+/**
+* Class provides a Java interface for OpenCV Engine Service. It's synchronous with native OpenCVEngine class.
+*/
+interface OpenCVEngineInterface
+{
+    /**
+    * @return Returns service version.
+    */
+    int getEngineVersion();
+
+    /**
+    * Finds an installed OpenCV library.
+    * @param OpenCV version.
+    * @return Returns path to OpenCV native libs or an empty string if OpenCV can not be found.
+    */
+    String getLibPathByVersion(String version);
+
+    /**
+    * Tries to install defined version of OpenCV from Google Play Market.
+    * @param OpenCV version.
+    * @return Returns true if installation was successful or OpenCV package has been already installed.
+    */
+    boolean installVersion(String version);
+
+    /**
+    * Returns list of libraries in loading order, separated by semicolon.
+    * @param OpenCV version.
+    * @return Returns names of OpenCV libraries, separated by semicolon.
+    */
+    String getLibraryList(String version);
+}

openCVLibrary2411/src/main/java/org/opencv/android/BaseLoaderCallback.java

+package org.opencv.android;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.util.Log;
+
+/**
+ * Basic implementation of LoaderCallbackInterface.
+ */
+public abstract class BaseLoaderCallback implements LoaderCallbackInterface {
+
+    public BaseLoaderCallback(Context AppContext) {
+        mAppContext = AppContext;
+    }
+
+    public void onManagerConnected(int status)
+    {
+        switch (status)
+        {
+            /** OpenCV initialization was successful. **/
+            case LoaderCallbackInterface.SUCCESS:
+            {
+                /** Application must override this method to handle successful library initialization. **/
+            } break;
+            /** OpenCV loader can not start Google Play Market. **/
+            case LoaderCallbackInterface.MARKET_ERROR:
+            {
+                Log.e(TAG, "Package installation failed!");
+                AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
+                MarketErrorMessage.setTitle("OpenCV Manager");
+                MarketErrorMessage.setMessage("Package installation failed!");
+                MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
+                MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        finish();
+                    }
+                });
+                MarketErrorMessage.show();
+            } break;
+            /** Package installation has been canceled. **/
+            case LoaderCallbackInterface.INSTALL_CANCELED:
+            {
+                Log.d(TAG, "OpenCV library instalation was canceled by user");
+                finish();
+            } break;
+            /** Application is incompatible with this version of OpenCV Manager. Possibly, a service update is required. **/
+            case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION:
+            {
+                Log.d(TAG, "OpenCV Manager Service is uncompatible with this app!");
+                AlertDialog IncomatibilityMessage = new AlertDialog.Builder(mAppContext).create();
+                IncomatibilityMessage.setTitle("OpenCV Manager");
+                IncomatibilityMessage.setMessage("OpenCV Manager service is incompatible with this app. Try to update it via Google Play.");
+                IncomatibilityMessage.setCancelable(false); // This blocks the 'BACK' button
+                IncomatibilityMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        finish();
+                    }
+                });
+                IncomatibilityMessage.show();
+            } break;
+            /** Other status, i.e. INIT_FAILED. **/
+            default:
+            {
+                Log.e(TAG, "OpenCV loading failed!");
+                AlertDialog InitFailedDialog = new AlertDialog.Builder(mAppContext).create();
+                InitFailedDialog.setTitle("OpenCV error");
+                InitFailedDialog.setMessage("OpenCV was not initialised correctly. Application will be shut down");
+                InitFailedDialog.setCancelable(false); // This blocks the 'BACK' button
+                InitFailedDialog.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int which) {
+                        finish();
+                    }
+                });
+
+                InitFailedDialog.show();
+            } break;
+        }
+    }
+
+    public void onPackageInstall(final int operation, final InstallCallbackInterface callback)
+    {
+        switch (operation)
+        {
+            case InstallCallbackInterface.NEW_INSTALLATION:
+            {
+                AlertDialog InstallMessage = new AlertDialog.Builder(mAppContext).create();
+                InstallMessage.setTitle("Package not found");
+                InstallMessage.setMessage(callback.getPackageName() + " package was not found! Try to install it?");
+                InstallMessage.setCancelable(false); // This blocks the 'BACK' button
+                InstallMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Yes", new OnClickListener()
+                {
+                    public void onClick(DialogInterface dialog, int which)
+                    {
+                        callback.install();
+                    }
+                });
+
+                InstallMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "No", new OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int which)
+                    {
+                        callback.cancel();
+                    }
+                });
+
+                InstallMessage.show();
+            } break;
+            case InstallCallbackInterface.INSTALLATION_PROGRESS:
+            {
+                AlertDialog WaitMessage = new AlertDialog.Builder(mAppContext).create();
+                WaitMessage.setTitle("OpenCV is not ready");
+                WaitMessage.setMessage("Installation is in progress. Wait or exit?");
+                WaitMessage.setCancelable(false); // This blocks the 'BACK' button
+                WaitMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Wait", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        callback.wait_install();
+                    }
+                });
+                WaitMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "Exit", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        callback.cancel();
+                    }
+                });
+
+                WaitMessage.show();
+            } break;
+        }
+    }
+
+    void finish()
+    {
+        ((Activity) mAppContext).finish();
+    }
+
+    protected Context mAppContext;
+    private final static String TAG = "OpenCVLoader/BaseLoaderCallback";
+}

openCVLibrary2411/src/main/java/org/opencv/android/FpsMeter.java

+package org.opencv.android;
+
+import java.text.DecimalFormat;
+
+import org.opencv.core.Core;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.util.Log;
+
+public class FpsMeter {
+    private static final String TAG               = "FpsMeter";
+    private static final int    STEP              = 20;
+    private static final DecimalFormat FPS_FORMAT = new DecimalFormat("0.00");
+
+    private int                 mFramesCouner;
+    private double              mFrequency;
+    private long                mprevFrameTime;
+    private String              mStrfps;
+    Paint                       mPaint;
+    boolean                     mIsInitialized = false;
+    int                         mWidth = 0;
+    int                         mHeight = 0;
+
+    public void init() {
+        mFramesCouner = 0;
+        mFrequency = Core.getTickFrequency();
+        mprevFrameTime = Core.getTickCount();
+        mStrfps = "";
+
+        mPaint = new Paint();
+        mPaint.setColor(Color.BLUE);
+        mPaint.setTextSize(20);
+    }
+
+    public void measure() {
+        if (!mIsInitialized) {
+            init();
+            mIsInitialized = true;
+        } else {
+            mFramesCouner++;
+            if (mFramesCouner % STEP == 0) {
+                long time = Core.getTickCount();
+                double fps = STEP * mFrequency / (time - mprevFrameTime);
+                mprevFrameTime = time;
+                if (mWidth != 0 && mHeight != 0)
+                    mStrfps = FPS_FORMAT.format(fps) + " FPS@" + Integer.valueOf(mWidth) + "x" + Integer.valueOf(mHeight);
+                else
+                    mStrfps = FPS_FORMAT.format(fps) + " FPS";
+                Log.i(TAG, mStrfps);
+            }
+        }
+    }
+
+    public void setResolution(int width, int height) {
+        mWidth = width;
+        mHeight = height;
+    }
+
+    public void draw(Canvas canvas, float offsetx, float offsety) {
+        Log.d(TAG, mStrfps);
+        canvas.drawText(mStrfps, offsetx, offsety, mPaint);
+    }
+
+}

openCVLibrary2411/src/main/java/org/opencv/android/InstallCallbackInterface.java

+package org.opencv.android;
+
+/**
+ * Installation callback interface.
+ */
+public interface InstallCallbackInterface
+{
+    /**
+     * New package installation is required.
+     */
+    static final int NEW_INSTALLATION = 0;
+    /**
+     * Current package installation is in progress.
+     */
+    static final int INSTALLATION_PROGRESS = 1;
+
+    /**
+     * Target package name.
+     * @return Return target package name.
+     */
+    public String getPackageName();
+    /**
+     * Installation is approved.
+     */
+    public void install();
+    /**
+     * Installation is canceled.
+     */
+    public void cancel();
+    /**
+     * Wait for package installation.
+     */
+    public void wait_install();
+};

openCVLibrary2411/src/main/java/org/opencv/android/LoaderCallbackInterface.java

+package org.opencv.android;
+
+/**
+ * Interface for callback object in case of asynchronous initialization of OpenCV.
+ */
+public interface LoaderCallbackInterface
+{
+    /**
+     * OpenCV initialization finished successfully.
+     */
+    static final int SUCCESS = 0;
+    /**
+     * Google Play Market cannot be invoked.
+     */
+    static final int MARKET_ERROR = 2;
+    /**
+     * OpenCV library installation has been canceled by the user.
+     */
+    static final int INSTALL_CANCELED = 3;
+    /**
+     * This version of OpenCV Manager Service is incompatible with the app. Possibly, a service update is required.
+     */
+    static final int INCOMPATIBLE_MANAGER_VERSION = 4;
+    /**
+     * OpenCV library initialization has failed.
+     */
+    static final int INIT_FAILED = 0xff;
+
+    /**
+     * Callback method, called after OpenCV library initialization.
+     * @param status status of initialization (see initialization status constants).
+     */
+    public void onManagerConnected(int status);
+
+    /**
+     * Callback method, called in case the package installation is needed.
+     * @param callback answer object with approve and cancel methods and the package description.
+     */
+    public void onPackageInstall(final int operation, InstallCallbackInterface callback);
+};

openCVLibrary2411/src/main/java/org/opencv/android/NativeCameraView.java

+package org.opencv.android;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ViewGroup.LayoutParams;
+
+/**
+ * This class is an implementation of a bridge between SurfaceView and native OpenCV camera.
+ * Due to the big amount of work done, by the base class this child is only responsible
+ * for creating camera, destroying camera and delivering frames while camera is enabled
+ */
+public class NativeCameraView extends CameraBridgeViewBase {
+
+    public static final String TAG = "NativeCameraView";
+    private boolean mStopThread;
+    private Thread mThread;
+
+    protected VideoCapture mCamera;
+    protected NativeCameraFrame mFrame;
+
+    public NativeCameraView(Context context, int cameraId) {
+        super(context, cameraId);
+    }
+
+    public NativeCameraView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected boolean connectCamera(int width, int height) {
+
+        /* 1. We need to instantiate camera
+         * 2. We need to start thread which will be getting frames
+         */
+        /* First step - initialize camera connection */
+        if (!initializeCamera(width, height))
+            return false;
+
+        /* now we can start update thread */
+        mThread = new Thread(new CameraWorker());
+        mThread.start();
+
+        return true;
+    }
+
+    @Override
+    protected void disconnectCamera() {
+        /* 1. We need to stop thread which updating the frames
+         * 2. Stop camera and release it
+         */
+        if (mThread != null) {
+            try {
+                mStopThread = true;
+                mThread.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } finally {
+                mThread =  null;
+                mStopThread = false;
+            }
+        }
+
+        /* Now release camera */
+        releaseCamera();
+    }
+
+    public static class OpenCvSizeAccessor implements ListItemAccessor {
+
+        public int getWidth(Object obj) {
+            Size size  = (Size)obj;
+            return (int)size.width;
+        }
+
+        public int getHeight(Object obj) {
+            Size size  = (Size)obj;
+            return (int)size.height;
+        }
+
+    }
+
+    private boolean initializeCamera(int width, int height) {
+        synchronized (this) {
+
+            if (mCameraIndex == -1)
+                mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            else
+                mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID + mCameraIndex);
+
+            if (mCamera == null)
+                return false;
+
+            if (mCamera.isOpened() == false)
+                return false;
+
+            mFrame = new NativeCameraFrame(mCamera);
+
+            java.util.List<Size> sizes = mCamera.getSupportedPreviewSizes();
+
+            /* Select the size that fits surface considering maximum size allowed */
+            Size frameSize = calculateCameraFrameSize(sizes, new OpenCvSizeAccessor(), width, height);
+
+            mFrameWidth = (int)frameSize.width;
+            mFrameHeight = (int)frameSize.height;
+
+            if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT))
+                mScale = Math.min(((float)height)/mFrameHeight, ((float)width)/mFrameWidth);
+            else
+                mScale = 0;
+
+            if (mFpsMeter != null) {
+                mFpsMeter.setResolution(mFrameWidth, mFrameHeight);
+            }
+
+            AllocateCache();
+
+            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, frameSize.width);
+            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, frameSize.height);
+        }
+
+        Log.i(TAG, "Selected camera frame size = (" + mFrameWidth + ", " + mFrameHeight + ")");
+
+        return true;
+    }
+
+    private void releaseCamera() {
+        synchronized (this) {
+            if (mFrame != null) mFrame.release();
+            if (mCamera != null) mCamera.release();
+        }
+    }
+
+    private static class NativeCameraFrame implements CvCameraViewFrame {
+
+        @Override
+        public Mat rgba() {
+            mCapture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            return mRgba;
+        }
+
+        @Override
+        public Mat gray() {
+            mCapture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+            return mGray;
+        }
+
+        public NativeCameraFrame(VideoCapture capture) {
+            mCapture = capture;
+            mGray = new Mat();
+            mRgba = new Mat();
+        }
+
+        public void release() {
+            if (mGray != null) mGray.release();
+            if (mRgba != null) mRgba.release();
+        }
+
+        private VideoCapture mCapture;
+        private Mat mRgba;
+        private Mat mGray;
+    };
+
+    private class CameraWorker implements Runnable {
+
+        public void run() {
+            do {
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "Camera frame grab failed");
+                    break;
+                }
+
+                deliverAndDrawFrame(mFrame);
+            } while (!mStopThread);
+        }
+    }
+
+}

openCVLibrary2411/src/main/java/org/opencv/android/OpenCVLoader.java

+package org.opencv.android;
+
+import android.content.Context;
+
+/**
+ * Helper class provides common initialization methods for OpenCV library.
+ */
+public class OpenCVLoader
+{
+    /**
+     * OpenCV Library version 2.4.2.
+     */
+    public static final String OPENCV_VERSION_2_4_2 = "2.4.2";
+
+    /**
+     * OpenCV Library version 2.4.3.
+     */
+    public static final String OPENCV_VERSION_2_4_3 = "2.4.3";
+
+    /**
+     * OpenCV Library version 2.4.4.
+     */
+    public static final String OPENCV_VERSION_2_4_4 = "2.4.4";
+
+    /**
+     * OpenCV Library version 2.4.5.
+     */
+    public static final String OPENCV_VERSION_2_4_5 = "2.4.5";
+
+    /**
+     * OpenCV Library version 2.4.6.
+     */
+    public static final String OPENCV_VERSION_2_4_6 = "2.4.6";
+
+    /**
+     * OpenCV Library version 2.4.7.
+     */
+    public static final String OPENCV_VERSION_2_4_7 = "2.4.7";
+
+    /**
+     * OpenCV Library version 2.4.8.
+     */
+    public static final String OPENCV_VERSION_2_4_8 = "2.4.8";
+
+    /**
+     * OpenCV Library version 2.4.9.
+     */
+    public static final String OPENCV_VERSION_2_4_9 = "2.4.9";
+
+    /**
+     * OpenCV Library version 2.4.10.
+     */
+    public static final String OPENCV_VERSION_2_4_10 = "2.4.10";
+
+    /**
+     * OpenCV Library version 2.4.11.
+     */
+    public static final String OPENCV_VERSION_2_4_11 = "2.4.11";
+
+    /**
+     * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java").
+     * @return Returns true is initialization of OpenCV was successful.
+     */
+    public static boolean initDebug()
+    {
+        return StaticHelper.initOpenCV(false);
+    }
+
+    /**
+     * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java").
+     * @param InitCuda load and initialize CUDA runtime libraries.
+     * @return Returns true is initialization of OpenCV was successful.
+     */
+    public static boolean initDebug(boolean InitCuda)
+    {
+        return StaticHelper.initOpenCV(InitCuda);
+    }
+
+    /**
+     * Loads and initializes OpenCV library using OpenCV Engine service.
+     * @param Version OpenCV library version.
+     * @param AppContext application context for connecting to the service.
+     * @param Callback object, that implements LoaderCallbackInterface for handling the connection status.
+     * @return Returns true if initialization of OpenCV is successful.
+     */
+    public static boolean initAsync(String Version, Context AppContext,
+            LoaderCallbackInterface Callback)
+    {
+        return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback);
+    }
+}

openCVLibrary2411/src/main/java/org/opencv/android/StaticHelper.java

+package org.opencv.android;
+
+import org.opencv.core.Core;
+
+import java.util.StringTokenizer;
+import android.util.Log;
+
+class StaticHelper {
+
+    public static boolean initOpenCV(boolean InitCuda)
+    {
+        boolean result;
+        String libs = "";
+
+        if(InitCuda)
+        {
+            loadLibrary("cudart");
+            loadLibrary("nppc");
+            loadLibrary("nppi");
+            loadLibrary("npps");
+            loadLibrary("cufft");
+            loadLibrary("cublas");
+        }
+
+        Log.d(TAG, "Trying to get library list");
+
+        try
+        {
+            System.loadLibrary("opencv_info");
+            libs = getLibraryList();
+        }
+        catch(UnsatisfiedLinkError e)
+        {
+            Log.e(TAG, "OpenCV error: Cannot load info library for OpenCV");
+        }
+
+        Log.d(TAG, "Library list: \"" + libs + "\"");
+        Log.d(TAG, "First attempt to load libs");
+        if (initOpenCVLibs(libs))
+        {
+            Log.d(TAG, "First attempt to load libs is OK");
+            String eol = System.getProperty("line.separator");
+            for (String str : Core.getBuildInformation().split(eol))
+                Log.i(TAG, str);
+
+            result = true;
+        }
+        else
+        {
+            Log.d(TAG, "First attempt to load libs fails");
+            result = false;
+        }
+
+        return result;
+    }
+
+    private static boolean loadLibrary(String Name)
+    {
+        boolean result = true;
+
+        Log.d(TAG, "Trying to load library " + Name);
+        try
+        {
+            System.loadLibrary(Name);
+            Log.d(TAG, "Library " + Name + " loaded");
+        }
+        catch(UnsatisfiedLinkError e)
+        {
+            Log.d(TAG, "Cannot load library \"" + Name + "\"");
+            e.printStackTrace();
+            result &= false;
+        }
+
+        return result;
+    }
+
+    private static boolean initOpenCVLibs(String Libs)
+    {
+        Log.d(TAG, "Trying to init OpenCV libs");
+
+        boolean result = true;
+
+        if ((null != Libs) && (Libs.length() != 0))
+        {
+            Log.d(TAG, "Trying to load libs by dependency list");
+            StringTokenizer splitter = new StringTokenizer(Libs, ";");
+            while(splitter.hasMoreTokens())
+            {
+                result &= loadLibrary(splitter.nextToken());
+            }
+        }
+        else
+        {
+            // If dependencies list is not defined or empty.
+            result &= loadLibrary("opencv_java");
+        }
+
+        return result;
+    }
+
+    private static final String TAG = "OpenCV/StaticHelper";
+
+    private static native String getLibraryList();
+}

openCVLibrary2411/src/main/java/org/opencv/android/Utils.java

+package org.opencv.android;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.highgui.Highgui;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Utils {
+
+    public static String exportResource(Context context, int resourceId) {
+        return exportResource(context, resourceId, "OpenCV_data");
+    }
+
+    public static String exportResource(Context context, int resourceId, String dirname) {
+        String fullname = context.getResources().getString(resourceId);
+        String resName = fullname.substring(fullname.lastIndexOf("/") + 1);
+        try {
+            InputStream is = context.getResources().openRawResource(resourceId);
+            File resDir = context.getDir(dirname, Context.MODE_PRIVATE);
+            File resFile = new File(resDir, resName);
+
+            FileOutputStream os = new FileOutputStream(resFile);
+
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while ((bytesRead = is.read(buffer)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            is.close();
+            os.close();
+
+            return resFile.getAbsolutePath();
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new CvException("Failed to export resource " + resName
+                    + ". Exception thrown: " + e);
+        }
+    }
+
+    public static Mat loadResource(Context context, int resourceId) throws IOException
+    {
+        return loadResource(context, resourceId, -1);
+    }
+
+    public static Mat loadResource(Context context, int resourceId, int flags) throws IOException
+    {
+        InputStream is = context.getResources().openRawResource(resourceId);
+        ByteArrayOutputStream os = new ByteArrayOutputStream(is.available());
+
+        byte[] buffer = new byte[4096];
+        int bytesRead;
+        while ((bytesRead = is.read(buffer)) != -1) {
+            os.write(buffer, 0, bytesRead);
+        }
+        is.close();
+
+        Mat encoded = new Mat(1, os.size(), CvType.CV_8U);
+        encoded.put(0, 0, os.toByteArray());
+        os.close();
+
+        Mat decoded = Highgui.imdecode(encoded, flags);
+        encoded.release();
+
+        return decoded;
+    }
+
+    /**
+     * Converts Android Bitmap to OpenCV Mat.
+     * <p>
+     * This function converts an Android Bitmap image to the OpenCV Mat.
+     * <br>'ARGB_8888' and 'RGB_565' input Bitmap formats are supported.
+     * <br>The output Mat is always created of the same size as the input Bitmap and of the 'CV_8UC4' type,
+     * it keeps the image in RGBA format.
+     * <br>This function throws an exception if the conversion fails.
+     * @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'.
+     * @param mat is a valid output Mat object, it will be reallocated if needed, so it may be empty.
+     * @param unPremultiplyAlpha is a flag, that determines, whether the bitmap needs to be converted from alpha premultiplied format (like Android keeps 'ARGB_8888' ones) to regular one; this flag is ignored for 'RGB_565' bitmaps.
+     */
+    public static void bitmapToMat(Bitmap bmp, Mat mat, boolean unPremultiplyAlpha) {
+        if (bmp == null)
+            throw new java.lang.IllegalArgumentException("bmp == null");
+        if (mat == null)
+            throw new java.lang.IllegalArgumentException("mat == null");
+        nBitmapToMat2(bmp, mat.nativeObj, unPremultiplyAlpha);
+    }
+
+    /**
+     * Short form of the bitmapToMat(bmp, mat, unPremultiplyAlpha=false).
+     * @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'.
+     * @param mat is a valid output Mat object, it will be reallocated if needed, so Mat may be empty.
+     */
+    public static void bitmapToMat(Bitmap bmp, Mat mat) {
+        bitmapToMat(bmp, mat, false);
+    }
+
+
+    /**
+     * Converts OpenCV Mat to Android Bitmap.
+     * <p>
+     * <br>This function converts an image in the OpenCV Mat representation to the Android Bitmap.
+     * <br>The input Mat object has to be of the types 'CV_8UC1' (gray-scale), 'CV_8UC3' (RGB) or 'CV_8UC4' (RGBA).
+     * <br>The output Bitmap object has to be of the same size as the input Mat and of the types 'ARGB_8888' or 'RGB_565'.
+     * <br>This function throws an exception if the conversion fails.
+     *
+     * @param mat is a valid input Mat object of types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'.
+     * @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'.
+     * @param premultiplyAlpha is a flag, that determines, whether the Mat needs to be converted to alpha premultiplied format (like Android keeps 'ARGB_8888' bitmaps); the flag is ignored for 'RGB_565' bitmaps.
+     */
+    public static void matToBitmap(Mat mat, Bitmap bmp, boolean premultiplyAlpha) {
+        if (mat == null)
+            throw new java.lang.IllegalArgumentException("mat == null");
+        if (bmp == null)
+            throw new java.lang.IllegalArgumentException("bmp == null");
+        nMatToBitmap2(mat.nativeObj, bmp, premultiplyAlpha);
+    }
+
+    /**
+     * Short form of the <b>matToBitmap(mat, bmp, premultiplyAlpha=false)</b>
+     * @param mat is a valid input Mat object of the types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'.
+     * @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'.
+     */
+    public static void matToBitmap(Mat mat, Bitmap bmp) {
+        matToBitmap(mat, bmp, false);
+    }
+
+
+    private static native void nBitmapToMat2(Bitmap b, long m_addr, boolean unPremultiplyAlpha);
+
+    private static native void nMatToBitmap2(long m_addr, Bitmap b, boolean premultiplyAlpha);
+}

openCVLibrary2411/src/main/java/org/opencv/contrib/Contrib.java

+
+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.contrib;
+
+import java.util.List;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.utils.Converters;
+
+public class Contrib {
+
+    public static final int
+            ROTATION = 1,
+            TRANSLATION = 2,
+            RIGID_BODY_MOTION = 4,
+            COLORMAP_AUTUMN = 0,
+            COLORMAP_BONE = 1,
+            COLORMAP_JET = 2,
+            COLORMAP_WINTER = 3,
+            COLORMAP_RAINBOW = 4,
+            COLORMAP_OCEAN = 5,
+            COLORMAP_SUMMER = 6,
+            COLORMAP_SPRING = 7,
+            COLORMAP_COOL = 8,
+            COLORMAP_HSV = 9,
+            COLORMAP_PINK = 10,
+            COLORMAP_HOT = 11,
+            RETINA_COLOR_RANDOM = 0,
+            RETINA_COLOR_DIAGONAL = 1,
+            RETINA_COLOR_BAYER = 2;
+
+
+    //
+    // C++:  void applyColorMap(Mat src, Mat& dst, int colormap)
+    //
+
+/**
+ * <p>Applies a GNU Octave/MATLAB equivalent colormap on a given image.</p>
+ *
+ * <p>Currently the following GNU Octave/MATLAB equivalent colormaps are
+ * implemented: enum <code></p>
+ *
+ * <p>// C++ code:</p>
+ *
+ *
+ * <p>COLORMAP_AUTUMN = 0,</p>
+ *
+ * <p>COLORMAP_BONE = 1,</p>
+ *
+ * <p>COLORMAP_JET = 2,</p>
+ *
+ * <p>COLORMAP_WINTER = 3,</p>
+ *
+ * <p>COLORMAP_RAINBOW = 4,</p>
+ *
+ * <p>COLORMAP_OCEAN = 5,</p>
+ *
+ * <p>COLORMAP_SUMMER = 6,</p>
+ *
+ * <p>COLORMAP_SPRING = 7,</p>
+ *
+ * <p>COLORMAP_COOL = 8,</p>
+ *
+ * <p>COLORMAP_HSV = 9,</p>
+ *
+ * <p>COLORMAP_PINK = 10,</p>
+ *
+ * <p>COLORMAP_HOT = 11</p>
+ *
+ *
+ * @param src The source image, grayscale or colored does not matter.
+ * @param dst The result is the colormapped source image. Note: "Mat.create" is
+ * called on dst.
+ * @param colormap The colormap to apply, see the list of available colormaps
+ * below.
+ *
+ * @see <a href="http://docs.opencv.org/modules/contrib/doc/colormaps.html#applycolormap">org.opencv.contrib.Contrib.applyColorMap</a>
+ */
+    public static void applyColorMap(Mat src, Mat dst, int colormap)
+    {
+
+        applyColorMap_0(src.nativeObj, dst.nativeObj, colormap);
+
+        return;
+    }
+
+
+    //
+    // C++:  int chamerMatching(Mat img, Mat templ, vector_vector_Point& results, vector_float& cost, double templScale = 1, int maxMatches = 20, double minMatchDistance = 1.0, int padX = 3, int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6, double orientationWeight = 0.5, double truncate = 20)
+    //
+
+    public static int chamerMatching(Mat img, Mat templ, List<MatOfPoint> results, MatOfFloat cost, double templScale, int maxMatches, double minMatchDistance, int padX, int padY, int scales, double minScale, double maxScale, double orientationWeight, double truncate)
+    {
+        Mat results_mat = new Mat();
+        Mat cost_mat = cost;
+        int retVal = chamerMatching_0(img.nativeObj, templ.nativeObj, results_mat.nativeObj, cost_mat.nativeObj, templScale, maxMatches, minMatchDistance, padX, padY, scales, minScale, maxScale, orientationWeight, truncate);
+        Converters.Mat_to_vector_vector_Point(results_mat, results);
+        return retVal;
+    }
+
+    public static int chamerMatching(Mat img, Mat templ, List<MatOfPoint> results, MatOfFloat cost)
+    {
+        Mat results_mat = new Mat();
+        Mat cost_mat = cost;
+        int retVal = chamerMatching_1(img.nativeObj, templ.nativeObj, results_mat.nativeObj, cost_mat.nativeObj);
+        Converters.Mat_to_vector_vector_Point(results_mat, results);
+        return retVal;
+    }
+
+
+    //
+    // C++:  Ptr_FaceRecognizer createEigenFaceRecognizer(int num_components = 0, double threshold = DBL_MAX)
+    //
+
+    // Return type 'Ptr_FaceRecognizer' is not supported, skipping the function
+
+
+    //
+    // C++:  Ptr_FaceRecognizer createFisherFaceRecognizer(int num_components = 0, double threshold = DBL_MAX)
+    //
+
+    // Return type 'Ptr_FaceRecognizer' is not supported, skipping the function
+
+
+    //
+    // C++:  Ptr_FaceRecognizer createLBPHFaceRecognizer(int radius = 1, int neighbors = 8, int grid_x = 8, int grid_y = 8, double threshold = DBL_MAX)
+    //
+
+    // Return type 'Ptr_FaceRecognizer' is not supported, skipping the function
+
+
+
+
+    // C++:  void applyColorMap(Mat src, Mat& dst, int colormap)
+    private static native void applyColorMap_0(long src_nativeObj, long dst_nativeObj, int colormap);
+
+    // C++:  int chamerMatching(Mat img, Mat templ, vector_vector_Point& results, vector_float& cost, double templScale = 1, int maxMatches = 20, double minMatchDistance = 1.0, int padX = 3, int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6, double orientationWeight = 0.5, double truncate = 20)
+    private static native int chamerMatching_0(long img_nativeObj, long templ_nativeObj, long results_mat_nativeObj, long cost_mat_nativeObj, double templScale, int maxMatches, double minMatchDistance, int padX, int padY, int scales, double minScale, double maxScale, double orientationWeight, double truncate);
+    private static native int chamerMatching_1(long img_nativeObj, long templ_nativeObj, long results_mat_nativeObj, long cost_mat_nativeObj);
+
+}

openCVLibrary2411/src/main/java/org/opencv/core/CvException.java

+package org.opencv.core;
+
+public class CvException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public CvException(String msg) {
+        super(msg);
+    }
+
+    @Override
+    public String toString() {
+        return "CvException [" + super.toString() + "]";
+    }
+}

openCVLibrary2411/src/main/java/org/opencv/core/CvType.java

+package org.opencv.core;
+
+public final class CvType {
+
+    // type depth constants
+    public static final int
+            CV_8U = 0, CV_8S = 1,
+            CV_16U = 2, CV_16S = 3,
+            CV_32S = 4,
+            CV_32F = 5,
+            CV_64F = 6,
+            CV_USRTYPE1 = 7;
+
+    // predefined type constants
+    public static final int
+            CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),
+            CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),
+            CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),
+            CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),
+            CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),
+            CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),
+            CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);
+
+    private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);
+
+    public static final int makeType(int depth, int channels) {
+        if (channels <= 0 || channels >= CV_CN_MAX) {
+            throw new java.lang.UnsupportedOperationException(
+                    "Channels count should be 1.." + (CV_CN_MAX - 1));
+        }
+        if (depth < 0 || depth >= CV_DEPTH_MAX) {
+            throw new java.lang.UnsupportedOperationException(
+                    "Data type depth should be 0.." + (CV_DEPTH_MAX - 1));
+        }
+        return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT);
+    }
+
+    public static final int CV_8UC(int ch) {
+        return makeType(CV_8U, ch);
+    }
+
+    public static final int CV_8SC(int ch) {
+        return makeType(CV_8S, ch);
+    }
+
+    public static final int CV_16UC(int ch) {
+        return makeType(CV_16U, ch);
+    }
+
+    public static final int CV_16SC(int ch) {
+        return makeType(CV_16S, ch);
+    }
+
+    public static final int CV_32SC(int ch) {
+        return makeType(CV_32S, ch);
+    }
+
+    public static final int CV_32FC(int ch) {
+        return makeType(CV_32F, ch);
+    }
+
+    public static final int CV_64FC(int ch) {
+        return makeType(CV_64F, ch);
+    }
+
+    public static final int channels(int type) {
+        return (type >> CV_CN_SHIFT) + 1;
+    }
+
+    public static final int depth(int type) {
+        return type & (CV_DEPTH_MAX - 1);
+    }
+
+    public static final boolean isInteger(int type) {
+        return depth(type) < CV_32F;
+    }
+
+    public static final int ELEM_SIZE(int type) {
+        switch (depth(type)) {
+        case CV_8U:
+        case CV_8S:
+            return channels(type);
+        case CV_16U:
+        case CV_16S:
+            return 2 * channels(type);
+        case CV_32S:
+        case CV_32F:
+            return 4 * channels(type);
+        case CV_64F:
+            return 8 * channels(type);
+        default:
+            throw new java.lang.UnsupportedOperationException(
+                    "Unsupported CvType value: " + type);
+        }
+    }
+
+    public static final String typeToString(int type) {
+        String s;
+        switch (depth(type)) {
+        case CV_8U:
+            s = "CV_8U";
+            break;
+        case CV_8S:
+            s = "CV_8S";
+            break;
+        case CV_16U:
+            s = "CV_16U";
+            break;
+        case CV_16S:
+            s = "CV_16S";
+            break;
+        case CV_32S:
+            s = "CV_32S";
+            break;
+        case CV_32F:
+            s = "CV_32F";
+            break;
+        case CV_64F:
+            s = "CV_64F";
+            break;
+        case CV_USRTYPE1:
+            s = "CV_USRTYPE1";
+            break;
+        default:
+            throw new java.lang.UnsupportedOperationException(
+                    "Unsupported CvType value: " + type);
+        }
+
+        int ch = channels(type);
+        if (ch <= 4)
+            return s + "C" + ch;
+        else
+            return s + "C(" + ch + ")";
+    }
+
+}

openCVLibrary2411/src/main/java/org/opencv/core/MatOfByte.java

+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MatOfByte extends Mat {
+    // 8UC(x)
+    private static final int _depth = CvType.CV_8U;
+    private static final int _channels = 1;
+
+    public MatOfByte() {
+        super();
+    }
+
+    protected MatOfByte(long addr) {
+        super(addr);
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfByte fromNativeAddr(long addr) {
+        return new MatOfByte(addr);
+    }
+
+    public MatOfByte(Mat m) {
+        super(m, Range.all());
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfByte(byte...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(byte...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public byte[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+            throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        byte[] a = new byte[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Byte> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Byte ab[] = lb.toArray(new Byte[0]);
+        byte a[] = new byte[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Byte> toList() {
+        byte[] a = toArray();
+        Byte ab[] = new Byte[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}

openCVLibrary2411/src/main/java/org/opencv/core/MatOfDMatch.java

+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.features2d.DMatch;
+
+public class MatOfDMatch extends Mat {
+    // 32FC4
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 4;
+
+    public MatOfDMatch() {
+        super();
+    }
+
+    protected MatOfDMatch(long addr) {
+        super(addr);
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat: " + toString());
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfDMatch fromNativeAddr(long addr) {
+        return new MatOfDMatch(addr);
+    }
+
+    public MatOfDMatch(Mat m) {
+        super(m, Range.all());
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat: " + toString());
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfDMatch(DMatch...ap) {
+        super();
+        fromArray(ap);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+
+    public void fromArray(DMatch...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length;
+        alloc(num);
+        float buff[] = new float[num * _channels];
+        for(int i=0; i<num; i++) {
+            DMatch m = a[i];
+            buff[_channels*i+0] = m.queryIdx;
+            buff[_channels*i+1] = m.trainIdx;
+            buff[_channels*i+2] = m.imgIdx;
+            buff[_channels*i+3] = m.distance;
+        }
+        put(0, 0, buff); //TODO: check ret val!
+    }
+
+    public DMatch[] toArray() {
+        int num = (int) total();
+        DMatch[] a = new DMatch[num];
+        if(num == 0)
+            return a;
+        float buff[] = new float[num * _channels];
+        get(0, 0, buff); //TODO: check ret val!
+        for(int i=0; i<num; i++)
+            a[i] = new DMatch((int) buff[_channels*i+0], (int) buff[_channels*i+1], (int) buff[_channels*i+2], buff[_channels*i+3]);
+        return a;
+    }
+
+    public void fromList(List<DMatch> ldm) {
+        DMatch adm[] = ldm.toArray(new DMatch[0]);
+        fromArray(adm);
+    }
+
+    public List<DMatch> toList() {
+        DMatch[] adm = toArray();
+        return Arrays.asList(adm);
+    }
+}

openCVLibrary2411/src/main/java/org/opencv/core/MatOfDouble.java

+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MatOfDouble extends Mat {
+    // 64FC(x)
+    private static final int _depth = CvType.CV_64F;
+    private static final int _channels = 1;
+
+    public MatOfDouble() {
+        super();
+    }
+
+    protected MatOfDouble(long addr) {
+        super(addr);
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfDouble fromNativeAddr(long addr) {
+        return new MatOfDouble(addr);
+    }
+
+    public MatOfDouble(Mat m) {
+        super(m, Range.all());
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfDouble(double...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(double...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public double[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+            throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        double[] a = new double[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Double> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Double ab[] = lb.toArray(new Double[0]);
+        double a[] = new double[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Double> toList() {
+        double[] a = toArray();
+        Double ab[] = new Double[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}

openCVLibrary2411/src/main/java/org/opencv/core/MatOfFloat.java

+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MatOfFloat extends Mat {
+    // 32FC1
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 1;
+
+    public MatOfFloat() {
+        super();
+    }
+
+    protected MatOfFloat(long addr) {
+        super(addr);
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfFloat fromNativeAddr(long addr) {
+        return new MatOfFloat(addr);
+    }
+
+    public MatOfFloat(Mat m) {
+        super(m, Range.all());
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfFloat(float...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(float...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public float[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+            throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        float[] a = new float[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Float> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Float ab[] = lb.toArray(new Float[0]);
+        float a[] = new float[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Float> toList() {
+        float[] a = toArray();
+        Float ab[] = new Float[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}