¿Cómo usar OpenCV en Android Studio usando la herramienta de comstackción Gradle?

Quiero usar Android Studio para desarrollar una aplicación usando la herramienta de comstackción Gradle. No puedo insertar el repository y la biblioteca de OpenCV en build.gradle . Mi archivo .gradle es como a continuación:

 buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.5.+' } } apply plugin: 'android' repositories { mavenCentral() } dependencies { compile 'com.android.support:support-v4:13.0.+' } android { compileSdkVersion 17 buildToolsVersion "17.0.0" defaultConfig { minSdkVersion 7 targetSdkVersion 16 } } 

¿Cómo puedo agregar OpenCV en mi proyecto? Gracias.

Puedes hacerlo fácilmente en Android Studio.

Siga los pasos a continuación para agregar CV abierto en su proyecto como biblioteca.

  1. Crea una carpeta de libraries debajo del directorio principal de tu proyecto. Por ejemplo, si su proyecto es OpenCVExamples , creará una carpeta OpenCVExamples/libraries .

  2. Vaya a la ubicación donde tiene SDK “\ OpenCV-2.4.8-android-sdk \ sdk” aquí encontrará la carpeta java , opencv a opencv .

  3. Ahora copie el directorio completo de opencv del SDK en la carpeta de bibliotecas que acaba de crear.

  4. Ahora crea un archivo build.gradle en el directorio opencv con los siguientes contenidos

     apply plugin: 'android-library' buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.9.+' } } android { compileSdkVersion 19 buildToolsVersion "19.0.1" defaultConfig { minSdkVersion 8 targetSdkVersion 19 versionCode 2480 versionName "2.4.8" } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] resources.srcDirs = ['src'] res.srcDirs = ['res'] aidl.srcDirs = ['src'] } } } 
  5. Edite su archivo settings.gradle en el directorio principal de su aplicación y agregue esta línea:

     include ':libraries:opencv' 
  6. Sincronice su proyecto con Gradle y debería verse así

    pantalla 1

  7. Haga clic con el botón derecho en su proyecto y luego haga clic en Open Module Settings luego elija Módulos en la lista de la izquierda, haga clic en el módulo de su aplicación, haga clic en la pestaña Dependencias y haga clic en el botón + para agregar una nueva dependencia de módulo.

    enter image description here

  8. Elija la Module dependency . Se abrirá un diálogo con una lista de módulos para elegir; seleccione “: libraries: opencv”.

    enter image description here

  9. Cree una carpeta jniLibs en /app/src/main/ location y copie toda la carpeta con archivos * .so (armeabi, armeabi-v7a, mips, x86) en jniLibs desde OpenCV SDK.

    enter image description here

  10. Haga clic en Aceptar. Ahora todo hecho, ve y disfruta con OpenCV.

Según los documentos de OpenCV ( 1 ), debajo de los pasos que usan el administrador de OpenCV es la forma recomendada de usar OpenCV para ejecuciones de producción . Pero, el administrador de OpenCV ( 2 ) es una instalación adicional de Google play store. Por lo tanto, si prefiere una apk autónoma (sin usar el administrador de OpenCV) o se encuentra actualmente en fase de desarrollo / prueba , le sugiero que responda en https://stackoverflow.com/a/27421494/1180117 .

Pasos recomendados para usar OpenCV en Android Studio con el administrador de OpenCV.

  1. Descomprime OpenCV Android sdk descargado de OpenCV.org ( 3 )
  2. Desde File -> Import Module , elija la carpeta sdk/java en el archivo descomprimido opencv.
  3. Actualice build.gradle bajo el módulo OpenCV importado para actualizar 4 campos para que coincidan con el build.gradle su proyecto a) compileSdkVersion b) buildToolsVersion c) minSdkVersion y 4) targetSdkVersion.
  4. Agregue dependencia de módulo por Application -> Module Settings , y seleccione la pestaña Dependencies . Haga clic en el icono + en la parte inferior (o derecha), seleccione Module Dependency y seleccione el módulo OpenCV importado.

Como paso final, en tu clase de Actividad, agrega un fragmento a continuación.

  public class SampleJava extends Activity { private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) { @Override public void onManagerConnected(int status) { switch(status) { case LoaderCallbackInterface.SUCCESS: Log.i(TAG,"OpenCV Manager Connected"); //from now onwards, you can use OpenCV API Mat m = new Mat(5, 10, CvType.CV_8UC1, new Scalar(0)); break; case LoaderCallbackInterface.INIT_FAILED: Log.i(TAG,"Init Failed"); break; case LoaderCallbackInterface.INSTALL_CANCELED: Log.i(TAG,"Install Cancelled"); break; case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION: Log.i(TAG,"Incompatible Version"); break; case LoaderCallbackInterface.MARKET_ERROR: Log.i(TAG,"Market Error"); break; default: Log.i(TAG,"OpenCV Manager Install"); super.onManagerConnected(status); break; } } }; @Override protected void onResume() { super.onResume(); //initialize OpenCV manager OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this, mLoaderCallback); } } 

Nota: solo puede hacer llamadas de OpenCV después de recibir una callback onManagerConnected método onManagerConnected . Durante la ejecución, se le solicitará la instalación del administrador de OpenCV desde Play Store, si aún no está instalado. Durante el desarrollo, si no tiene acceso a play store o está en emualtor, use la apk del administrador de OpenCV presente en la carpeta apk en el archivo sdk de OpenCV descargado.

Pros

  • Reducción del tamaño del apk en alrededor de 40 MB (considere también las actualizaciones).
  • El administrador de OpenCV instala binarios optimizados para su hardware que podrían ayudar a acelerar.
  • Las actualizaciones del administrador de OpenCV pueden salvar su aplicación de errores en OpenCV.
  • Las diferentes aplicaciones podrían compartir la misma biblioteca OpenCV.

Contras

  • Experiencia del usuario final: puede que no le guste un mensaje de instalación desde su aplicación.

Si no quieres usar JavaCV, esto funciona para mí …

Paso 1- Descarga los recursos

Descargue OpenCV Android SDK desde http://opencv.org/downloads.html

Paso 2: copia los binarios de OpenCV en tu APK

Copie libopencv_info.so y libopencv_java.so de

OpenCV-2.?.?-android-sdk -> sdk -> native -> libs -> armeabi-v7a

a

Project Root -> Your Project -> lib - > armeabi-v7a

Comprime la carpeta lib y renómbrala a lo que sea-v7a.jar.

Copia este archivo .jar y colócalo aquí en tu proyecto

Project Root -> Your Project -> libs

Agregue esta línea a sus proyectos build.gradle en la sección de dependencias

compile files('libs/whatever-v7a.jar')

Cuando compiles ahora, probablemente verás que tu .apk es aproximadamente 4mb más grande.

(Repita para “armeabi” si también desea soportar ARMv6, probablemente ya no sea necesario).

Paso 3 – Agregar el java sdk a tu proyecto

Copia la carpeta java desde aquí

OpenCV-2.?.?-android-sdk -> sdk

a

Project Root -> Your Project -> libs (El mismo lugar que su archivo .jar);

(Puede cambiar el nombre de la carpeta ‘java’ a ‘OpenCV’)

En esta carpeta recién copiada, agregue un archivo build.gradle típico; Usé esto:

 buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.6.+' } } apply plugin: 'android-library' repositories { mavenCentral(); } android { compileSdkVersion 19 buildToolsVersion "19" defaultConfig { minSdkVersion 15 targetSdkVersion 19 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] resources.srcDirs = ['src'] aidl.srcDirs = ['src'] renderscript.srcDirs = ['src'] res.srcDirs = ['res'] assets.srcDirs = ['assets'] } } } 

En su archivo de configuración de Project Root, cámbielo también y tenga un aspecto similar a este:

include ':Project Name:libs:OpenCV', ':Project Name'

En su raíz de proyecto -> Nombre del proyecto -> archivo build.gradle en la sección de dependencias, agregue esta línea:

compile project(':Project Name:libs:OpenCV')

Paso 4 – Uso de OpenCV en tu proyecto

Reconstruya y podrá importar y comenzar a usar OpenCV en su proyecto.

 import org.opencv.android.OpenCVLoader; ... if (!OpenCVLoader.initDebug()) {} 

Lo sé si un poco de hack pero pensé que lo publicaría de todos modos.

 buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:0.5.+' } } apply plugin: 'android' repositories { mavenCentral() maven { url 'http://maven2.javacv.googlecode.com/git/' } } dependencies { compile 'com.android.support:support-v4:13.0.+' compile 'com.googlecode.javacv:javacv:0.5' instrumentTestCompile 'junit:junit:4.4' } android { compileSdkVersion 14 buildToolsVersion "17.0.0" defaultConfig { minSdkVersion 7 targetSdkVersion 14 } } 

Esto me funciona 🙂

He publicado una nueva publicación sobre cómo crear una aplicación Android NDK con OpenCV incluida con Android Studio y Gradle. Se puede ver más información aquí . He resumido dos métodos:

(1) ejecuta ndk-build dentro de la tarea de Gradle

 sourceSets.main.jni.srcDirs = [] task ndkBuild(type: Exec, description: 'Compile JNI source via NDK') { ndkDir = project.plugins.findPlugin('com.android.application').getNdkFolder() commandLine "$ndkDir/ndk-build", 'NDK_PROJECT_PATH=build/intermediates/ndk', 'NDK_LIBS_OUT=src/main/jniLibs', 'APP_BUILD_SCRIPT=src/main/jni/Android.mk', 'NDK_APPLICATION_MK=src/main/jni/Application.mk' } tasks.withType(JavaCompile) { compileTask -> compileTask.dependsOn ndkBuild } 

(2) ejecuta ndk-build con una herramienta externa

Parámetros: NDK_PROJECT_PATH=$ModuleFileDir$/build/intermediates/ndk NDK_LIBS_OUT=$ModuleFileDir$/src/main/jniLibs NDK_APPLICATION_MK=$ModuleFileDir$/src/main/jni/Application.mk APP_BUILD_SCRIPT=$ModuleFileDir$/src/main/jni/Android.mk V=1

Más información se puede ver aquí

Funciona con Android Studio 1.2 + OpenCV-2.4.11-android-sdk (.zip), también.

Solo haz lo siguiente:

1) Siga la respuesta que comienza con “Puede hacerlo fácilmente en Android Studio. Siga los pasos a continuación para agregar OpenCV en su proyecto como biblioteca”. por TGMCians.

2) Modifique en la \libraries\opencv su \libraries\opencv recién creado a (paso 4 en la respuesta de TGMCians, adaptado a OpenCV2.4.11-android-sdk y usando gradle 1.1.0 ):

 apply plugin: 'android-library' buildscript { repositories { mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:1.1.0' } } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 8 targetSdkVersion 21 versionCode 2411 versionName "2.4.11" } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] resources.srcDirs = ['src'] res.srcDirs = ['res'] aidl.srcDirs = ['src'] } } } 

3) * .so archivos que se encuentran en los directorios "armeabi", "armeabi-v7a", "mips", "x86" se pueden encontrar en (ubicación predeterminada de OpenCV): ..\OpenCV-2.4.11-android-sdk\OpenCV-android-sdk\sdk\native\libs (paso 9 en la respuesta de TGMCians).

Disfrútalo y, si esto te ayudó, por favor da una buena reputación. Necesito 50 para responder directamente a las respuestas (19 izquierda) 🙂

Estos son los pasos necesarios para usar OpenCV con Android Studio 1.2:

  • Descarga OpenCV y extrae el archivo
  • Abra su proyecto de aplicación en Android Studio
  • Ir a Archivo -> Nuevo -> Importar módulo …
  • Seleccione sdk/java en el directorio que extrajo antes
  • Establecer el nombre del módulo en opencv
  • Presione Siguiente luego Terminar
  • Abra build.gradle bajo el módulo OpenCV importado y actualice compileSdkVersion y buildToolsVersion a las versiones que tenga en su máquina
  • Agregue el compile project(':opencv') a su aplicación build.gradle

     dependencies { ... compile project(':opencv') } 
  • Presione Proyecto de sincronización con archivos Gradle

Como la integración de OpenCV es tal esfuerzo, lo preempaquetamos y lo publicamos a través de JCenter aquí: https://github.com/quickbirdstudios/opencv-android

Simplemente incluya esto en la sección de dependencias build.gradle de su módulo

 dependencies { implementation 'com.quickbirdstudios:opencv:3.4.1' } 

y esto en la sección build.gradle repositories de tu proyecto

 repositories { jcenter() } 

He importado el proyecto Java de OpenCV SDK a un proyecto gradle de Android Studio y lo he puesto a disposición en https://github.com/ctodobom/OpenCV-3.1.0-Android

Puede incluirlo en su proyecto solo agregando dos líneas en el archivo build.gradle gracias al servicio jitpack.io.

Los siguientes permisos y características son necesarios en el archivo AndroidManifest.xml sin el cual obtendrá el siguiente cuadro de diálogo

“Parece que su dispositivo no es compatible con la cámara (o está bloqueado). La aplicación se cerrará”

       

OpenCV, Android Studio 1.4.1, complemento gradle-experimental 0.2.1

Ninguna de las otras respuestas me ayudó. Esto es lo que funcionó para mí. Estoy usando la muestra tutorial-1 de opencv, pero lo haré usando el NDK en mi proyecto, así que estoy usando el plugin gradle-experimental, que tiene una estructura diferente a la del plugin gradle.

Se debe instalar Android Studio, Android NDK se debe instalar a través de Android SDK Manager y OpenCV Android SDK se debe descargar y descomprimir.

Esto está en fragmentos de script bash para mantenerlo compacto pero completo. También está todo en la línea de comandos porque uno de los grandes problemas que tuve fue que las instrucciones de IDE estaban obsoletas a medida que evolucionó el IDE.

Primero configure la ubicación del directorio raíz del OpenCV SDK.

 export OPENCV_SDK=/home/user/wip/OpenCV-2.4.11-android-sdk cd $OPENCV_SDK 

Crea tus archivos de comstackción gradle …

Primero la biblioteca OpenCV

 cat > $OPENCV_SDK/sdk/java/build.gradle <<'===' apply plugin: 'com.android.model.library' model { android { compileSdkVersion = 23 buildToolsVersion = "23.0.2" defaultConfig.with { minSdkVersion.apiLevel = 8 targetSdkVersion.apiLevel = 23 } } android.buildTypes { release { minifyEnabled = false } debug{ minifyEnabled = false } } android.sources { main.manifest.source.srcDirs += "." main.res.source.srcDirs += "res" main.aidl.source.srcDirs += "src" main.java.source.srcDirs += "src" } } === 

Luego dígale a la muestra del tutorial cómo etiquetar la biblioteca y dónde encontrarla.

 cat > $OPENCV_SDK/samples/tutorial-1-camerapreview/settings.gradle <<'===' include ':openCVLibrary2411' project(':openCVLibrary2411').projectDir = new File('../../sdk/java') === 

Crea el archivo de comstackción para el tutorial.

 cat > $OPENCV_SDK/samples/tutorial-1-camerapreview/build.gradle <<'===' buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle-experimental:0.2.1' } } allprojects { repositories { jcenter() } } apply plugin: 'com.android.model.application' model { android { compileSdkVersion = 23 buildToolsVersion = "23.0.2" defaultConfig.with { applicationId = "org.opencv.samples.tutorial1" minSdkVersion.apiLevel = 8 targetSdkVersion.apiLevel = 23 } } android.sources { main.manifest.source.srcDirs += "." main.res.source.srcDirs += "res" main.aidl.source.srcDirs += "src" main.java.source.srcDirs += "src" } android.buildTypes { release { minifyEnabled = false proguardFiles += file('proguard-rules.pro') } debug { minifyEnabled = false } } } dependencies { compile project(':openCVLibrary2411') } === 

La versión de herramientas de comstackción debe configurarse correctamente. Aquí hay una manera fácil de ver lo que tiene instalado. (Puede instalar otras versiones a través del Administrador de Android SDK). Cambie buildToolsVersion si no tiene 23.0.2.

 echo "Your buildToolsVersion is one of: " ls $ANDROID_HOME/build-tools 

Cambie la variable de entorno en la primera línea a su número de versión

 REP=23.0.2 #CHANGE ME sed -i.bak s/23\.0\.2/${REP}/g $OPENCV_SDK/sdk/java/build.gradle sed -i.bak s/23\.0\.2/${REP}/g $OPENCV_SDK/samples/tutorial-1-camerapreview/build.gradle 

Finalmente, configure la envoltura gradle correcta. Gradle necesita un directorio limpio para hacer esto.

 pushd $(mktemp -d) gradle wrapper --gradle-version 2.5 mv -f gradle* $OPENCV_SDK/samples/tutorial-1-camerapreview popd 

Ahora debería estar todo listo. Ahora puede navegar a este directorio con Android Studio y abrir el proyecto.

Construya el tutoral en la línea de comando con el siguiente comando:

 ./gradlew assembleDebug 

Debería construir tu apk, poniéndolo en ./build/outputs/apk

El OpenCV Android SDK tiene un ejemplo de archivo gradle.build con comentarios útiles: https://github.com/opencv/opencv/blob/master/modules/java/android_sdk/build.gradle.in

 // // Notes about integration OpenCV into existed Android Studio application project are below (application 'app' module should exist). // // This file is located in /sdk directory (near 'etc', 'java', 'native' subdirectories) // // Add module into Android Studio application project: // // - Android Studio way: // (will copy almost all OpenCV Android SDK into your project, ~200Mb) // // Import module: Menu -> "File" -> "New" -> "Module" -> "Import Gradle project": // Source directory: select this "sdk" directory // Module name: ":opencv" // // - or attach library module from OpenCV Android SDK // (without copying into application project directory, allow to share the same module between projects) // // Edit "settings.gradle" and add these lines: // // def opencvsdk='' // // You can put declaration above into gradle.properties file instead (including file in HOME directory), // // but without 'def' and apostrophe symbols ('): opencvsdk= // include ':opencv' // project(':opencv').projectDir = new File(opencvsdk + '/sdk') // // // // Add dependency into application module: // // - Android Studio way: // "Open Module Settings" (F4) -> "Dependencies" tab // // - or add "project(':opencv')" dependency into app/build.gradle: // // dependencies { // implementation fileTree(dir: 'libs', include: ['*.jar']) // ... // implementation project(':opencv') // } // // // // Load OpenCV native library before using: // // - avoid using of "OpenCVLoader.initAsync()" approach - it is deprecated // It may load library with different version (from OpenCV Android Manager, which is installed separatelly on device) // // - use "System.loadLibrary("opencv_java3")" or "OpenCVLoader.initDebug()" // TODO: Add accurate API to load OpenCV native library // // // // Native C++ support (necessary to use OpenCV in native code of application only): // // - Use find_package() in app/CMakeLists.txt: // // find_package(OpenCV 3.4 REQUIRED java) // ... // target_link_libraries(native-lib ${OpenCV_LIBRARIES}) // // - Add "OpenCV_DIR" and enable C++ exceptions/RTTI support via app/build.gradle // Documentation about CMake options: https://developer.android.com/ndk/guides/cmake.html // // defaultConfig { // ... // externalNativeBuild { // cmake { // cppFlags "-std=c++11 -frtti -fexceptions" // arguments "-DOpenCV_DIR=" + opencvsdk + "/sdk/native/jni" // , "-DANDROID_ARM_NEON=TRUE" // } // } // } // // - (optional) Limit/filter ABIs to build ('android' scope of 'app/build.gradle'): // Useful information: https://developer.android.com/studio/build/gradle-tips.html (Configure separate APKs per ABI) // // splits { // abi { // enable true // reset() // include 'armeabi-v7a' // , 'x86', 'x86_64', 'arm64-v8a' // universalApk false // } // } // apply plugin: 'com.android.library' println "OpenCV: " + project.buildscript.sourceFile android { compileSdkVersion 27 //buildToolsVersion "27.0.3" // not needed since com.android.tools.build:gradle:3.0.0 defaultConfig { minSdkVersion 14 targetSdkVersion 21 } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt' } } compileOptions { sourceCompatibility JavaVersion.VERSION_1_6 targetCompatibility JavaVersion.VERSION_1_6 } sourceSets { main { jniLibs.srcDirs = ['native/libs'] java.srcDirs = ['java/src'] aidl.srcDirs = ['java/src'] res.srcDirs = ['java/res'] manifest.srcFile 'java/AndroidManifest.xml' } } } dependencies { }