Możesz to zrobić bardzo łatwo w Android Studio.

Wykonaj poniższe kroki, aby dodać otwarte CV do swojego projektu jako bibliotekę.

1. Utwórz folder libraries pod głównym katalogiem projektu. Na przykład, jeśli twoim projektem jest OpenCVExamples, utworzysz folder OpenCVExamples/libraries.

2. Przejdź do lokalizacji, w której masz SDK "\OpenCV-2.4.8-android-sdk \ sdk " tutaj znajdziesz folder java, zmień jego nazwę na opencv.

3. Teraz skopiuj kompletny opencv katalog z zestawu SDK do folderu biblioteki, który właśnie utworzyłeś.

4. Utwórz teraz Plik build.gradle w katalogu opencv o następującej zawartości

   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. Edytuj swoje ustawienia.plik gradle w głównym katalogu aplikacji i dodaj tę linię:

   include ':libraries:opencv'
   

6. Zsynchronizuj swój projekt z Gradle i powinien wyglądać tak

   

7. Kliknij prawym przyciskiem myszy swój projekt, następnie kliknij Open Module Settings Następnie wybierz Moduły z listy po lewej stronie kliknij moduł aplikacji, kliknij kartę zależności i kliknij przycisk+, aby dodać nowy moduł zależności.

   

8. Wybierz Module dependency. Otworzy okno dialogowe z listą modułów do wyboru; wybierz ": libraries: opencv".

   

9. Utwórz folder jniLibs w miejscu /app/src/main/ i skopiuj cały folder z plikami*. so (armeabi, armeabi-v7a, mips, x86) w jniLibs z OpenCV SDK.

   

10. Kliknij OK. Teraz wszystko zrobione, idź i ciesz się z OpenCV.

Zgodnie z dokumentami OpenCV(1), poniżej kroki korzystanie z OpenCV manager jest zalecanym sposobem użycia OpenCV dla produkcji Działa. Ale, OpenCV manager(2) jest dodatkową instalacją ze Sklepu Google play. Tak więc, jeśli wolisz samodzielny apk (nie używający Menedżera OpenCV) lub jest obecnie w fazie rozwoju / testowania, proponuję odpowiedź na https://stackoverflow.com/a/27421494/1180117 .

Zalecane kroki korzystania z OpenCV w Android Studio z menedżerem OpenCV.

1. Rozpakuj OpenCV Android sdk pobrany z OpenCV.org(3)
2. Z File -> Import Module Wybierz sdk/java folder w rozpakowanym archiwum opencv.
3. Update build.gradle under imported OpenCV module to update 4 fields to match your project ' s build.gradle a) compileSdkVersion b) buildToolsVersion c) minSdkVersion and 4) targetSdkVersion.
4. Dodaj zależność modułu przez {[5] } i wybierz kartę Dependencies. Kliknij ikonę + u dołu (lub po prawej), wybierz Module Dependency i wybierz importowany moduł OpenCV.

Ostatnim krokiem w klasie aktywności jest dodanie fragmentu poniżej.

    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);
    }
}

Uwaga: możesz wykonywać połączenia OpenCV dopiero po otrzymaniu pomyślnego wywołania zwrotnego metodą onManagerConnected . Podczas uruchamiania zostanie wyświetlony monit o instalację Menedżera OpenCV ze Sklepu play, jeśli nie jest on jeszcze zainstalowany. Podczas rozwoju, jeśli nie masz dostępu do Sklepu play lub jest na emualtor, użyj odpowiedniego OpenCV manager apk obecny w apk folder w pobranym archiwum OpenCV sdk .

Plusy

• zmniejszenie rozmiaru Apk o około 40 MB(rozważ również uaktualnienia).
• OpenCV manager instaluje zoptymalizowane binaria dla Twojego sprzętu, które mogą pomóc w szybkości.
• uaktualnienia do menedżera OpenCV mogą uratować Twoją aplikację przed błędami w OpenCV.
• różne aplikacje mogą współdzielić tę samą bibliotekę OpenCV.

Cons

• doświadczenie użytkownika końcowego-może się nie podobać monit instalacyjny z twojego podanie.

Ponieważ integracja OpenCV jest takim wysiłkiem, wstępnie spakowaliśmy go i opublikowaliśmy za pośrednictwem JCenter tutaj: https://github.com/quickbirdstudios/opencv-android

Po prostu dołącz to do swojego modułu.sekcja zależności gradle

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

I to w budowaniu Twojego projektu.sekcja repozytoriów gradle

repositories {
  jcenter()
}

Nie pojawi się błąd lint po imporcie gradle, ale nie zapomnij zainicjować biblioteki OpenCV w ten sposób w MainActivity

public class MainActivity extends Activity {
    static {
        if (!OpenCVLoader.initDebug())
            Log.d("ERROR", "Unable to load OpenCV");
        else
            Log.d("SUCCESS", "OpenCV loaded");
    }
...
...
...
...

Jeśli nie chcesz używać JavaCV to działa dla mnie...

Krok 1-Pobierz zasoby

Pobierz OpenCV Android SDK z http://opencv.org/downloads.html

Krok 2-Kopiowanie plików binarnych OpenCV do APK

Kopia libopencv_info.so & libopencv_java.so od

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

Do

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

Zapnij folder lib i zmień jego nazwę na whatever-v7a.jar.

Zrozumiałem .plik jar i umieść go tutaj w Twoim projekcie

Project Root -> Your Project -> libs

Dodaj tę linię do budowania projektów.gradle w sekcji zależności

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

Kiedy skompilujesz teraz prawdopodobnie zobaczysz swój .apk jest o 4mb większy.

(powtórz dla "armeabi", jeśli chcesz również wspierać ARMv6, prawdopodobnie już nie jest potrzebne.)

Krok 3-dodanie zestawu SDK Javy do projektu

Skopiuj folder java z tego miejsca

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

Do

Project Root -> Your Project -> libs (to samo miejsce jako twój .plik jar);

(możesz zmienić nazwę folderu 'java' na 'OpenCV')

W tym świeżo skopiowanym folderze dodaj typową kompilację.gradle file; użyłem tego:

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']
        }
    }
}

W Ustawieniach głównego projektu.gradle file change it too look something like this:

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

W katalogu głównym projektu - > Nazwa projektu - > build.plik gradle w sekcji zależności dodaj tę linię:

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

Krok 4-Korzystanie z OpenCV w Twoim projekt

Przebuduj i powinieneś być w stanie zaimportować i zacząć używać OpenCV w swoim projekcie.

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

Wiem to, jeśli trochę hack, ale pomyślałem, że i tak go opublikować.

Opublikowałem nowy post o tym, jak zbudować aplikację Android NDK z OpenCV w zestawie korzystanie z Android Studio i Gradle. Więcej informacji można zobaczyć tutaj , podsumowałem dwie metody:

(1) Uruchom ndk-build w ramach zadania 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) Uruchom ndk-build za pomocą zewnętrznego narzędzia

Parametry: 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

Więcej informacji można zobaczyć tutaj

Działa z Android Studio 1.2 + OpenCV-2.4.11-android-sdk (.zip), także.

Wykonaj następujące czynności:

1) postępuj zgodnie z odpowiedzią, która zaczyna się od " Możesz to zrobić bardzo łatwo w Android Studio. Wykonaj poniższe kroki, aby dodać OpenCV do swojego projektu jako bibliotekę."przez Tgmcian.

2) zmodyfikuj w folderze <yourAppDir>\libraries\opencv nowo utworzony build.gradle do (Krok 4 w odpowiedzi TGM, przystosowany do OpenCV2.4. 11-android-sdk i za pomocą 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)*. tak więc pliki znajdujące się w katalogach "armeabi", "armeabi-v7a", "mips", "x86" można znaleźć w (domyślna lokalizacja OpenCV): ..\OpenCV-2.4.11-android-sdk\OpenCV-android-sdk\sdk\native\libs (Krok 9 w odpowiedzi Tgmcian).

Ciesz się, a jeśli to pomogło, daj pozytywną reputację. Potrzebuję 50 aby odpowiedzieć bezpośrednio na odpowiedzi (19 zostało):)

[[6]}są to kroki niezbędne do korzystania z OpenCV z Androidem Studio 1.2:

• Pobierz OpenCV i rozpakuj archiwum
• Otwórz projekt aplikacji w Android Studio
• przejdź do File -> New - > Import Module...
• Wybierz sdk/java w katalogu, który rozpakowałeś przed
• Ustaw nazwę modułu na opencv
• naciśnij następny następnie Zakończ
• Open build.gradle pod zaimportowany moduł OpenCV i aktualizacja compileSdkVersion i buildToolsVersion do wersji, które masz na swojej maszynie

• Dodaj compile project(':opencv') do swojej aplikacji.gradle

  dependencies {
      ...
      compile project(':opencv')
  }
  

• Naciśnij Synchronizuj Projekt z plikami Gradle

OpenCV Android SDK ma przykładowy gradle.zbuduj Plik z pomocnymi komentarzami: 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 <OpenCV-android-sdk>/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='<path_to_opencv_android_sdk_rootdir>'
//   // You can put declaration above into gradle.properties file instead (including file in HOME directory),
//   // but without 'def' and apostrophe symbols ('): opencvsdk=<path_to_opencv_android_sdk_rootdir>
//   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 {
}

Zaimportowałem projekt Java z OpenCV SDK do projektu Android Studio gradle i udostępniłem go na https://github.com/ctodobom/OpenCV-3.1.0-Android

Możesz dołączyć go do swojego projektu dodając tylko dwie linie do pliku build.gradle dzięki jitpack.io obsługa.

Następujące uprawnienia i funkcje są niezbędne w AndroidManifest.plik xml, bez którego otrzymasz następujące okno dialogowe

"wydaje się, że Twoje urządzenie nie obsługuje kamery (lub jest zablokowane). Aplikacja zostanie zamknięta "

  <uses-permission android:name="android.permission.CAMERA"/>

    <uses-feature android:name="android.hardware.camera" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>

OpenCV, Android Studio 1.4.1, Gradle-experimental plugin 0.2.1

Żadna z innych odpowiedzi mi nie pomogła. Oto, co mi się udało. Używam tutorial-1 sample z opencv, ale będę robić za pomocą NDK w moim projekcie, więc używam gradle-experimental plugin, który ma inną strukturę niż plugin gradle.

Android studio powinno być zainstalowane, Android NDK powinno być zainstalowane przez Android SDK Manager, a OpenCV Android SDK należy pobrać i rozpakować.

To jest w kawałkach skryptu bash, aby zachować kompaktowy, ale kompletny. Jest to również wszystko w linii poleceń, ponieważ jednym z dużych problemów, jakie miałem, było to, że instrukcje in-IDE były przestarzałe, gdy IDE ewoluowało.

Najpierw ustaw lokalizację katalogu głównego OpenCV SDK.

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

Utwórz swoje pliki gradle build...

Najpierw biblioteka 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"
   }

}


===

Następnie powiedz próbce samouczka, co oznaczyć biblioteka jako i gdzie ją znaleźć.

cat > $OPENCV_SDK/samples/tutorial-1-camerapreview/settings.gradle <<'==='


include ':openCVLibrary2411'
project(':openCVLibrary2411').projectDir = new File('../../sdk/java')


===

Utwórz plik budowania dla samouczka.

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')
}


===

Twoja wersja narzędzi do budowania musi być poprawnie ustawiona. Oto prosty sposób aby zobaczyć, co zainstalowałeś. (Można zainstalować inne wersje za pośrednictwem Android SDK Manager). Zmień buildToolsVersion jeśli nie masz 23.0.2.

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

Zmień zmienną środowiskową w pierwszej linii na numer wersji

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

Na koniec skonfiguruj poprawne opakowanie gradle. Gradle potrzebuje czystego katalogu żeby to zrobić.

pushd $(mktemp -d)

gradle wrapper --gradle-version 2.5

mv -f gradle* $OPENCV_SDK/samples/tutorial-1-camerapreview
popd

Powinieneś być gotowy. Możesz teraz przejść do tego katalogu za pomocą Android Studio i otworzyć projekt.

Zbuduj tutoral w wierszu poleceń za pomocą następującego polecenia:

./gradlew assembleDebug

Powinien zbudować twój apk, umieszczając go w./ build/outputs / apk