OpenCV Android Programming By Example

Chapter 1. Getting Yourself Ready

In this chapter, I will explain, in a step-by-step fashion, how to start using OpenCV to develop vision-aware Android applications.

The Open Source Computer Vision (OpenCV) software library has over 2,500 optimized algorithms; the library includes a comprehensive set of both classic and state-of-the-art computer vision and machine learning algorithms. It has been around for a decade and released under the Berkeley Software Distribution (BSD) license, making it easy for users to utilize and modify the code.

OpenCV is downloaded over seven million times and used by well-established companies such as Google, Yahoo, Microsoft, Intel, IBM, Sony, and Honda. Moreover, OpenCV supports several desktop and mobile operating systems including Windows, Linux, Mac OS X, Android, and iOS.

In this book, we will work with OpenCV for Android, which is a part of OpenCV that runs on the Android operating system.

I'll be covering two scenarios for the installation and to get ready; first, if you are starting a clean installation for Android, it is recommended that you start with Tegra Android Development Pack (TADP). The other scenario is a manual setup of every component needed to run Android with OpenCV. You would probably go with this option if you already have a previous installation of the Android development environment. We will cover the following topics:

Installing Tegra Android Development Pack
Installing the OpenCV and Android development environment manually
Understanding how Native Development Kit (NDK) works
Building your first Android project with OpenCV

Installing Tegra Android Development Pack

TADP was released by NVIDIA to make the preparation for the Android development environment a seamless process.

NVIDIA has released TADP version 3.0r4 to support Android SDK (23.0.2), NDK (r10c), and OpenCV for Tegra 2.4.8.2, which is a regular OpenCV4Android SDK extended with Tegra-specific optimizations.

Downloading and installing TADP

To get TADP, visit https://developer.nvidia.com/tegra-android-development-pack and follow the steps to become a registered developer; it is a free membership.

Once you have your membership activated, log in and download the version corresponding to your operating system. NVIDIA supports the following operating systems:

Windows 64-bit
Mac OS X
Ubuntu Linux (32/64-bit)

In my case, I have Windows 7 64-bit on my machine, so from now on, all the upcoming steps are tested and working fine on this operating system. However, I don't expect any major changes if you are working with a different operating system.

Note

For the Ubuntu installation, TADP will need you to have root privileges, so make sure that you do.

Once you finish downloading the TADP installer, launch it and perform the following steps:

Follow the onscreen instructions after you read and accept the license agreement.
You will need to choose the type of installation. Select a Custom installation and click on the Next button:
Select the components to be installed as depicted and click on the Next button:
You need to name the installation and download the directory.
Note
Note that if you have a previous installation, you will get a warning message that the previous installation needs to be uninstalled. To uninstall the previous installation, go to the previous installation directory and run tadp_uninstall.exe.
Sometimes, the uninstaller doesn't clean everything. In this case, you need to delete the contents of the previous installation directory manually.
Now you are ready to install the selected components. Click on the Next button.
In case you are behind a proxy, you can enter the proxy details; otherwise, click on the Next button.
The installer will start to download all the selected components; this may take a while depending on your Internet connection.
After the download has finished, click Next to start installing the selected components.
Note
Sometimes, the installer window will not respond; this is okay. After a few minutes, the installation will continue in a normal way.
Select the post-installation action that you want and click on the Finish button.

TADP post-installation configuration

Yes, TADP will download and install everything for you; yet you still need to do some post-installation configuration in order to make sure that everything will work properly.

Installing emulator system images

You need to install a system image for every Android SDK platform installed in case you want to run an emulator with this SDK platform as a target.

To do so, just follow these simple steps:

Go to the installation directory that you selected while installing TADP.
Open the SDK folder; in this case, it is android-sdk-windows.
Run the SDK Manager.
For every installed Android X.X, select a system image for the emulator, such as ARM EABI V7a System Image:
Click Install packages.
Read and accept the license agreement for the selected components.
Click Install.

Now, you can test your applications on an emulator of any of the installed targets.

Configuring Eclipse to work with NDK

You also need to configure Eclipse to run with NDK so that you can build your native apps directly from Eclipse:

Launch Eclipse from the installation directory that you specified earlier.
Open Window | Preferences.
In the pane on the left-hand side, open Android Tree.
Select the tree node labeled NDK.
In the right pane, click Browse and select the NDK directory; you will find it under the installation directory.
Click OK.

NDK verification

As the OpenCV libraries are written in C/C++, the first step to verify that your environment is working is to make sure that you are able to run Android applications that use native code:

Launch Eclipse.
From the NDK installation directory—in my case, C:\NVPACK\android-ndk-r10c\—import the hello-jni sample project from the samples folder as if you are importing any other Android project.
Right-click on the HelloJni project.
In the context menu, choose Android Tools | Add Native Support.
Make sure that the library name is set to hello-jni; it should be named this by default.
Start the emulator with the target of your choice.
Right click on the hello-jni project in the project explorer. In the context menu, choose Run as | Android application.

In your console output, there should be a list of .so files; these are the native shared libraries that NDK has built using Application Binary Interface (ABI), which defines exactly how your machine code should look.

Android NDK supports different architectures. By default, your .so will be built for ARM EABI in addition to MIPS and x86 if you specify so in the application.mk file. We will discuss this subject later in this chapter.

If everything runs smoothly, your emulator should have an app running as follows:

This application is very simple and a good checkpoint to verify that you are able to invoke native code from your Android application.

Basically, what you see on the emulator screen is a string returned from the native code and displayed by the Android framework in a text view.

Installing the OpenCV and Android development environment manually

To choose to manually install OpenCV and the Android development environment, you probably have the following installed components on your machine:

Java SE Development Kit 6
Android Studio
Android SDK
Eclipse IDE
ADT and CDT plugin for Eclipse
Android NDK
OpenCV4Android SDK

You could go through the manual installation steps to make sure that you have all the needed components in order to start developing Android applications with OpenCV is ready and properly configured.

Java SE Development Kit 6

You can download the JDK installer for your OS from http://www.oracle.com/technetwork/java/javase/downloads/index.html.

Android Studio

Another very good option to work with is the Android Studio. You can download the Android Studio from http://developer.android.com/sdk/index.html. Note that Android Studio comes bundled with Android SDK, so you don't need to install it if you go with this option. Additionally, you can skip the Eclipse and ADT installation and note that starting from Android Studio 1.3; you will find built-in support for NDK as well.

Android SDK

To download and install Android SDK, follow these steps:

Go to http://developer.android.com/sdk/index.html.
Scroll down to the SDK Tools Only section and click on the .exe file of Windows installer link.
After you have read and accepted the terms and conditions, click the download button.
Save the installer on your disk and click on the .exe file to start the installer and then follow the onscreen instructions.
Keep a note of the SDK directory to refer to it later from the command line.
Once the installation is done, Android SDK Manager will start.
Select to install Android SDK Tools, revision 20 or newer.
For the SDK platform, Android, select Android 3.0 (API 11) or higher. In my case, I used API 15 and you are recommended to do so.
Read and accept the license agreement, then click Install.

Eclipse IDE

For OpenCV 2.4.x, it is recommended to have Eclipse 3.7 (Indigo) or Eclipse 4.2 (Juno); you can download your selected version from Eclipse's official website at http://www.eclipse.org/downloads/.

ADT and CDT plugins for Eclipse

Assuming that you have already downloaded Eclipse, you can follow these steps to download the Android Developer Tools (ADT) and C/C++ Development Tool (CDT) plugins:

Launch Eclipse and then navigate to Help | Install New Software.
Click the Add button in the top corner to the right.
In the Add Repository dialog, write ADT Plug-in in the Name field and copy and paste this URL, https://dl-ssl.google.com/android/eclipse/, in the Location field.
Click OK.
Check the Developer Tools checkbox.
Click Next.
A list of the tools to be downloaded will be shown in the next window. Just make sure that it includes the native support tools (CDT) and click Next.
Read and accept the license agreement and click Finish.
Once the installation is complete, you will need to restart Eclipse.

Android NDK

In order to develop for Android in C++, you will need to install Android NDK.

Note

Android NDK is not meant to be used in all situations. As a developer, you need to balance between the performance gains that come with using a native API and the introduced complexity.

In our case, as the OpenCV libraries are written in C/C++, we might have to use NDK. However, using NDK shouldn't be just because the programmer prefers to write in C/C++.

Downloading Android NDK

You can download Android NDK by following these steps:

Go to the Android NDK home page, http://developer.android.com/tools/sdk/ndk/index.html.
In the Downloads section, select the version corresponding to your operating system. In my case, it is Windows 64-bit.
Read and agree with the terms and conditions.
Click the Download button.

Installing and configuring Android NDK

Once the download has finished, you will need to follow these steps to configure NDK:

Navigate to the NDK download folder.
Double-click on the downloaded file to extract it.
Rename and move the extracted folder; I'll refer to the ndk folder as <ndk_home>. Now you are ready to use NDK to build your projects.
If you prefer to build from the command line, you will need to add the <ndk_home> folder (in my case, C:/android/android-ndk-r10d) to your PATH environment variable. For Windows, open CMD. Enter the following command and replace the ndk directory with yours:
```
set PATH=%PATH%;c:/android/android-ndk-r10d
```
To check that NDK is configured properly, go to the directory that contains your project. For simplicity, you can test on the hello-jni sample project. You can find it under <ndk_home>/samples/.
Change the directory by executing the command cd <your_project_directory>/. Run the following command:
```
ndk-build
```
As depicted in the console output, the files with the .so extension are the compiled version of the C/C++ source code used in this project:

Building native code using Eclipse

If you prefer to build from Eclipse, which is more convenient, you will need to tell Eclipse where to find NDK so that you can build your apps:

Launch Eclipse and open Window | Preferences.
In the left-hand side pane, open the Android tree.
Select the NDK tree node and in the right-hand side pane, click Browse and select the <ndk_home> directory.
Click OK.
Import the hello-jni sample project from <ndk_home>/samples/ as an Android project.
Open the Project Explorer and right-click on the hello-jni project.
In the context menu, navigate to Android Tools | Add Native Support to convert this project to a C++ project.
Accept the default library name and click Finish.
Build the application.

In the console, you will see a list of .so files, which are the compiled C++ part of this project. Still, if you open any C/C++ file from the imported project, you will see many highlighted errors. You just need to do some extra steps related to the CDT plugin:

Navigate to Project | Properties. In the left-hand side pane, expand the C/C++ General node.
Select Paths and Symbols.
In the right-hand side pane, select the Includes tab.
Click Add and then File system to add the following paths:
- If you installed NDK r8 or prior:
  <ndk_home>/platforms/android-9/arch-arm/usr/include<ndk_home>/sources/cxx-stl/gnu-libstdc++/include<ndk_home>/sources/cxx-stl/gnu-libstdc++/libs/armeabi-v7a/include
- If you installed NDK r8b or later:
  <ndk_home> /platforms/android-9/arch-arm/usr/include
  <ndk_home>/sources/cxx-stl/gnu-libstdc++/4.6/include
  <ndk_home> /sources/cxx-stl/gnu-libstdc++/4.6/libs/armeabi-v7a/include
Click OK. Eclipse will rebuild the project and all the syntax errors should be cleared from Eclipse.
Now, you can build the project to package both the Java and native code in one APK. To install the application on the emulator of your choice, use the menu item, Run | Run As | Android Application.

OpenCV4Android SDK

To be able to use the OpenCV collection of native (C/C++) libraries on your Android device, you need to install OpenCV4Android SDK, which is a part of OpenCV to run on the Android operating system.

First, go to the OpenCV download page, http://sourceforge.net/projects/opencvlibrary/files/opencv-android/.
Download the latest available version, which, at the time this book is being written, was 2.4.10.
Extract the compressed file to a convenient path, for example, C:\opencv\.
Note
It is highly recommended to use paths with no spaces to avoid any problems with ndk-build.

Understanding how NDK works

Whether you had a clean installation using TADP or followed the manual setup steps, at this stage you should have all the needed components to develop vision-aware Android applications.

Before we move forward to our first example, let's first elaborate on how NDK works. It's always a good idea to familiarize yourself with the basics of Android NDK and be comfortable using it as it will be a cornerstone to our development of Android applications using OpenCV.

An overview of NDK

If you decided to compile the native part of your Android application using the command prompt, you must have used the ndk-build tool. The ndk-build tool is actually a script that launches different build scripts that are responsible for the following:

It automatically searches your project to decide on what to build
Once the search is done, the scripts start generating binaries and managing dependencies
It copies the generated binaries to your project path

Besides the ndk-build tool, there are a few other main components that you should be familiar with, including the following:

Java and native calls: Android applications are written in Java, and once the source code is compiled, it is transformed to bytecode so that the Android OS runs under the Dalvik or Android Runtime (ART) virtual machine.
Note
Note that the applications that execute the native code are tested only on a Dalvik virtual machine.
When you are using methods implemented in native code, you should use the native keyword.
For example, you could declare a function that multiplies two numbers and instructs the compiler that it is a native library:
```
public native double mul(double x, double y);
```
Native shared libraries: NDK builds these libraries with an extension, .so. As the name suggests, these libraries are shared and linked in runtime.
Native static libraries: NDK also builds these libraries with an extension, .a; these kind of libraries are actually linked at the compile time.
Java Native Interface (JNI): As you write your Android application in Java, you need a way to channel your calls to the native libraries written in C/C++ and that's where the JNI comes in handy.
Application Binary Interface (ABI): It is the interface that defines how your application machine code should look as you can run your application on different machine architectures. By default, NDK builds your code for ARM EABI; however, you can also select it to be built for MIPS or x86.
Android.mk: Think of this file as a Maven build script or better, a make file, which instructs the ndk-build script about the definitions of the module and its name, the source files that you need to compile, and also the libraries that you need to link. It is very important to understand how to use this file and we will come back to it later for more details.
Application.mk: It is optional to create this file and it is used to list the modules that your application requires. This information can include ABIs to generate machine code for a specific target architecture, toolchains, and standard libraries.

With these components in mind, you can summarize the general flow of developing native applications for Android as follows:

Decide which parts will be written in Java and which parts will be written in native C/C++.
Create an Android application in Eclipse.
Create an Android.mk file to define your module, list the native source code files to be compiled, and enumerate the linked libraries.
Create Application.mk; this is optional.
Copy your Anrdoid.mk file under the jni folder in your project path.
Build the project using Eclipse. As we linked Eclipse to the installed NDK, the ndk-build tool will compile the .so, .a libraries, your Java code will be compiled to the .dex files, and everything will be packaged in one single APK file and ready to be installed.

A simple example of NDK

As you will be developing Android applications with native support, you will need to be familiar with the general structure of a typical Android application using NDK.

Usually, your Android application has the following folder structure. The project root folder has the following subdirectories:

jni/
libs/
res/
src/
AndroidManifest.xml
project.properties

Here, the NDK-related folders are as follows:

The jni folder will contain the native part of your application. In other words, this is the C/C++ source code with the NDK build scripts such as Android.mk and Application.mk, which are needed to build the native libraries.
The libs folder will contain the native libraries after a successful build.
Note
The NDK build system requires both the AndroidManifest.xml and project.properties files to compile the native part of your application. So, if any of these files are missing, you will need to compile your Java code first before compiling the C/C++ code.

Android.mk

In this section, I'll describe the syntax of the Android.mk build file. As mentioned before, Android.mk is actually a GNU makefile fragment that the build system parses to know what to build in your project. The syntax of the file allows you to define modules. A module is one of the following:

A static library
A shared library
A standalone executable

You already used ndk-build to build the hello-jni project, so let's take a look at the contents of this project Android.mk file:

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE    := hello-jni
LOCAL_SRC_FILES := hello-jni.c

include $(BUILD_SHARED_LIBRARY)

Now, let's go through these lines one by one:

LOCAL_PATH := $(call my-dir): Here, the script defines a variable called LOCAL_PATH and sets its value by calling the my-dir function, which returns the current working directory.
include $(CLEAR_VARS): In this line, the script includes another GNU makefile called CLEAR_VARS to clear all the local variables—variables starting with Local_XXX with the exception of LOCAL_PATH. This is needed because the build files are parsed in a single-make execution context where all the variables are declared as global.
LOCAL_MODULE := hello-jni: Here, the script defines a module called hello-jni. The LOCAL_MODULE variable must be defined and unique to identify each module in Android.mk.
Note
The build system will add the lib prefix and .so suffix to your defined modules. In the example case, the generated library will be named libhello-jni.so.
LOCAL_SRC_FILES := hello-jni.c: As the name suggests, you will list all the source files that you need be built and assembled in one module.
Note
You only list the source files and not the header files; it is the responsibility of the build system to compute the dependency for you.
include $(BUILD_SHARED_LIBRARY): Here we are including another GNU makefile, which will collect all the information that you defined after the last include command and decide what to build and how to build your module.

Building your first Android project with OpenCV

With the development environment up and running and having the proper NDK background, I can start assembling the big picture on how you can use the OpenCV libraries in your Android application.

OpenCV for Android supports access to its functions through its native API and also its Java wrappers API. In the case of a native API, you will define your native library using Android NDK and include the OpenCV libraries that you are using. Then, you will call your native library from the Java code using Java Native Interface (JNI).

The other option is to use the OpenCV Java wrappers directly in your Java code using the usual Java imports. What will happen is that the Java wrappers will channel your calls to the native OpenCV libraries using JNI.

Of course, it is up to you to choose which style to go with; however, you should understand that using native calls could result in less JNI overhead but require more programming effort. On the other hand, using Java wrappers could cause more JNI overhead with less programming effort.

Note

Consider this scenario: you are processing a video frame or still image and in your algorithm, you will call several OpenCV functions. In this case, it is better to write one native library that calls all these functions. In your Android application, you can access this native library using only one JNI call.

HelloVisionWorld Android application

We will build our first Android application to grab preview frames from the camera in real time and display the preview on a fullscreen using OpenCV's Java camera API.

Creating a project in Eclipse

Following are the steps to create a project in Eclipse:

Launch Eclipse and create a new workspace.
Create a new Android project and name your application HelloVisionWorld.
Set the Minimum SDK version. To build with OpenCV4Android SDK, the minimum SDK version is 11; however, it is highly recommended to use API 15 or higher. In my case, I used API 15.
Select Target SDK. In my case, I set it to API 19. Click Next.
Allow Eclipse to create New Blank Activity and name it HelloVisionActivity with a layout named activity_hello_vision.
Import the OpenCV library project to your workspace. Navigate to File | Import | Existing Android Code Into Workspace.
Select the root directory of OpenCV4Android SDK. Deselect All the sample projects and select only OpenCV Library and click Finish:
Reference the OpenCV library from your Android project. Click Project | Properties. Select the Android tree node from the left-hand side pane and in the right-hand side pane, click Add in the Library section and then OK:

Creating a project in Android Studio

Following are the steps to create a project in Android Studio:

Launch Android Studio.
Create a new Android Studio project and name it HelloVisionWorld with Company Domain set to app0.com.
Choose Minimum SDK. To build with OpenCV4Android SDK, the Minimum SDK version is 11.
Create a blank activity and name it HelloVisionActivity.
To add OpenCV as a dependency to your project, navigate to File | New | Import Module and <OpenCV4Android_Directoy>\sdk\java. Then, click OK. At this point, you may face some issues depending on the components installed from Android SDK. Android Studio will propose quick-fix links to solve such errors and it should be a straightforward fix.
Right-click on your newly created application in the project view and choose Open Module Settings or press F4.
In the Dependencies tab, press the + button and select Module Dependency.
Choose the OpenCV library and press Add. Now, you should be able to import the OpenCV classes to your project.

Moving forward, you should be able to follow the steps regardless of your choice of an IDE:

Open the layout file and edit it to match the following code. We added the OpenCV namespace and defined a Java camera view layout:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:opencv="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.example.hellovisionworld.HelloVisionActivity" >
    <org.opencv.android.JavaCameraView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:visibility="gone"
        android:id="@+id/HelloVisionView"
        opencv:show_fps="true"
        opencv:camera_id="any" />
</RelativeLayout>

Note

Downloading the example code

You can download the example code files for all the Packt books that you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register in order to have the files e-mailed to you directly.

As we will be using the device camera, we need to set some permissions in the AndroidManifest file:

</application>

<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"/>

Hide the title and system buttons in the AndroidManifest file:

<application
    android:icon="@drawable/icon"
    android:label="@string/app_name"
    android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >

We need to initialize the OpenCV library in the created activity. To do so, we use asynchronous initialization using the OpenCV Manager service to access the OpenCV libraries externally installed in the target system. First, we need to install the OpenCV Manager on the emulator that we will use. To do so, use the adb install command in the command prompt:

adb install <OpenCV4Android SDK_Home>\apk\OpenCV_2.4.X_Manager_2.X_<platform>.apk

Replace <OpenCV4Android SDK_Home> with your OpenCV installation folder and X in the apk name with the available versions in your apk folder.

For <platform>, use the following table to choose which platform to install according to the system image that is installed on your emulator:

Hardware platform	Package name
armeabi-v7a (ARMv7-A + NEON)	OpenCV_2.4.X_Manager_2.X_armv7a-neon.apk
armeabi (ARMv5, ARMv6)	OpenCV_2.4.X_Manager_2.X_armeabi.apk
Intel x86	OpenCV_2.4.X_Manager_2.X_x86.apk
MIPS	OpenCV_2.4.X_Manager_2.X_mips.apk

Note

When you are testing your application on a real device, a message will be displayed asking you to download the OpenCV manager from Google Play, so click Yes and check which version of OpenCV it supports so that you can load it through asynchronous initialization.

In Activity, define the following and fix the imports accordingly:

//A Tag to filter the log messages
private static final String  TAG = "Example::HelloVisionWorld::Activity";

//A class used to implement the interaction between OpenCV and the //device camera.
private CameraBridgeViewBase mOpenCvCameraView;

//This is the callback object used when we initialize the OpenCV //library asynchronously
private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {

    @Override
       //This is the callback method called once the OpenCV //manager is connected
    public void onManagerConnected(int status) {
      switch (status) {
  //Once the OpenCV manager is successfully connected we can enable the camera interaction with the defined OpenCV camera view
      case LoaderCallbackInterface.SUCCESS:
        {
          Log.i(TAG, "OpenCV loaded successfully");
          mOpenCvCameraView.enableView();
        } break;
          default:
            {
              super.onManagerConnected(status);
            } break;
       }
    }
};

Update the onResume activity callback method to load the OpenCV library and fix the imports accordingly:

@Override
public void onResume(){

  super.onResume();

//Call the async initialization and pass the callback object we //created later, and chose which version of OpenCV library to //load. Just make sure that the OpenCV manager you installed //supports the version you are trying to load.
  OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_10, this, mLoaderCallback);
}

Your activity needs to implement CvCameraViewListener2 to be able to receive camera frames from the OpenCV camera view:
```
public class HelloVisionActivity extends Activity implements CvCameraViewListener2
```
Fix the imports error accordingly and also insert the unimplemented methods in your activity.

In the onCreate activity callback method, we need to set the OpenCV camera view as visible and register your activity as the callback object that will handle the camera frames:

@Override
protected void onCreate(Bundle savedInstanceState) {
  Log.i(TAG, "called onCreate");

  super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  setContentView(R.layout.activity_hello_vision);

  mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.HelloVisionView);

  //Set the view as visible
  mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);

  //Register your activity as the callback object to handle //camera frames
  mOpenCvCameraView.setCvCameraViewListener(this);
}

The last step is to receive the camera frames. In order to do so, change the implementation of the onCameraFrame callback method:

public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

  //We're returning the colored frame as is to be rendered on //thescreen.
  return inputFrame.rgba();
}

Now you're ready to build and install your application on the emulator or on a real device.
This is the application running on an emulated camera:

Walter Sep 13, 2023

The book covers a interesting topic, but there is certainly some bugfixing involved if you use a newer library version and android obviously too:Obviously first of all you can just use IntelliJ or android studio for android developmentIt was challenging to get into the first chapters, because the file / image chooser from the beginning works differently in 2023, as android doesnt like file paths at all by now, and the file choosing must happen as input stream directly from the loaded Uri. The getPath method is obsolete because android doesnt want you to use them anymore, instead use a mediaquery. Android will refuse to give the app read access like back when in 2015 the book released.--->To inread image from storage:InputStream inputStream = getContentResolver().openInputStream(selectedImageUri); Mat imageMat = Imgcodecs.imdecode(new MatOfByte(IOUtils.toByteArray(inputStream)), Imgcodecs.IMREAD_COLOR);-> obviously you have to fix the load-image method aswell and skip the path making thing and just set the loaded image as original image to work with, instead of reading the path.----I also had trouble with installing Open Cv itself, but that can be fixed by using opencv from quickbirds from GitHub and use their solution by loading it with the (app)-build.gradle file.-----The async method, to check if open cv is loaded, made my app crash aswell, just use a log msg: Log.d("OpenCv loaded: " + OpenCVLoader.initDebug());-----Other than that i am half way through the book and some method names have changed, still its a great book to get into OpenCv i guess.

Amazon Verified review

OpenCV Android Programming By Example: Leverage OpenCV to develop vision-aware and intelligent Android applications.

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Downloading and installing TADP

Note

Note

TADP post-installation configuration

Installing emulator system images

Configuring Eclipse to work with NDK

NDK verification

Downloading Android NDK

Installing and configuring Android NDK

Building native code using Eclipse

Note

Note

A simple example of NDK

Note

Android.mk

Note

Note

Creating a project in Eclipse

Creating a project in Android Studio

Note

Note

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

People who bought this also bought

About the author

FAQs