generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #452 from asmorkalov:android_tutorial_update

Browse Source
This commit is contained in:
Andrey Kamaev 2013-02-08 18:43:57 +04:00 committed by OpenCV Buildbot
commit bb25111d23
2 changed files with 152 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.rst
View File

@ -78,39 +78,33 @@ See the "15-puzzle" OpenCV sample for details.
.. code-block:: java .. code-block:: java
:linenos: :linenos:
public class MyActivity extends Activity implements HelperCallbackInterface public class Sample1Java extends Activity implements CvCameraViewListener {
{
private BaseLoaderCallback mOpenCVCallBack = new BaseLoaderCallback(this) {
@Override
public void onManagerConnected(int status) {
switch (status) {
case LoaderCallbackInterface.SUCCESS:
{
Log.i(TAG, "OpenCV loaded successfully");
// Create and set View
mView = new puzzle15View(mAppContext);
setContentView(mView);
} break;
default:
{
super.onManagerConnected(status);
} break;
}
}
};
/** Call on every application resume **/ private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
@Override @Override
protected void onResume() public void onManagerConnected(int status) {
{ switch (status) {
Log.i(TAG, "called onResume"); case LoaderCallbackInterface.SUCCESS:
super.onResume(); {
Log.i(TAG, "OpenCV loaded successfully");
mOpenCvCameraView.enableView();
} break;
default:
{
super.onManagerConnected(status);
} break;
}
}
};
Log.i(TAG, "Trying to load OpenCV library"); @Override
if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) public void onResume()
{ {
Log.e(TAG, "Cannot connect to OpenCV Manager"); super.onResume();
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mLoaderCallback);
} }
...
} }
It this case application works with OpenCV Manager in asynchronous fashion. ``OnManagerConnected`` It this case application works with OpenCV Manager in asynchronous fashion. ``OnManagerConnected``
@ -297,110 +291,43 @@ application. It will be capable of accessing camera output, processing it and di
result. result.
#. Open Eclipse IDE, create a new clean workspace, create a new Android project #. Open Eclipse IDE, create a new clean workspace, create a new Android project
:menuselection:`File --> New --> Android Project`. :menuselection:`File --> New --> Android Project`
#. Set name, target, package and ``minSDKVersion`` accordingly. #. Set name, target, package and ``minSDKVersion`` accordingly. The minimal SDK version for build
with OpenCV4Android SDK is 11. Minimal device API Level (for application manifest) is 8.
#. Create a new class :menuselection:`File -> New -> Class`. Name it for example: #. Allow Eclipse to create default activity. Lets name the activity ``HelloOpenCvActivity``.
*HelloOpenCVView*.
.. image:: images/dev_OCV_new_class.png #. Choose Blank Activity with full screen layout. Lets name the layout ``HelloOpenCvLayout``.
:alt: Add a new class.
#. Import OpenCV library project to your workspace.
#. Reference OpenCV library within your project properties.
.. image:: images/dev_OCV_reference.png
:alt: Reference OpenCV library.
:align: center :align: center
* It should extend ``SurfaceView`` class. #. Edit your layout file as xml file and pass the following layout there:
* It also should implement ``SurfaceHolder.Callback``, ``Runnable``.
#. Edit ``HelloOpenCVView`` class. .. code-block:: xml
* Add an ``import`` line for ``android.content.context``.
* Modify autogenerated stubs: ``HelloOpenCVView``, ``surfaceCreated``, ``surfaceDestroyed`` and
``surfaceChanged``.
.. code-block:: java
:linenos: :linenos:
package com.hello.opencv.test; <LinearLayout 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" >
import android.content.Context; <org.opencv.android.JavaCameraView
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:visibility="gone"
android:id="@+id/HelloOpenCvView"
opencv:show_fps="true"
opencv:camera_id="any" />
public class HelloOpenCVView extends SurfaceView implements Callback, Runnable { </LinearLayout>
public HelloOpenCVView(Context context) {
super(context);
getHolder().addCallback(this);
}
public void surfaceCreated(SurfaceHolder holder) {
(new Thread(this)).start();
}
public void surfaceDestroyed(SurfaceHolder holder) {
cameraRelease();
}
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
cameraSetup(width, height);
}
* Add ``cameraOpen``, ``cameraRelease`` and ``cameraSetup`` voids as shown below.
* Also, don't forget to add the public void ``run()`` as follows:
.. code-block:: java
:linenos:
public void run() {
// TODO: loop { getFrame(), processFrame(), drawFrame() }
}
public boolean cameraOpen() {
return false; //TODO: open camera
}
private void cameraRelease() {
// TODO release camera
}
private void cameraSetup(int width, int height) {
// TODO setup camera
}
#. Create a new ``Activity`` :menuselection:`New -> Other -> Android -> Android Activity` and name
it, for example: *HelloOpenCVActivity*. For this activity define ``onCreate``, ``onResume`` and
``onPause`` voids.
.. code-block:: java
:linenos:
public void onCreate (Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mView = new HelloOpenCVView(this);
setContentView (mView);
}
protected void onPause() {
super.onPause();
mView.cameraRelease();
}
protected void onResume() {
super.onResume();
if( !mView.cameraOpen() ) {
// MessageBox and exit app
AlertDialog ad = new AlertDialog.Builder(this).create();
ad.setCancelable(false); // This blocks the "BACK" button
ad.setMessage("Fatal error: can't open camera!");
ad.setButton("OK", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
finish();
}
});
ad.show();
}
}
#. Add the following permissions to the :file:`AndroidManifest.xml` file: #. Add the following permissions to the :file:`AndroidManifest.xml` file:
@ -409,108 +336,120 @@ result.
</application> </application>
<uses-permission android:name="android.permission.CAMERA" /> <uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
#. Reference OpenCV library within your project properties. <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"/>
.. image:: images/dev_OCV_reference.png #. Set application theme in AndroidManifest.xml to hide title and system buttons.
:alt: Reference OpenCV library.
:align: center
#. We now need some code to handle the camera. Update the ``HelloOpenCVView`` class as follows: .. code-block:: xml
:linenos:
<application
android:icon="@drawable/icon"
android:label="@string/app_name"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
#. Add OpenCV library initialization to your activity. Fix errors by adding requited imports.
.. code-block:: java
:linenos:
private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
@Override
public void onManagerConnected(int status) {
switch (status) {
case LoaderCallbackInterface.SUCCESS:
{
Log.i(TAG, "OpenCV loaded successfully");
mOpenCvCameraView.enableView();
} break;
default:
{
super.onManagerConnected(status);
} break;
}
}
};
@Override
public void onResume()
{
super.onResume();
OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mLoaderCallback);
}
#. Defines that your activity implements CvViewFrameListener interface and fix activity related
errors by defining missed methods. For this activity define ``onCreate``, ``onDestroy`` and
``onPause`` and implement them according code snippet bellow. Fix errors by adding requited
imports.
.. code-block:: java .. code-block:: java
:linenos: :linenos:
private VideoCapture mCamera; private CameraBridgeViewBase mOpenCvCameraView;
public boolean cameraOpen() { @Override
synchronized (this) { public void onCreate(Bundle savedInstanceState) {
cameraRelease(); Log.i(TAG, "called onCreate");
mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID); super.onCreate(savedInstanceState);
if (!mCamera.isOpened()) { getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mCamera.release(); setContentView(R.layout.HelloOpenCvLayout);
mCamera = null; mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.HelloOpenCvView);
Log.e("HelloOpenCVView", "Failed to open native camera"); mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
return false; mOpenCvCameraView.setCvCameraViewListener(this);
} }
}
return true;
}
public void cameraRelease() { @Override
synchronized(this) { public void onPause()
if (mCamera != null) { {
mCamera.release(); super.onPause();
mCamera = null; if (mOpenCvCameraView != null)
} mOpenCvCameraView.disableView();
} }
}
private void cameraSetup(int width, int height) { public void onDestroy() {
synchronized (this) { super.onDestroy();
if (mCamera != null && mCamera.isOpened()) { if (mOpenCvCameraView != null)
List<Size> sizes = mCamera.getSupportedPreviewSizes(); mOpenCvCameraView.disableView();
int mFrameWidth = width; }
int mFrameHeight = height;
{ // selecting optimal camera preview size
double minDiff = Double.MAX_VALUE;
for (Size size : sizes) {
if (Math.abs(size.height - height) < minDiff) {
mFrameWidth = (int) size.width;
mFrameHeight = (int) size.height;
minDiff = Math.abs(size.height - height);
}
}
}
mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
}
}
}
#. The last step would be to update the ``run()`` void in ``HelloOpenCVView`` class as follows: public void onCameraViewStarted(int width, int height) {
}
.. code-block:: java public void onCameraViewStopped() {
:linenos: }
public void run() { public Mat onCameraFrame(Mat inputFrame) {
while (true) { return inputFrame;
Bitmap bmp = null; }
synchronized (this) {
if (mCamera == null)
break;
if (!mCamera.grab())
break;
bmp = processFrame(mCamera); #. Run your application on device or emulator.
}
if (bmp != null) {
Canvas canvas = getHolder().lockCanvas();
if (canvas != null) {
canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2,
(canvas.getHeight() - bmp.getHeight()) / 2, null);
getHolder().unlockCanvasAndPost(canvas);
} Lets discuss some most important steps. Every Android application with UI must implement Activity
bmp.recycle(); and View. By the first steps we create blank activity and default view layout. The simplest
} OpenCV-centric application must implement OpenCV initialization, create its own view to show
} preview from camera and implements ``CvViewFrameListener`` interface to get frames from camera and
} process it.
protected Bitmap processFrame(VideoCapture capture) { First of all we create our application view using xml layout. Our layout consists of the only
Mat mRgba = new Mat(); one full screen component of class ``org.opencv.android.JavaCameraView``. This class is
capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA); implemented inside OpenCV library. It is inherited from ``CameraBridgeViewBase``, that extends
//process mRgba ``SurfaceView`` and uses standard Android camera API. Alternatively you can use
Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888); ``org.opencv.android.NativeCameraView`` class, that implements the same interface, but uses
try { ``VideoCapture`` class as camera access back-end. ``opencv:show_fps="true"`` and
Utils.matToBitmap(mRgba, bmp); ``opencv:camera_id="any"`` options enable FPS message and allow to use any camera on device.
} catch(Exception e) { Application tries to use back camera first.
Log.e("processFrame", "Utils.matToBitmap() throws an exception: " + e.getMessage());
bmp.recycle(); After creating layout we need to implement ``Activity`` class. OpenCV initialization process has
bmp = null; been already discussed above. In this sample we use asynchronous initialization. Implementation of
} ``CvCameraViewListener`` interface allows you to add processing steps after frame grabbing from
return bmp; camera and before its rendering on screen. The most important function is ``onCameraFrame``. It is
} callback function and it is called on retrieving frame from camera. The callback input is frame
from camera. RGBA format is used by default. You can change this behavior by ``SetCaptureFormat``
method of ``View`` class. ``Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA`` and
``Highgui.CV_CAP_ANDROID_GREY_FRAME`` are supported. It expects that function returns RGBA frame
that will be drawn on the screen.

2
doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst
View File

@ -137,7 +137,7 @@ Here you can read tutorials about how to set up your computer to work with the O
================ ================================================= ================ =================================================
|AndroidLogo| **Title:** :ref:`dev_with_OCV_on_Android` |AndroidLogo| **Title:** :ref:`dev_with_OCV_on_Android`
*Compatibility:* > OpenCV 2.4.2 *Compatibility:* > OpenCV 2.4.3
*Author:* |Author_VsevolodG| *Author:* |Author_VsevolodG|