Merged android-experimental branch back to trunk.

3rdparty/CMakeLists.txt

-if(ANDROID)
- configure_file("${CMAKE_SOURCE_DIR}/Android.mk.modules.in" "${CMAKE_CURRENT_BINARY_DIR}/Android.mk")
-endif()
-
 add_subdirectory(lapack)
 add_subdirectory(zlib)
 if(WITH_JASPER AND NOT JASPER_FOUND)

3rdparty/lapack/CMakeLists.txt

@@ -2,9 +2,6 @@
 #  CMake file for opencv_lapack. See root CMakeLists.txt
 #
 # ----------------------------------------------------------------------------
-if(ANDROID)
-define_3rdparty_module(opencv_lapack)
-else()
 
 project(opencv_lapack)
 
@@ -65,5 +62,3 @@ if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
 	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
 endif()
-    
-endif() #android

3rdparty/libjasper/CMakeLists.txt

-if(ANDROID)
-set(android_defs "-DEXCLUDE_MIF_SUPPORT -DEXCLUDE_PNM_SUPPORT -DEXCLUDE_BMP_SUPPORT -DEXCLUDE_RAS_SUPPORT  -DEXCLUDE_JPG_SUPPORT -DEXCLUDE_PGX_SUPPORT")
-define_3rdparty_module(jasper)
-set(android_defs "")
-else(ANDROID)
-
-
 # ----------------------------------------------------------------------------
 #  CMake file for libjasper. See root CMakeLists.txt
 #
@@ -62,5 +55,3 @@ if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
 	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
 endif()
-    
-endif(ANDROID)#!android

3rdparty/libjpeg/CMakeLists.txt

-if(ANDROID)
-define_3rdparty_module(jpeg)
-else()
-#endif()#android
 # ----------------------------------------------------------------------------
 #  CMake file for libjpeg. See root CMakeLists.txt
 #
@@ -52,5 +48,3 @@ if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
 	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
 endif()
-    
-endif()#android

3rdparty/libpng/CMakeLists.txt

-if(ANDROID)
-define_3rdparty_module(png)
-else()
 # ----------------------------------------------------------------------------
 #  CMake file for libpng. See root CMakeLists.txt
 #
@@ -46,5 +43,3 @@ if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
 	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
 endif()
-    
-endif()#android

3rdparty/libtiff/tif_config.h

@@ -20,8 +20,10 @@
 /* Define to 1 if you have the <io.h> header file. */
 #define HAVE_IO_H 1
 
+#if !__ANDROID__
 /* Define to 1 if you have the <search.h> header file. */
 #define HAVE_SEARCH_H 1
+#endif
 
 /* Define to 1 if you have the `setmode' function. */
 #define HAVE_SETMODE 1

3rdparty/zlib/CMakeLists.txt

-if(ANDROID)
-define_3rdparty_module(zlib)
-else()
 # ----------------------------------------------------------------------------
 #  CMake file for zlib. See root CMakeLists.txt
 #
@@ -43,5 +40,3 @@ if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
 	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
 endif()
-
-endif(ANDROID)

CMakeLists.txt

@@ -482,8 +482,10 @@ if(UNIX)
             endif()
         endif()
 
-        if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+        if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD" AND NOT ANDROID)
             set(OPENCV_LINKER_LIBS m pthread)
+        elseif(ANDROID)
+            set(OPENCV_LINKER_LIBS dl m)
         else()
             set(OPENCV_LINKER_LIBS dl m pthread rt)
         endif()
@@ -508,6 +510,18 @@ if(WITH_JASPER AND NOT JASPER_FOUND)
     set(JASPER_LIBRARIES libjasper)
 endif()
 
+if (ANDROID)
+  set(NativeCamera_DIR "${CMAKE_SOURCE_DIR}/android/native-camera/build")
+  FIND_PACKAGE(NativeCamera QUIET)
+  if(NativeCamera_FOUND)
+    set(HAVE_ANDROID_NATIVE_CAMERA TRUE)
+    set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${NativeCamera_LIBS} log)
+  else()
+    set(HAVE_ANDROID_NATIVE_CAMERA FALSE)
+    message("-- Could NOT find NativeCamera for Android")
+  endif()
+endif()
+
 #message(STATUS "Graphic libraries: ${PNG_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES} ${JASPER_LIBRARIES}")
 
 if(WITH_OPENEXR)
@@ -895,7 +909,9 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 
     # We need pthread's
     if(UNIX)
+      if(NOT ANDROID)
         set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -pthread")
+      endif()
     endif()
 
     if(OPENCV_WARNINGS_ARE_ERRORS)
@@ -1083,7 +1099,17 @@ endif()
 set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"${CMAKE_CURRENT_SOURCE_DIR}/include\" \"${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
 set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"${CMAKE_CURRENT_SOURCE_DIR}\"")
 
-set(CMAKE_LIB_DIRS_CONFIGCMAKE "${LIBRARY_OUTPUT_PATH}")
+set(CMAKE_LIB_DIRS_CONFIGCMAKE "${LIBRARY_OUTPUT_PATH}")
+
+if (ANDROID)
+	if (NOT BUILD_SHARED_LIBS)
+	  set(CMAKE_LIB_DIRS_CONFIGCMAKE ${CMAKE_LIB_DIRS_CONFIGCMAKE} "${CMAKE_BINARY_DIR}/lib")
+	endif()
+
+	if( HAVE_ANDROID_NATIVE_CAMERA )
+    	set(CMAKE_LIB_DIRS_CONFIGCMAKE ${CMAKE_LIB_DIRS_CONFIGCMAKE} ${NativeCamera_LIB_DIR})
+	endif()
+endif()
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig.cmake" IMMEDIATE @ONLY)
 
@@ -1367,6 +1393,9 @@ else()
 message(STATUS "    V4L/V4L2:                   ${HAVE_CAMV4L}/${HAVE_CAMV4L2}")
 endif()
 message(STATUS "    Xine:                       ${HAVE_XINE}")
+if(ANDROID)
+message(STATUS "    AndroidNativeCamera:        ${HAVE_ANDROID_NATIVE_CAMERA}")
+endif()
 endif() #if(UNIX AND NOT APPLE)
 
 if(APPLE)

OpenCVConfig.cmake.in

@@ -52,8 +52,14 @@ LINK_DIRECTORIES(${OpenCV_LIB_DIR})
 
 # ====================================================================
 # Link libraries: e.g.   opencv_core220.so, opencv_imgproc220d.lib, etc...
-# ====================================================================
-set(OPENCV_LIB_COMPONENTS opencv_core opencv_imgproc opencv_features2d opencv_gpu opencv_calib3d opencv_objdetect opencv_video opencv_highgui opencv_ml opencv_legacy opencv_contrib opencv_flann)
+# ====================================================================
+if(NOT ANDROID)
+	set(OPENCV_LIB_COMPONENTS opencv_core opencv_imgproc opencv_features2d opencv_gpu opencv_calib3d opencv_objdetect opencv_video opencv_highgui opencv_ml opencv_legacy opencv_contrib opencv_flann)
+else()
+	#libraries order is very important because linker from Android NDK is one-pass linker
+	set(OPENCV_LIB_COMPONENTS opencv_calib3d opencv_objdetect opencv_features2d opencv_imgproc opencv_video  opencv_highgui opencv_ml opencv_legacy  opencv_flann opencv_core )
+endif()
+
 SET(OpenCV_LIBS "")
 foreach(__CVLIB ${OPENCV_LIB_COMPONENTS})
 	# CMake>=2.6 supports the notation "debug XXd optimized XX"
@@ -85,6 +91,9 @@ IF (NOT @OPENCV_BUILD_SHARED_LIB@)
     LINK_DIRECTORIES(@CMAKE_LIB_DIRS_CONFIGCMAKE@/../3rdparty/lib)
     if(WIN32)
         LINK_DIRECTORIES(@CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@/3rdparty/lib)
+    elseif(ANDROID)
+        LINK_DIRECTORIES(@CMAKE_BINARY_DIR@/3rdparty/lib)
+        LINK_DIRECTORIES(@CMAKE_LIB_DIRS_CONFIGCMAKE@/3rdparty/lib)
     else()
         LINK_DIRECTORIES(@CMAKE_LIB_DIRS_CONFIGCMAKE@/../share/opencv/3rdparty/lib)
     endif()    

OpenCVModule.cmake

@@ -29,18 +29,6 @@ macro(define_opencv_module name)
 
     add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs})
 
-    if(PCHSupport_FOUND)
-        set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
-        if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-            if(${CMAKE_GENERATOR} MATCHES "Visual*")
-                set(${the_target}_pch "src/precomp.cpp")
-            endif()            
-            add_native_precompiled_header(${the_target} ${pch_header})
-        elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-            add_precompiled_header(${the_target} ${pch_header})
-        endif()
-    endif()
-
     # For dynamic link numbering convenions
     set_target_properties(${the_target} PROPERTIES
         VERSION ${OPENCV_VERSION}
@@ -56,6 +44,18 @@ macro(define_opencv_module name)
         INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
         )
 
+    if(PCHSupport_FOUND)
+        set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
+        if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
+            if(${CMAKE_GENERATOR} MATCHES "Visual*")
+                set(${the_target}_pch "src/precomp.cpp")
+            endif()            
+            add_native_precompiled_header(${the_target} ${pch_header})
+        elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
+            add_precompiled_header(${the_target} ${pch_header})
+        endif()
+    endif()
+
     # Add the required libraries for linking:
     target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
 

OpenCVPCHSupport.cmake

@@ -34,6 +34,10 @@ ELSE()
 	ENDIF()
 ENDIF(CMAKE_COMPILER_IS_GNUCXX)
 
+#if (ANDROID)
+  #SET(PCHSupport_FOUND FALSE)
+#endif()
+
 
 MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
 

android/Android.mk.in

-LOCAL_PATH := ${CMAKE_CURRENT_SOURCE_DIR}
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := ${android_module_name}
-
-ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
-LOCAL_ARM_NEON := true
-endif
-
-LOCAL_SRC_FILES :=  ${android_srcs}
-
-LOCAL_CFLAGS := ${android_defs}
-
-LOCAL_C_INCLUDES :=  ${include_dirs} $(LOCAL_PATH)
-
-include $(BUILD_STATIC_LIBRARY)

android/Android.mk.master.in

-include android-opencv.mk
-include modules/Android.mk
-include 3rdparty/Android.mk
-#include zlib-android/Android.mk
-

android/Android.mk.modules.in

-include $(call all-subdir-makefiles)
-

android/AndroidCVModule.cmake

-macro(define_android_manual name lib_srcs includes)
-set(android_module_name ${name})
-set(android_srcs "")
-set(include_dirs "${includes}")
-foreach(f ${lib_srcs})
-		string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" n_f ${f})	
-		set(android_srcs "${android_srcs} ${n_f}")
-endforeach()
-configure_file("${CMAKE_SOURCE_DIR}/Android.mk.in" "${CMAKE_CURRENT_BINARY_DIR}/Android.mk")
-endmacro()
-
-
-macro(define_3rdparty_module name)
-	file(GLOB lib_srcs "*.c" "*.cpp")
-	file(GLOB lib_int_hdrs "*.h*")
-	define_android_manual(${name} "${lib_srcs}" "$(LOCAL_PATH)/../include")		
-endmacro()
-
-macro(define_opencv_module name)
-	file(GLOB lib_srcs "src/*.cpp")
-	file(GLOB lib_int_hdrs "src/*.h*")
-	define_android_manual(opencv_${name} "${lib_srcs}" "$(LOCAL_PATH)/src  $(OPENCV_INCLUDES)")
-endmacro()
-
-
-
-
-

android/AndroidManifest.xml.in

-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="com.opencv"
-      android:versionCode="1"
-      android:versionName="1.0">
-   
-</manifest> 
\ No newline at end of file

android/Application.mk.in

-APP_BUILD_SCRIPT := $(call my-dir)/Android.mk
-APP_PROJECT_PATH := $(call my-dir)
-# The ARMv7 is significanly faster due to the use of the hardware FPU
-APP_ABI := ${ARM_TARGETS}
-APP_MODULES      := png jpeg jasper zlib opencv_lapack opencv_core opencv_imgproc opencv_ml opencv_highgui opencv_features2d \
-    opencv_legacy opencv_objdetect opencv_calib3d opencv_video opencv_contrib opencv_flann 

android/CMakeCache.android.initial.cmake

+########################
+# Initial cache settings for opencv on android
+# run cmake with:
+# cmake -C 
+########################
+#Build all examples
+set(BUILD_EXAMPLES OFF CACHE BOOL "" )
+
+#Build Reference Manual
+set(BUILD_REFMAN OFF CACHE BOOL "" )
+
+#Build LaTeX OpenCV Documentation
+#set(BUILD_LATEX_DOCS OFF CACHE BOOL "" )
+
+#Build with Python support
+set(BUILD_NEW_PYTHON_SUPPORT OFF CACHE BOOL "" )
+
+#Build a installer with the SDK
+set(BUILD_PACKAGE OFF CACHE BOOL "" )
+
+#Build shared libraries (.dll/.so CACHE BOOL "" ) instead of static ones (.lib/.a CACHE BOOL "" )
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "" )
+
+#Build 3rd party libraries
+set(OPENCV_BUILD_3RDPARTY_LIBS ON CACHE BOOL "" )
+
+#Build tests
+set(BUILD_TESTS OFF CACHE BOOL "" )
+
+#Choose the type of build, options are: None Debug Release RelWithDebInfo
+# MinSizeRel.
+set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" )
+
+#Include IEEE1394 support
+set(WITH_1394 OFF CACHE BOOL "" )
+
+#Include NVidia Cuda Runtime support
+set(WITH_CUDA OFF CACHE BOOL "" )
+
+#Include Eigen2/Eigen3 support
+set(WITH_EIGEN2 OFF CACHE BOOL "" )
+
+#Include FFMPEG support
+set(WITH_FFMPEG OFF CACHE BOOL "" )
+
+#Include Gstreamer support
+set(WITH_GSTREAMER OFF CACHE BOOL "" )
+
+#Include GTK support
+set(WITH_GTK OFF CACHE BOOL "" )
+
+#Include Intel IPP support
+set(WITH_IPP OFF CACHE BOOL "" )
+
+#Include JPEG2K support
+set(WITH_JASPER ON CACHE BOOL "" )
+
+#Include JPEG support
+set(WITH_JPEG ON CACHE BOOL "" )
+
+#Include ILM support via OpenEXR
+set(WITH_OPENEXR OFF CACHE BOOL "" )
+
+#Include OpenNI support
+set(WITH_OPENNI OFF CACHE BOOL "" )
+
+#Include PNG support
+set(WITH_PNG ON CACHE BOOL "" )
+
+#Include Prosilica GigE support
+set(WITH_PVAPI OFF CACHE BOOL "" )
+
+#Build with Qt Backend support
+set(WITH_QT OFF CACHE BOOL "" )
+
+#Add OpenGL extension to Qt
+set(WITH_QT_OPENGL OFF CACHE BOOL "" )
+
+#Include Intel TBB support
+set(WITH_TBB OFF CACHE BOOL "" )
+
+#Include TIFF support
+set(WITH_TIFF ON CACHE BOOL "" )
+
+#Include Unicap support (GPL CACHE BOOL "" )
+set(WITH_UNICAP OFF CACHE BOOL "" )
+
+#Include Video 4 Linux support
+set(WITH_V4L OFF CACHE BOOL "" )
+
+#Include Xine support (GPL CACHE BOOL "" )
+set(WITH_XINE OFF CACHE BOOL "" )
+
+#Enable SSE instructions
+SET( ENABLE_SSE OFF CACHE BOOL "" )
+
+#Enable SSE2 instructions
+SET( ENABLE_SSE2 OFF CACHE BOOL "" )
+
+#Enable SSE3 instructions
+SET( ENABLE_SSE3 OFF CACHE BOOL "" )
+
+#Enable SSE4.1 instructions
+SET( ENABLE_SSE41 OFF CACHE BOOL "" )
+
+#Enable SSE4.2 instructions
+SET( ENABLE_SSE42 OFF CACHE BOOL "" )
+
+#Enable SSSE3 instructions
+SET( ENABLE_SSSE3 OFF CACHE BOOL "" )

android/CMakeLists.txt

-# ----------------------------------------------------------------------------
-#  Root CMake file for Android Opencv Build
-#
-#    To build with cmake
-#        $ mkdir build
-#        $ cd build
-#        $ cmake ..
-#        $ make
-#    Make sure to set the path in the cache for the crystax ndk available 
-#    here:
-#          http://www.crystax.net/android/ndk-r4.php
-#
-#   - initial version August 2010 Ethan Rublee ethan.ruble@gmail.com
-#
-# ----------------------------------------------------------------------------
-
-project(android-opencv)
-
-cmake_minimum_required(VERSION 2.8)
-
-include(AndroidCVModule.cmake REQUIRED)
-
-set(opencv_root "${CMAKE_SOURCE_DIR}/.." CACHE STRING "opencv source root directory")
-if(NOT EXISTS ${opencv_root})
-message(FATAL_ERROR "Cannot find your opencv root directory!" )
-endif()
-set(ANDROID true)
-set(WITH_JASPER true)
-set(JASPER_FOUND false)
-set(WITH_PNG true)
-set(WITH_JPEG true)
-
-file(GLOB module_includes "${opencv_root}/modules/[a-zA-Z]*")
-
-list(REMOVE_ITEM module_includes ${opencv_root}/modules/CMakeLists.txt)
-
-set(module_includes ${module_includes} ${CMAKE_SOURCE_DIR}/../3rdparty $(OPENCV_BUILD_ROOT) ${opencv_root} )
-foreach(mdir ${module_includes})
-    string(REPLACE "${opencv_root}" "$(OPENCV_ROOT)" n_f ${mdir})	
-    set(android_module_include_dirs "${android_module_include_dirs} ${n_f}/include")
-endforeach()
-
-set(PossibleArmTargets
-  "armeabi armeabi-v7a;armeabi;armeabi-v7a")
-set(ARM_TARGETS "armeabi armeabi-v7a" CACHE STRING "the arm targets for android, recommend armeabi-v7a for floating point support and neon")
-set_property(CACHE ARM_TARGETS PROPERTY STRINGS ${PossibleArmTargets} )
-
-
-
-configure_file("${CMAKE_SOURCE_DIR}/Android.mk.master.in" "${CMAKE_BINARY_DIR}/Android.mk")
-configure_file("${CMAKE_SOURCE_DIR}/Application.mk.in" "${CMAKE_BINARY_DIR}/Application.mk")
-configure_file("${CMAKE_SOURCE_DIR}/AndroidManifest.xml.in" "${CMAKE_BINARY_DIR}/AndroidManifest.xml")
-configure_file("${CMAKE_SOURCE_DIR}/default.properties.in" "${CMAKE_BINARY_DIR}/default.properties")
-configure_file("${CMAKE_SOURCE_DIR}/cvconfig.h.in" "${CMAKE_BINARY_DIR}/include/cvconfig.h")
-
-add_subdirectory(${opencv_root}/modules "${CMAKE_BINARY_DIR}/modules")
-
-add_subdirectory(${opencv_root}/3rdparty "${CMAKE_BINARY_DIR}/3rdparty")
-
-set(NDK_ROOT  "$ENV{HOME}/android-ndk-r4-crystax" CACHE STRING "the crystax ndk directory")
-if(NOT EXISTS ${NDK_ROOT})
-message(FATAL_ERROR "Cannot find your ndk root directory! please download and 
-unzip the android ndk from crystax to the directory specified by NDK_ROOT
-You may download the crystax ndk from: 
-        http://www.crystax.net/android/ndk-r4.php" )
-endif()
-set(J  "2" CACHE STRING "how many processes for make -j <J>")
-
-ADD_CUSTOM_COMMAND(
-OUTPUT    android-opencv
-DEPENDS   ${CMAKE_BINARY_DIR}/Android.mk
-COMMAND   "${NDK_ROOT}/ndk-build" 
-ARGS      --directory=${CMAKE_BINARY_DIR} NDK_APPLICATION_MK=Application.mk -j${J}
-)
-
-configure_file("${CMAKE_SOURCE_DIR}/android-opencv.mk.in" "${CMAKE_BINARY_DIR}/android-opencv.mk")
-
-ADD_CUSTOM_TARGET(ndk ALL echo
-  DEPENDS android-opencv
-)
-
-message(STATUS "Make will use make -j${J} - for speeding up build - you may change this in the cache")
-message(STATUS "The NDK directory is ${NDK_ROOT}")
-message(STATUS "OpenCV source root is ${opencv_root}")
-message(STATUS "just run make - and grab some coffee or tea ;)")
-message(STATUS "The android opencv libs will be located in ${CMAKE_BINARY_DIR}/obj/local/armeabi*/")
-
-
-
-  
-
-
-

android/README.android.txt

 Author: Ethan Rublee
 email: ethan.rublee@gmail.com
+########################################################
+Prerequisites:
+########################################################
+   android-ndk-r5b http://developer.android.com/sdk/ndk/index.html
+      the official ndk with standalone toolchain
+   android-cmake http://code.google.com/p/android-cmake/
+      this is for the cmake toolchain for android
+   mercurial
+    sudo apt-get install mercurial
+   cmake
+   opencv (you should have this if you're reading this file :)
 
-  
-To build with cmake:
+########################################################   
+Quick NDK Setup(ubuntu and bash):
+########################################################
+create some working directory:
+  WORK=$HOME/android_dev
+  cd $WORK
+
+now get the android-cmake project with mercurial
+  hg clone https://android-cmake.googlecode.com/hg/ android-cmake
 
-mkdir build
-cd build
-cmake ..
-make
+there is a convenience script in there for pulling down and setting up the
+android ndk as a standalone toolchain
+  cd android-cmake/scripts
+  ./get_ndk_toolchain_linux.sh $WORK
 
+add the cmake toolchain location to your bashrc or otherwise export it to your env
+  echo export ANDTOOLCHAIN=$WORK/android-cmake/toolchain/android.toolchain.cmake >> $HOME/.bashrc
 
+########################################################
+Quick opencv build(ubuntu and bash):
+########################################################
+Make sure you either source your bashrc or otherwise export the ANDTOOLCHAIN variable.
 
-Make sure to set the path in the cache for the crystax ndk available 
-here:
-   http://www.crystax.net/android/ndk-r4.php
-   
-   
-to include in an android project -
-just include the generated android-opencv.mk in you android ndk project 
-(in an Android.mk file)
-with:
+There is a script in the android folder for running cmake with the proper cache
+variables set.  It is recommended that you use this to setup a smake build directory.
+  cd opencv/android
+  sh ./cmake_android.sh
 
-include android-opencv.mk
+You should now see a build directory, that is ready to be made.
+  cd build
+  make -j8
 
-this defines OPENCV_INCLUDES and OPENCV_LIBS - which you should add to your
-makefiles like:
+That will build most of the opencv modules, except for those that don't make sense
+on android - gpu, etc..
+
+To install to the toolchain:
+  make install
+########################################################
+Using opencv in you're cmake own projects.
+########################################################
+Use the cmake find script for opencv:
+  find_package(OpenCV REQUIRED)
+  
+Then when you run cmake, use:
+  cmake -DCMAKE_TOOLCHAIN_FILE=$ANDTOOLCHAIN ..
 
-#define OPENCV_INCLUDES and OPENCV_LIBS
-include $(PATH_TO_OPENCV_ANDROID_BUILD)/android-opencv.mk
+And direct your cmake cache for OpenCV_Dir to the path that you build opencv for android.
+  something like : opencv/android/build
 
-LOCAL_LDLIBS += $(OPENCV_LIBS)
-    
-LOCAL_C_INCLUDES +=  $(OPENCV_INCLUDES)
+To avoid setting the cmake cache for OpenCV_Dir, you can just "install" opencv to your
+android toolchain. Run the following from the opencv/android/build path:
+  make install
 
-for now, you also need to cd to android-jni and run make
-this will create the android shared library with some useful functionality
-that may be reused in android projects.
+########################################################
+android targets
+########################################################
+You may wish to build android for multiple hardware targets.
 
+Just change the cmake cache ARM_TARGETS to either:
+ "armeabi" "armeab-v7a" "armeab-v7a with NEON"
+ 
+You may install each of these to the toolchain, and they should be linked against
+properly via way of the android-cmake toolchain.

android/android-cmake/CMakeLists.txt

-# ----------------------------------------------------------------------------
-#  Root CMake file for Android Opencv Build
-#
-#    To build with cmake
-#        $ mkdir build
-#        $ cd build
-#        $ cmake ..
-#        $ make
-#    Make sure to set the path in the cache for the crystax ndk available 
-#    here:
-#          http://www.crystax.net/android/ndk-r4.php
-#
-#   - initial version August 2010 Ethan Rublee ethan.rublee@gmail.com
-#
-# ----------------------------------------------------------------------------
-
-project(android-opencv-shared)
-
-cmake_minimum_required(VERSION 2.8)
-
-set(opencv_root "$ENV{HOME}/opencv" CACHE PATH "opencv source root directory")
-if(NOT EXISTS ${opencv_root})
-message(FATAL_ERROR "Cannot find your opencv root directory!" )
-endif()
-
-set(android_opencv_mk "${opencv_root}/android/build/android-opencv.mk" cache FILE "the generated android-opencv.mk file")
-if(NOT EXISTS ${android_opencv_mk})
-message(FATAL_ERROR "please locate the cmake generated android-opencv.mk file, usually in the android/build directory...")
-endif()
-
-set(ANDROID true)
-
-file(GLOB module_includes "${opencv_root}/modules/[a-zA-Z]*")
-
-list(REMOVE_ITEM module_includes ${opencv_root}/modules/CMakeLists.txt)
-
-set(module_includes ${module_includes} ${CMAKE_SOURCE_DIR}/../3rdparty $(OPENCV_BUILD_ROOT) )
-foreach(mdir ${module_includes})
-    string(REPLACE "${opencv_root}" "$(OPENCV_ROOT)" n_f ${mdir})	
-    set(android_module_include_dirs "${android_module_include_dirs} ${n_f}/include")
-endforeach()
-
-configure_file("${CMAKE_SOURCE_DIR}/Android.mk.master.in" "${CMAKE_BINARY_DIR}/Android.mk")
-configure_file("${CMAKE_SOURCE_DIR}/Application.mk.in" "${CMAKE_BINARY_DIR}/Application.mk")
-configure_file("${CMAKE_SOURCE_DIR}/AndroidManifest.xml.in" "${CMAKE_BINARY_DIR}/AndroidManifest.xml")
-configure_file("${CMAKE_SOURCE_DIR}/default.properties.in" "${CMAKE_BINARY_DIR}/default.properties")
-
-set(NDK_ROOT  "$ENV{HOME}/android-ndk-r4-crystax" CACHE STRING "the crystax ndk directory")
-if(NOT EXISTS ${NDK_ROOT})
-message(FATAL_ERROR "Cannot find your ndk root directory! please download and 
-unzip the android ndk from crystax to the directory specified by NDK_ROOT
-You may download the crystax ndk from: 
-        http://www.crystax.net/android/ndk-r4.php" )
-endif()
-
-set(J  "2" CACHE STRING "how many processes for make -j <J>")
-
-ADD_CUSTOM_COMMAND(
-OUTPUT    android-ndk
-DEPENDS   ${CMAKE_BINARY_DIR}/Android.mk
-COMMAND   "${NDK_ROOT}/ndk-build" 
-ARGS      --directory=${CMAKE_BINARY_DIR} NDK_APPLICATION_MK=Application.mk -j${J}
-)
-
-ADD_CUSTOM_COMMAND(
-OUTPUT    android-swig
-DEPENDS   ${SWIG_MAIN}
-COMMAND   "swig" 
-ARGS      --directory=${CMAKE_BINARY_DIR} NDK_APPLICATION_MK=Application.mk -j${J}
-)
-
-
-configure_file("${CMAKE_SOURCE_DIR}/android-opencv.mk.in" "${CMAKE_BINARY_DIR}/android-opencv.mk")
-
-ADD_CUSTOM_TARGET(ndk ALL echo
-  DEPENDS android-ndk
-)
-
-message(STATUS "Make will use make -j${J} - for speeding up build - you may change this in the cache")
-message(STATUS "The NDK directory is ${NDK_ROOT}")
-message(STATUS "OpenCV source root is ${opencv_root}")
-message(STATUS "just run make - and grab some coffee or tea ;)")
-message(STATUS "The android opencv libs will be located in ${CMAKE_BINARY_DIR}/obj/local/armeabi*/")
-
-
-
-  
-
-
-

android/android-jni/AndroidManifest.xml

-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.opencv" android:versionCode="1"
-	android:versionName="0.1">
-	
-	 <application android:debuggable="true">
-        <!-- The activity tag here is currently not used. The main project TicTacToeMain
-             must currently redefine the activities to be used from the libraries.
-             However later the tools will pick up the activities from here and merge them
-             automatically, so it's best to define your activities here like for any
-             regular Android project.
-        -->
-        <activity android:name="com.opencv.OpenCV" />
-        <activity android:name="com.opencv.calibration.ChessBoardChooser"/>
-		<activity android:name="com.opencv.calibration.CameraConfig"/>
-		<activity android:name="com.opencv.calibration.CalibrationViewer"/>
-        <service android:name="com.opencv.calibration.services.CalibrationService"/>
-    </application>
-    <!-- set the opengl version 
-    <uses-feature android:glEsVersion="0x00020000" />-->
-	<uses-sdk android:minSdkVersion="7" />
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-	
-</manifest> 

android/android-jni/Makefile

-# The path to the NDK, requires crystax version r-4 for now, due to support
-# for the standard library
-
-# load environment from local make file
-LOCAL_ENV_MK=local.env.mk
-ifneq "$(wildcard $(LOCAL_ENV_MK))" ""
-include $(LOCAL_ENV_MK)
-else
-$(shell cp sample.$(LOCAL_ENV_MK) $(LOCAL_ENV_MK))
-$(info ERROR local environement not setup! try:)
-$(info gedit $(LOCAL_ENV_MK))
-$(error Please setup the $(LOCAL_ENV_MK) - the default was just created')
-endif
-
-ifndef ARM_TARGETS
-ARM_TARGETS="armeabi armeabi-v7a"
-endif
-
-ANDROID_NDK_BASE = $(ANDROID_NDK_ROOT)
-
-$(info OPENCV_CONFIG = $(OPENCV_CONFIG))
-
-# The name of the native library
-LIBNAME = libandroid-opencv.so
-
-# Find all the C++ sources in the native folder
-SOURCES = $(wildcard jni/*.cpp)
-HEADERS = $(wildcard jni/*.h)
-SWIG_IS = $(wildcard jni/*.i)
-
-ANDROID_MKS = $(wildcard jni/*.mk)
-
-SWIG_MAIN = jni/android-cv.i
-
-SWIG_JAVA_DIR = src/com/opencv/jni
-SWIG_JAVA_OUT = $(wildcard $(SWIG_JAVA_DIR)/*.java)
-
-SWIG_C_DIR = jni/gen
-SWIG_C_OUT = $(SWIG_C_DIR)/android_cv_wrap.cpp
-
-# The real native library stripped of symbols
-LIB		= libs/armeabi-v7a/$(LIBNAME) libs/armeabi/$(LIBNAME)
-
-
-all:	$(LIB) nogdb
-
-
-#calls the ndk-build script, passing it OPENCV_ROOT and OPENCV_LIBS_DIR
-$(LIB): $(SWIG_C_OUT) $(SOURCES) $(HEADERS) $(ANDROID_MKS)
-	$(ANDROID_NDK_BASE)/ndk-build OPENCV_CONFIG=$(OPENCV_CONFIG) \
-	PROJECT_PATH=$(PROJECT_PATH) ARM_TARGETS=$(ARM_TARGETS) V=$(V) $(NDK_FLAGS)
-
-
-#this creates the swig wrappers
-$(SWIG_C_OUT): $(SWIG_IS)
-	make clean-swig &&\
-	mkdir -p $(SWIG_C_DIR) &&\
-	mkdir -p $(SWIG_JAVA_DIR) &&\
-	swig -java -c++ -package "com.opencv.jni" \
-	-outdir $(SWIG_JAVA_DIR) \
-	-o $(SWIG_C_OUT) $(SWIG_MAIN)
-	
-	
-#clean targets
-.PHONY: clean  clean-swig cleanall nogdb
-
-nogdb: $(LIB)
-	rm -f libs/armeabi*/gdb*
-
-#this deletes the generated swig java and the generated c wrapper
-clean-swig:
-	rm -f $(SWIG_JAVA_OUT) $(SWIG_C_OUT)
-	
-#does clean-swig and then uses the ndk-build clean
-clean: clean-swig
-	$(ANDROID_NDK_BASE)/ndk-build OPENCV_CONFIG=$(OPENCV_CONFIG) \
-	PROJECT_PATH=$(PROJECT_PATH) clean  ARM_TARGETS=$(ARM_TARGETS) V=$(V) $(NDK_FLAGS)
-	

android/android-jni/README.txt

-android-jni
-
-this is an example of an android library project that has some reusable
-code that exposes part of OpenCV to android. In particular this provides a
-native camera interface for loading live video frames from the android camera
-into native opencv functions(as cv::Mat's)
-
-pre-reqs:
-* build the opencv/android libraries - up one directory
-* you need swig in you path for android-jni
-    on ubuntu - sudo apt-get install swig
-    others: http://www.swig.org/
-   
-to build:
-
-make
-
-that should work...  If it doesn't make sure to edit the generated local.env.mk
-to reflect your machine's setup
-
-see the sample for how to use this in your own projects
-
-If you only support armeabi-v7a or armeabi your final apks will be much smaller.
-
-To build the class files, either start a new Android project from existing sources
-in eclipse
-or from the commmand line:
-sh project_create.sh
-ant debug
-
-This should be linked to in your android projects, if you would like to reuse the
-code. See Calibration or CVCamera in the opencv/android/apps directory
-
-With cdt installed in eclipse, you may also "convert to C++ project" once you have
-opened this as an android project. Select makefile project->toolchain other to do this.
-
-Eclipse tip of the day:
-You may get build warnings when linking to the project, complainging about duplicate something
-or other in you .svn directories.  Right click project->settings->java build path->source->excude paths->add
-.svn/ and **/.svn/ should do it ;)
-    

android/android-jni/jni/Android.mk

-# date: Summer, 2010 
-# author: Ethan Rublee
-# contact: ethan.rublee@gmail.com
-#
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-#define OPENCV_INCLUDES and OPENCV_LIBS
-include $(OPENCV_CONFIG)
-
-LOCAL_LDLIBS += $(OPENCV_LIBS) -llog -lGLESv2
-    
-LOCAL_C_INCLUDES +=  $(OPENCV_INCLUDES) 
-
-LOCAL_MODULE    := android-opencv
-
-LOCAL_SRC_FILES := gen/android_cv_wrap.cpp image_pool.cpp \
-    gl_code.cpp Calibration.cpp
-    
-
-#ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
-#    LOCAL_CFLAGS := -DHAVE_NEON=1
-#    LOCAL_SRC_FILES += yuv2rgb_neon.c.neon
-#else
-	LOCAL_SRC_FILES +=  yuv420sp2rgb.c
-#endif
-    
-
-include $(BUILD_SHARED_LIBRARY)
-

android/android-jni/jni/Application.mk

-APP_ABI := $(ARM_TARGETS)
-APP_MODULES      := android-opencv

android/android-jni/jni/yuv420sp2rgb.c

-#include <string.h>
-#include <jni.h>
-
-#include <yuv420sp2rgb.h>
-
-/*
- YUV 4:2:0 image with a plane of 8 bit Y samples followed by an interleaved
- U/V plane containing 8 bit 2x2 subsampled chroma samples.
- except the interleave order of U and V is reversed.
-
- H V
- Y Sample Period      1 1
- U (Cb) Sample Period 2 2
- V (Cr) Sample Period 2 2
- */
-
-/*
- size of a char:
- find . -name limits.h -exec grep CHAR_BIT {} \;
- */
-
-#ifndef max
-#define max(a,b) ({typeof(a) _a = (a); typeof(b) _b = (b); _a > _b ? _a : _b; })
-#define min(a,b) ({typeof(a) _a = (a); typeof(b) _b = (b); _a < _b ? _a : _b; })
-#endif
-
-const int bytes_per_pixel = 2;
-void color_convert_common(const unsigned char *pY, const unsigned char *pUV, int width, int height, unsigned char *buffer, int grey)
-{
-
-  int i, j;
-  int nR, nG, nB;
-  int nY, nU, nV;
-  unsigned char *out = buffer;
-  int offset = 0;
-
-  if (grey)
-  {
-    memcpy(out,pY,width*height*sizeof(unsigned char));
-  }
-  else
-    // YUV 4:2:0
-    for (i = 0; i < height; i++)
-    {
-      for (j = 0; j < width; j++)
-      {
-        nY = *(pY + i * width + j);
-        nV = *(pUV + (i / 2) * width + bytes_per_pixel * (j / 2));
-        nU = *(pUV + (i / 2) * width + bytes_per_pixel * (j / 2) + 1);
-
-        // Yuv Convert
-        nY -= 16;
-        nU -= 128;
-        nV -= 128;
-
-        if (nY < 0)
-          nY = 0;
-
-        nB = (int)(1192 * nY + 2066 * nU);
-        nG = (int)(1192 * nY - 833 * nV - 400 * nU);
-        nR = (int)(1192 * nY + 1634 * nV);
-
-        nR = min(262143, max(0, nR));
-        nG = min(262143, max(0, nG));
-        nB = min(262143, max(0, nB));
-
-        nR >>= 10;
-        nR &= 0xff;
-        nG >>= 10;
-        nG &= 0xff;
-        nB >>= 10;
-        nB &= 0xff;
-
-        out[offset++] = (unsigned char)nR;
-        out[offset++] = (unsigned char)nG;
-        out[offset++] = (unsigned char)nB;
-      }
-    }
-
-}

android/android-jni/sample.local.env.mk

-#location of android-opencv.mk file that was generated by the cmake build
-#of opencv for android
-OPENCV_CONFIG=../build/android-opencv.mk
-
-#the root directory of the crystax r4 ndk - ndk-build should be in this dir
-#you can download the ndk from http://www.crystax.net/android/ndk-r4.php
-ANDROID_NDK_ROOT=$(HOME)/android-ndk-r4-crystax
-
-#define only armeabi-v7a to make the final apk smaller or armeabi
-ARM_TARGETS="armeabi armeabi-v7a"
\ No newline at end of file

android/android-opencv.mk.in

-#you may override this if you move the build
-#just define it before including this or on the command line - or with
-#an environment variable
-#this points to the root of the opencv trunk - where the original opencv 
-#sources are - with modules 3rparty ...
-ifndef OPENCV_ROOT
-OPENCV_ROOT := ${opencv_root}
-endif
-
-#you may override this same as above
-#this points to the actually directory that you built opencv for android from
-#maybe in under opencv/android/build
-ifndef OPENCV_BUILD_ROOT
-OPENCV_BUILD_ROOT := ${CMAKE_BINARY_DIR}
-endif
-
-OPENCV_INCLUDES := ${android_module_include_dirs}
-
-ANDROID_OPENCV_INCLUDES := $(OPENCV_ROOT)/android/android-jni/jni
-
-ARMOBJS := local/armeabi
-ARMOBJS_V7A := local/armeabi-v7a
-
-OPENCV_LIB_DIRS := -L$(OPENCV_BUILD_ROOT)/obj/$(ARMOBJS_V7A) \
-    -L$(OPENCV_BUILD_ROOT)/obj/$(ARMOBJS) -L$(OPENCV_BUILD_ROOT)/bin/ndk/$(ARMOBJS) \
-    -L$(OPENCV_BUILD_ROOT)/bin/ndk/$(ARMOBJS_V7A)
-
-ANDROID_OPENCV_LIB_DIRS := -L$(OPENCV_ROOT)/android/android-jni/libs/armeabi-v7a \
-    -L$(OPENCV_ROOT)/android/android-jni/libs/armeabi
-
-#order of linking very important ---- may have stuff out of order here, but
-#important that modules that are more dependent come first...
-
-OPENCV_LIBS := $(OPENCV_LIB_DIRS) -lopencv_calib3d -lopencv_features2d -lopencv_objdetect -lopencv_imgproc \
-     -lopencv_video  -lopencv_highgui -lopencv_ml -lopencv_legacy -lopencv_core -lopencv_lapack -lopencv_flann \
-    -lzlib -lpng -ljpeg -ljasper
-ANDROID_OPENCV_LIBS := -landroid-opencv $(ANDROID_OPENCV_LIB_DIRS)
-    

android/android-opencv/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+	package="com.opencv" android:versionCode="1" android:versionName="0.1">
+
+	<application android:debuggable="true">
+		<!-- The activity tag here is currently not used. The main project TicTacToeMain 
+			must currently redefine the activities to be used from the libraries. However 
+			later the tools will pick up the activities from here and merge them automatically, 
+			so it's best to define your activities here like for any regular Android 
+			project. -->
+		<activity android:name="com.opencv.OpenCV">
+			<intent-filter>
+				<action android:name="android.intent.action.MAIN" />
+				<category android:name="android.intent.category.LAUNCHER" />
+			</intent-filter>
+		</activity>
+		<activity android:name="com.opencv.calibration.ChessBoardChooser" />
+		<activity android:name="com.opencv.calibration.CameraConfig" />
+		<activity android:name="com.opencv.calibration.CalibrationViewer" />
+		<service android:name="com.opencv.calibration.services.CalibrationService" />
+	</application>
+	<uses-sdk android:minSdkVersion="7" />
+
+	<!-- set the opengl version -->
+	<uses-feature android:glEsVersion="0x00020000" />
+	<!-- set the opengl version -->
+	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
+
+</manifest> 

android/android-opencv/AndroidOpenCVConfig.cmake.in

+# ============================================================================
+#  The AndroidOpenCV CMake configuration file
+#
+#             ** File generated automatically, do not modify **
+#
+#  Usage from an external project:
+#    In your CMakeLists.txt, add these lines:
+#
+#    FIND_PACKAGE(AndroidOpenCV REQUIRED )
+#    TARGET_LINK_LIBRARIES(MY_TARGET_NAME ${AndroidOpenCV_LIBS})
+#
+#    This file will define the following variables:
+#      - AndroidOpenCV_LIBS      : The list of libraries to links against.
+#      - AndroidOpenCV_LIB_DIR   : The directory where lib files are. 
+#                                  Calling LINK_DIRECTORIES with this path
+#                                  is NOT needed.
+#      - AndroidOpenCV_INCLUDE_DIRS   : The AndroidOpenCV include directories.
+#      - AndroidOpenCV_SWIG_DIR : The swig path
+#
+# ===========================================================================
+
+
+# ======================================================
+# Include directories to add to the user project:
+# ======================================================
+
+# Provide the include directories to the caller
+SET(AndroidOpenCV_INCLUDE_DIRS @CMAKE_INCLUDE_DIRS_CONFIGCMAKE@)
+INCLUDE_DIRECTORIES(${AndroidOpenCV_INCLUDE_DIRS})
+
+# ======================================================
+# Link directories to add to the user project:
+# ======================================================
+
+# Provide the libs directory anyway, it may be needed in some cases.
+SET(AndroidOpenCV_LIB_DIR @CMAKE_LIB_DIRS_CONFIGCMAKE@)
+LINK_DIRECTORIES(${AndroidOpenCV_LIB_DIR})
+
+# ======================================================
+# Libraries to add to the user project:
+# ======================================================
+SET(AndroidOpenCV_LIBS @CMAKE_LIBS_CONFIGCMAKE@)
+
+SET(AndroidOpenCV_SWIG_DIR @CMAKE_SWIG_DIR_CONFIGCMAKE@)

android/android-opencv/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+project(android-jni)
+
+add_subdirectory(jni)

android/android-opencv/README.txt

+=========================================
+CMake Build
+=========================================
+mkdir build
+cd build
+cmake -DCMAKE_TOOLCHAIN_FILE=$ANDTOOLCHAIN ..
+
+=========================================
+Android Build
+=========================================
+sh project_create.sh
+ant compile
+ant install

android/android-jni/default.properties → android/android-opencv/default.properties

@@ -7,6 +7,7 @@
 # "build.properties", and override values to adapt the script to your
 # project structure.
 
-android.library=true
+#android.library=true
 # Project target.
 target=android-7
+android.library=true

android/android-opencv/jni/CMakeLists.txt

+#########################################################
+# Find opencv and android-opencv
+#########################################################
+
+set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../build 
+    CACHE PATH "The path where you built opencv for android")
+find_package(OpenCV REQUIRED)
+
+#########################################################
+#c flags, included, and lib dependencies
+#########################################################
+#notice the "recycling" of CMAKE_C_FLAGS
+#this is necessary to pick up android flags
+set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR} 
+                    ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+set( LIBRARY_DEPS ${OpenCV_LIBS} )
+if(ANDROID)
+  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl GLESv2)
+endif(ANDROID)
+
+#########################################################
+#SWIG STUFF
+#########################################################
+#the java package to place swig generated java files in
+set(MY_PACKAGE com.opencv.jni)
+
+if(NOT ANDROID)
+  #non android swig and jni
+  #jni is available by default on android
+  find_package(JNI REQUIRED)
+  include_directories(${JNI_INCLUDE_DIRS})
+  FIND_PACKAGE(SWIG)
+endif()
+
+INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
+
+if(ANDROID)
+  #this will set the output path for the java package
+  #and properly create the package declarations in generated java sources
+  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
+endif(ANDROID)
+
+SET_SOURCE_FILES_PROPERTIES(android-cv.i PROPERTIES CPLUSPLUS ON)
+
+SWIG_ADD_MODULE(android-opencv java 
+  android-cv.i
+  Calibration.cpp
+  gl_code.cpp
+  image_pool.cpp
+  yuv420sp2rgb.c
+  #yuv420rgb888c.c
+  #yuv420rgb888.s
+  yuv2rgb16tab.c
+  )
+  
+target_link_libraries(android-opencv ${LIBRARY_DEPS} )
+
+###################################################################
+# Setup the configure file for other's to link against.
+###################################################################
+set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+set(CMAKE_LIB_DIRS_CONFIGCMAKE ${LIBRARY_OUTPUT_PATH})
+set(CMAKE_LIBS_CONFIGCMAKE android-opencv)
+set(CMAKE_SWIG_DIR_CONFIGCMAKE ${CMAKE_CURRENT_SOURCE_DIR})
+configure_file( "${CMAKE_SOURCE_DIR}/AndroidOpenCVConfig.cmake.in"
+                "${CMAKE_BINARY_DIR}/AndroidOpenCVConfig.cmake"
+                IMMEDIATE @ONLY)

android/android-jni/jni/android-cv.i → android/android-opencv/jni/android-cv.i

@@ -8,7 +8,6 @@ before loading any lib that depends on this.
 %{
 #include "image_pool.h"
 #include "glcamera.h"
-
 using namespace cv;
 %}
 #ifndef SWIGIMPORTED

android/android-jni/jni/buffers.i → android/android-opencv/jni/buffers.i

@@ -51,7 +51,7 @@
     return $jnicall;
 }
 %typemap(in) CTYPE* LABEL {
-  $1 = (*jenv)->GetDirectBufferAddress(jenv, $input);
+  $1 = (CTYPE*)(jenv)->GetDirectBufferAddress( $input);
   if ($1 == NULL) {
     SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
   }
@@ -92,7 +92,7 @@ NIO_BUFFER_TYPEMAP(double, BUFF, java.nio.DoubleBuffer);
     return $jnicall;
 }
 %typemap(in) CTYPE* INBUFF {
-  $1 = (*jenv)->GetDirectBufferAddress(jenv, $input);
+  $1 = (jenv)->GetDirectBufferAddress($input);
   if ($1 == NULL) {
     SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
   }
@@ -116,7 +116,7 @@ NIO_BUFFER_TYPEMAP(double, BUFF, java.nio.DoubleBuffer);
     return $jnicall;
 }
 %typemap(in) CTYPE* OUTBUFF {
-  $1 = (*jenv)->GetDirectBufferAddress(jenv, $input);
+  $1 = (jenv)->GetDirectBufferAddress( $input);
   if ($1 == NULL) {
     SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
   }
@@ -147,7 +147,7 @@ UNSIGNED_NIO_BUFFER_TYPEMAP(unsigned long, 4, java.nio.LongBuffer, permafrost.hd
     return $jnicall;
 }
 %typemap(in) unsigned char* BUFF {
-  $1 = (*jenv)->GetDirectBufferAddress(jenv, $input);
+  $1 = (const char*)(jenv)->GetDirectBufferAddress( $input);
   if ($1 == NULL) {
     SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
   }

android/android-jni/jni/cv.i → android/android-opencv/jni/cv.i

@@ -6,19 +6,105 @@
 /** Wrapper for the OpenCV Size object. Good for setting dimensions of cv::Mat...
 */"
 
-class Mat {
-public:
- %immutable;
-	int rows;
-	int cols;
-};
 
 class Size{
 public:
+	Size();
 	Size(int width,int height);
+	~Size();
 	int width;
-	int height;
-	
+	int height;	
+};
+
+#define CV_CN_MAX     512
+#define CV_CN_SHIFT   3
+#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)
+
+#define CV_8U   0
+#define CV_8S   1
+#define CV_16U  2
+#define CV_16S  3
+#define CV_32S  4
+#define CV_32F  5
+#define CV_64F  6
+#define CV_USRTYPE1 7
+
+#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
+#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
+
+#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
+#define CV_MAKE_TYPE CV_MAKETYPE
+
+#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
+#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
+#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
+#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
+#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
+
+#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
+#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
+#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
+#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
+#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
+
+#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
+#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
+#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
+#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
+#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
+
+#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
+#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
+#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
+#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
+#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
+
+#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
+#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
+#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
+#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
+#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
+
+#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
+#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
+#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
+#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
+#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
+
+#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
+#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
+#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
+#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
+#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
+
+#define CV_AUTO_STEP  0x7fffffff
+#define CV_WHOLE_ARR  cvSlice( 0, 0x3fffffff )
+
+#define CV_MAT_CN_MASK          ((CV_CN_MAX - 1) << CV_CN_SHIFT)
+#define CV_MAT_CN(flags)        ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
+#define CV_MAT_TYPE_MASK        (CV_DEPTH_MAX*CV_CN_MAX - 1)
+#define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)
+#define CV_MAT_CONT_FLAG_SHIFT  14
+#define CV_MAT_CONT_FLAG        (1 << CV_MAT_CONT_FLAG_SHIFT)
+#define CV_IS_MAT_CONT(flags)   ((flags) & CV_MAT_CONT_FLAG)
+#define CV_IS_CONT_MAT          CV_IS_MAT_CONT
+#define CV_SUBMAT_FLAG_SHIFT    15
+#define CV_SUBMAT_FLAG          (1 << CV_SUBMAT_FLAG_SHIFT)
+#define CV_IS_SUBMAT(flags)     ((flags) & CV_MAT_SUBMAT_FLAG)
+
+#define CV_MAGIC_MASK       0xFFFF0000
+#define CV_MAT_MAGIC_VAL    0x42420000
+#define CV_TYPE_NAME_MAT    "opencv-matrix"
+
+class Mat {
+public:
+	Mat();
+	~Mat();
+	void create(Size size, int type);
+	int channels() const;
+ %immutable;
+	int rows;
+	int cols;
 };
 
 template<class _Tp> class Ptr
@@ -56,4 +142,15 @@ protected:
     int* refcount; //< the associated reference counter
 };
 
-%template(PtrMat) Ptr<Mat>;
+
\ No newline at end of file
+
+%template(PtrMat) Ptr<Mat>;
+
+void imwrite(const char* image_name, const Mat& image);
+Mat imread(const char* image_name);
+
+ %include "buffers.i" 
+ %apply char* BUFF {const char* buffer}
+ %apply char* BUFF {char* buffer}
+void copyMatToBuffer(char* buffer, const Mat& mat);
+void copyBufferToMat(Mat& mat, const char* buffer);
\ No newline at end of file

android/android-jni/jni/gl_code.cpp → android/android-opencv/jni/gl_code.cpp

@@ -17,14 +17,18 @@
 // OpenGL ES 2.0 code
 
 #include <jni.h>
+#if __ANDROID__
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include "android_logger.h"
 
-#include <android/log.h>
 #include <opencv2/core/core.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -33,9 +37,6 @@
 #include "glcamera.h"
 #include "image_pool.h"
 using namespace cv;
-#define  LOG_TAG    "libandroid-opencv"
-#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
-#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
 
 static void printGLString(const char *name, GLenum s)
 {
@@ -68,18 +69,12 @@ static const char gFragmentShader[] = "precision mediump float;
   "  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
   "}                                                   \n";
 
-const GLfloat gTriangleVertices[] = {0.0f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f};
-GLubyte testpixels[4 * 3] = {255, 0, 0, // Red
-                             0, 255, 0, // Green
-                             0, 0, 255, // Blue
-                             255, 255, 0 // Yellow
-    };
 
 GLuint glcamera::createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int width, int height, int channels)
 {
 
   // Bind the texture
-  glActiveTexture( GL_TEXTURE0);
+  glActiveTexture(GL_TEXTURE0);
   checkGlError("glActiveTexture");
   // Bind the texture object
   glBindTexture(GL_TEXTURE_2D, _textureid);
@@ -89,7 +84,11 @@ GLuint glcamera::createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int w
   switch (channels)
   {
     case 3:
+#if ANDROID
       format = GL_RGB;
+#else
+      format = GL_BGR;
+#endif
       break;
     case 1:
       format = GL_LUMINANCE;
@@ -102,9 +101,15 @@ GLuint glcamera::createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int w
   glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, pixels);
 
   checkGlError("glTexImage2D");
+#if ANDROID
   // Set the filtering mode
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+#else
+  /* Linear Filtering */
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+#endif
 
   return _textureid;
 
@@ -112,7 +117,9 @@ GLuint glcamera::createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int w
 
 GLuint glcamera::loadShader(GLenum shaderType, const char* pSource)
 {
-  GLuint shader = glCreateShader(shaderType);
+  GLuint shader = 0;
+#if __ANDROID__
+  shader = glCreateShader(shaderType);
   if (shader)
   {
     glShaderSource(shader, 1, &pSource, NULL);
@@ -138,11 +145,13 @@ GLuint glcamera::loadShader(GLenum shaderType, const char* pSource)
       }
     }
   }
+#endif
   return shader;
 }
 
 GLuint glcamera::createProgram(const char* pVertexSource, const char* pFragmentSource)
 {
+#if __ANDROID__
   GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
   if (!vertexShader)
   {
@@ -184,27 +193,32 @@ GLuint glcamera::createProgram(const char* pVertexSource, const char* pFragmentS
     }
   }
   return program;
+#else
+  return 0;
+#endif
+}
+void  glcamera::clear(){
+  nimg = Mat();
 }
-
 //GLuint textureID;
 
 bool glcamera::setupGraphics(int w, int h)
 {
-  printGLString("Version", GL_VERSION);
-  printGLString("Vendor", GL_VENDOR);
-  printGLString("Renderer", GL_RENDERER);
-  printGLString("Extensions", GL_EXTENSIONS);
+//  printGLString("Version", GL_VERSION);
+//  printGLString("Vendor", GL_VENDOR);
+//  printGLString("Renderer", GL_RENDERER);
+//  printGLString("Extensions", GL_EXTENSIONS);
 
-  LOGI("setupGraphics(%d, %d)", w, h);
+#if __ANDROID__
   gProgram = createProgram(gVertexShader, gFragmentShader);
   if (!gProgram)
   {
     LOGE("Could not create program.");
     return false;
   }
+
   gvPositionHandle = glGetAttribLocation(gProgram, "a_position");
   gvTexCoordHandle = glGetAttribLocation(gProgram, "a_texCoord");
-
   gvSamplerHandle = glGetAttribLocation(gProgram, "s_texture");
 
   // Use tightly packed data
@@ -212,28 +226,24 @@ bool glcamera::setupGraphics(int w, int h)
 
   // Generate a texture object
   glGenTextures(1, &textureID);
-  textureID = createSimpleTexture2D(textureID, testpixels, 2, 2, 3);
-
-  checkGlError("glGetAttribLocation");
-  LOGI("glGetAttribLocation(\"vPosition\") = %d\n",
-      gvPositionHandle);
 
   glViewport(0, 0, w, h);
-  checkGlError("glViewport");
+#endif
   return true;
 }
 
 void glcamera::renderFrame()
 {
 
+#if __ANDROID__
   GLfloat vVertices[] = {-1.0f, 1.0f, 0.0f, // Position 0
                          0.0f, 0.0f, // TexCoord 0
                          -1.0f, -1.0f, 0.0f, // Position 1
-                         0.0f, 1.0f, // TexCoord 1
+                         0.0f, img_h, // TexCoord 1
                          1.0f, -1.0f, 0.0f, // Position 2
-                         1.0f, 1.0f, // TexCoord 2
+                         img_w, img_h, // TexCoord 2
                          1.0f, 1.0f, 0.0f, // Position 3
-                         1.0f, 0.0f // TexCoord 3
+                         img_w, 0.0f // TexCoord 3
       };
   GLushort indices[] = {0, 1, 2, 0, 2, 3};
   GLsizei stride = 5 * sizeof(GLfloat); // 3 for position, 2 for texture
@@ -244,6 +254,8 @@ void glcamera::renderFrame()
   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
   checkGlError("glClear");
 
+  if(nimg.empty())return;
+
   glUseProgram(gProgram);
   checkGlError("glUseProgram");
 
@@ -256,14 +268,14 @@ void glcamera::renderFrame()
   glEnableVertexAttribArray(gvTexCoordHandle);
 
   // Bind the texture
-  glActiveTexture( GL_TEXTURE0);
+  glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, textureID);
 
   // Set the sampler texture unit to 0
   glUniform1i(gvSamplerHandle, 0);
 
   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
-
+#endif
   //checkGlError("glVertexAttribPointer");
   //glEnableVertexAttribArray(gvPositionHandle);
   //checkGlError("glEnableVertexAttribArray");
@@ -284,17 +296,35 @@ void glcamera::step()
   if (newimage && !nimg.empty())
   {
 
-    textureID = createSimpleTexture2D(textureID, nimg.ptr<unsigned char> (0), nimg.rows, nimg.cols, nimg.channels());
+    textureID = createSimpleTexture2D(textureID, nimg.ptr<unsigned char> (0), nimg.cols, nimg.rows, nimg.channels());
     newimage = false;
   }
   renderFrame();
 
 }
-#define NEAREST_POW2(x)((int)(0.5 + std::log(x)/0.69315) )
+#define NEAREST_POW2(x)( std::ceil(std::log(x)/0.69315) )
 void glcamera::setTextureImage(const Mat& img)
 {
+  int p = NEAREST_POW2(img.cols/2); //subsample by 2
+  //int sz = std::pow(2, p);
+
+  // Size size(sz, sz);
   Size size(256, 256);
-  resize(img, nimg, size, cv::INTER_NEAREST);
+  img_w = 1;
+  img_h = 1;
+  if (nimg.cols != size.width)
+    LOGI_STREAM( "using texture of size: (" << size.width << " , " << size.height << ") image size is: (" << img.cols << " , " << img.rows << ")");
+  nimg.create(size, img.type());
+#if SUBREGION_NPO2
+  cv::Rect roi(0, 0, img.cols/2, img.rows/2);
+  cv::Mat nimg_sub = nimg(roi);
+  //img.copyTo(nimg_sub);
+  img_w = (img.cols/2)/float(sz);
+  img_h = (img.rows/2)/float(sz);
+  cv::resize(img,nimg_sub,nimg_sub.size(),0,0,CV_INTER_NN);
+#else
+  cv::resize(img, nimg, nimg.size(), 0, 0, CV_INTER_NN);
+#endif
   newimage = true;
 }
 

android/android-jni/jni/glcamera.i → android/android-opencv/jni/glcamera.i

@@ -39,5 +39,6 @@ public:
      void init(int width, int height);
      void step();
      void drawMatToGL(int idx, image_pool* pool);
+     void clear();
 };
 

android/android-jni/jni/image_pool.cpp → android/android-opencv/jni/image_pool.cpp

@@ -2,14 +2,31 @@
 
 #include "yuv420sp2rgb.h"
 
-#include <android/log.h>
+#include "android_logger.h"
+
 #include <opencv2/imgproc/imgproc.hpp>
+
+#include <cstdlib>
 #include <jni.h>
-using namespace cv;
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved);
+//
+//JNIEXPORT jobject JNICALL Java_com_opencv_jni_opencvJNI_getBitmapBuffer(
+//		JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_);
 
-#define  LOG_TAG    "libandroid-opencv"
-#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
-#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
+
+JNIEXPORT void JNICALL Java_com_opencv_jni_opencvJNI_addYUVtoPool(JNIEnv *, jclass, jlong, jobject, jbyteArray, jint,
+    jint, jint, jboolean);
+
+#ifdef __cplusplus
+}
+#endif
+
+using namespace cv;
 
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
 {
@@ -19,49 +36,36 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
 }
 
 JNIEXPORT void JNICALL Java_com_opencv_jni_opencvJNI_addYUVtoPool(JNIEnv * env, jclass thiz, jlong ppool,
-                                                                  jobject _jpool, jbyteArray jbuffer, jint jidx,
-                                                                  jint jwidth, jint jheight, jboolean jgrey)
+    jobject _jpool, jbyteArray jbuffer, jint jidx,
+    jint jwidth, jint jheight, jboolean jgrey)
 {
   int buff_height = jheight + (jheight / 2);
   Size buff_size(jwidth, buff_height);
   image_pool *pool = (image_pool *)ppool;
 
   Mat mat = pool->getYUV(jidx);
-
-  if (mat.empty() || mat.size() != buff_size)
+  //create is smart and only copies if the buffer size is different
+  mat.create(buff_size, CV_8UC1);
   {
-    mat.create(buff_size, CV_8UC1);
+    uchar* buff = mat.ptr<uchar> (0);
+    jsize sz = env->GetArrayLength(jbuffer);
+    //http://elliotth.blogspot.com/2007/03/optimizing-jni-array-access.html
+    env->GetByteArrayRegion(jbuffer, 0, sz, (jbyte*)buff);
   }
-
-  jsize sz = env->GetArrayLength(jbuffer);
-  uchar* buff = mat.ptr<uchar> (0);
-
-  env->GetByteArrayRegion(jbuffer, 0, sz, (jbyte*)buff);
-
   pool->addYUVMat(jidx, mat);
 
-  Mat color = pool->getImage(jidx);
-
-  if (!jgrey)
-  {
-
-    if (color.cols != jwidth || color.rows != jheight || color.channels() != 3)
-    {
-      color.create(jheight, jwidth, CV_8UC3);
-    }
-    //doesn't work unfortunately..
-    //TODO cvtColor(mat,color, CV_YCrCb2RGB);
-    color_convert_common(buff, buff + jwidth * jheight, jwidth, jheight, color.ptr<uchar> (0), false);
-  }
-
+  Mat color;
   if (jgrey)
   {
     Mat grey = pool->getGrey(jidx);
     color = grey;
   }
-
+  else
+  {
+    color = pool->getImage(jidx);
+    pool->convertYUVtoColor(jidx, color);
+  }
   pool->addImage(jidx, color);
-
 }
 
 image_pool::image_pool()
@@ -71,7 +75,7 @@ image_pool::image_pool()
 
 image_pool::~image_pool()
 {
-  __android_log_print(ANDROID_LOG_INFO, "image_pool", "destructor called");
+
 }
 
 Mat image_pool::getImage(int i)
@@ -100,9 +104,7 @@ void image_pool::addImage(int i, Mat mat)
 
 void image_pool::convertYUVtoColor(int i, cv::Mat& out)
 {
-
   Mat yuv = getYUV(i);
-
   if (yuv.empty())
     return;
   int width = yuv.cols;
@@ -110,7 +112,19 @@ void image_pool::convertYUVtoColor(int i, cv::Mat& out)
   out.create(height, width, CV_8UC3);
   const unsigned char* buff = yuv.ptr<unsigned char> (0);
   unsigned char* out_buff = out.ptr<unsigned char> (0);
-  //doesn't work unfortunately..
-  //TODO cvtColor(mat,color, CV_YCrCb2RGB);
   color_convert_common(buff, buff + width * height, width, height, out_buff, false);
 }
+
+void copyMatToBuffer(char* buffer, const cv::Mat& mat)
+{
+  memcpy(buffer, mat.data, mat.rows * mat.cols * mat.step1());
+}
+void copyBufferToMat(cv::Mat& mat, const char* buffer)
+{
+  memcpy(mat.data, buffer, mat.rows * mat.cols * mat.step1());
+}
+
+void RGB2BGR(const Mat& in, Mat& out)
+{
+  cvtColor(in, out, CV_RGB2BGR);
+}

android/android-jni/jni/image_pool.i → android/android-opencv/jni/image_pool.i

@@ -40,17 +40,12 @@ references them by an index.  It allows one to get a pointer to an underlying ma
 
 %feature("director") image_pool;
 class image_pool {
-	
 public:
-	image_pool();
-	~image_pool();
-	
-	
+	Mat getGrey(int i);
 	Mat getImage(int i);
 	void addImage(int i, Mat mat);
-
-	
-
-
+	void convertYUVtoColor(int i, Mat& out);
 };
 
+void RGB2BGR(const Mat& in, Mat& out);
+

android/android-opencv/jni/include/android_logger.h

+#pragma once
+#include <iostream>
+#include <sstream>
+
+#define  LOG_TAG    "libopencv"
+#if ANDROID
+#include <android/log.h>
+#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
+#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
+#else
+#include <cstdio>
+#define  LOGI(...)  printf("info:");printf("%s:",LOG_TAG); fprintf(stdout,__VA_ARGS__);printf("\n");
+#define  LOGE(...)  printf("error:");printf("%s:",LOG_TAG); fprintf(stderr,__VA_ARGS__);printf("\n");
+#endif
+
+#ifndef LOGI_STREAM
+#define  LOGI_STREAM(x)  {std::stringstream ss; ss << x; LOGI("%s",ss.str().c_str());}
+#endif
+#define  LOGE_STREAM(x)  {std::stringstream ss; ss << x; LOGE("%s",ss.str().c_str());}

android/android-jni/jni/glcamera.h → android/android-opencv/jni/include/glcamera.h

@@ -2,8 +2,13 @@
 #define GLCAMERA_H_
 #include <opencv2/core/core.hpp>
 
+#ifdef __ANDROID__
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
 
 #include "image_pool.h"
 
@@ -17,8 +22,11 @@ public:
   void step();
 
   void drawMatToGL(int idx, image_pool* pool);
+  void drawMatToGL(const cv::Mat& img);
   void setTextureImage(const cv::Mat& img);
 
+  void clear();
+
 private:
   GLuint createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int width, int height, int channels);
   GLuint loadShader(GLenum shaderType, const char* pSource);
@@ -35,5 +43,6 @@ private:
 
   GLuint gvTexCoordHandle;
   GLuint gvSamplerHandle;
+  float img_w, img_h;
 };
 #endif

android/android-jni/jni/image_pool.h → android/android-opencv/jni/include/image_pool.h

@@ -3,27 +3,8 @@
 #include <opencv2/core/core.hpp>
 #include <map>
 
-#if ANDROID
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved);
-//
-//JNIEXPORT jobject JNICALL Java_com_opencv_jni_opencvJNI_getBitmapBuffer(
-//		JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_);
 
 
-JNIEXPORT void JNICALL Java_com_opencv_jni_opencvJNI_addYUVtoPool(JNIEnv *, jclass, jlong, jobject, jbyteArray, jint,
-                                                                  jint, jint, jboolean);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
 class image_pool
 {
 
@@ -63,4 +44,8 @@ private:
   std::map<int, cv::Mat> yuvImagesMap;
 
 };
+
+void copyMatToBuffer(char* buffer, const cv::Mat& mat);
+void copyBufferToMat(cv::Mat& mat, const char* buffer);
+void RGB2BGR(const cv::Mat& in, cv::Mat& out);
 #endif

android/android-opencv/jni/include/yuv2rgb.h

+/* YUV-> RGB conversion code.
+ *
+ * Copyright (C) 2008-9 Robin Watts (robin@wss.co.uk) for Pinknoise
+ * Productions Ltd.
+ *
+ * Licensed under the GNU GPL. If you need it under another license, contact
+ * me and ask.
+ *
+ *  This program is free software ; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation ; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program ; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+
+#ifndef YUV2RGB_H
+
+#define YUV2RGB_H
+
+/* Define these to something appropriate in your build */
+typedef unsigned int   uint32_t;
+typedef signed   int   int32_t;
+typedef unsigned short uint16_t;
+typedef unsigned char  uint8_t;
+
+extern const uint32_t yuv2rgb565_table[];
+extern const uint32_t yuv2bgr565_table[];
+
+void yuv420_2_rgb565(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv422_2_rgb565(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv444_2_rgb565(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv420_2_rgb888(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv422_2_rgb888(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv444_2_rgb888(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither);
+
+void yuv420_2_rgb8888(uint8_t  *dst_ptr,
+                const uint8_t  *y_ptr,
+                const uint8_t  *u_ptr,
+                const uint8_t  *v_ptr,
+                      int32_t   width,
+                      int32_t   height,
+                      int32_t   y_span,
+                      int32_t   uv_span,
+                      int32_t   dst_span,
+                const uint32_t *tables,
+                      int32_t   dither);
+
+void yuv422_2_rgb8888(uint8_t  *dst_ptr,
+                const uint8_t  *y_ptr,
+                const uint8_t  *u_ptr,
+                const uint8_t  *v_ptr,
+                      int32_t   width,
+                      int32_t   height,
+                      int32_t   y_span,
+                      int32_t   uv_span,
+                      int32_t   dst_span,
+                const uint32_t *tables,
+                      int32_t   dither);
+
+void yuv444_2_rgb8888(uint8_t  *dst_ptr,
+                const uint8_t  *y_ptr,
+                const uint8_t  *u_ptr,
+                const uint8_t  *v_ptr,
+                      int32_t   width,
+                      int32_t   height,
+                      int32_t   y_span,
+                      int32_t   uv_span,
+                      int32_t   dst_span,
+                const uint32_t *tables,
+                      int32_t   dither);
+
+
+#endif /* YUV2RGB_H */

android/android-jni/jni/yuv420sp2rgb.h → android/android-opencv/jni/include/yuv420sp2rgb.h

-//yuv420sp2rgb.h
 #ifndef YUV420SP2RGB_H
 #define YUV420SP2RGB_H
 

android/android-opencv/jni/yuv420rgb888c.c

+/* YUV-> RGB conversion code. (YUV420 to RGB565)
+ *
+ * Copyright (C) 2008-9 Robin Watts (robin@wss.co.uk) for Pinknoise
+ * Productions Ltd.
+ *
+ * Licensed under the GNU GPL. If you need it under another license, contact
+ * me and ask.
+ *
+ *  This program is free software ; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation ; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program ; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ *
+ * The algorithm used here is based heavily on one created by Sophie Wilson
+ * of Acorn/e-14/Broadcomm. Many thanks.
+ *
+ * Additional tweaks (in the fast fixup code) are from Paul Gardiner.
+ *
+ * The old implementation of YUV -> RGB did:
+ *
+ * R = CLAMP((Y-16)*1.164 +           1.596*V)
+ * G = CLAMP((Y-16)*1.164 - 0.391*U - 0.813*V)
+ * B = CLAMP((Y-16)*1.164 + 2.018*U          )
+ *
+ * We're going to bend that here as follows:
+ *
+ * R = CLAMP(y +           1.596*V)
+ * G = CLAMP(y - 0.383*U - 0.813*V)
+ * B = CLAMP(y + 1.976*U          )
+ *
+ * where y = 0               for       Y <=  16,
+ *       y = (  Y-16)*1.164, for  16 < Y <= 239,
+ *       y = (239-16)*1.164, for 239 < Y
+ *
+ * i.e. We clamp Y to the 16 to 239 range (which it is supposed to be in
+ * anyway). We then pick the B_U factor so that B never exceeds 511. We then
+ * shrink the G_U factor in line with that to avoid a colour shift as much as
+ * possible.
+ *
+ * We're going to use tables to do it faster, but rather than doing it using
+ * 5 tables as as the above suggests, we're going to do it using just 3.
+ *
+ * We do this by working in parallel within a 32 bit word, and using one
+ * table each for Y U and V.
+ *
+ * Source Y values are    0 to 255, so    0.. 260 after scaling
+ * Source U values are -128 to 127, so  -49.. 49(G), -253..251(B) after
+ * Source V values are -128 to 127, so -204..203(R), -104..103(G) after
+ *
+ * So total summed values:
+ * -223 <= R <= 481, -173 <= G <= 431, -253 <= B < 511
+ *
+ * We need to pack R G and B into a 32 bit word, and because of Bs range we
+ * need 2 bits above the valid range of B to detect overflow, and another one
+ * to detect the sense of the overflow. We therefore adopt the following
+ * representation:
+ *
+ * osGGGGGgggggosBBBBBbbbosRRRRRrrr
+ *
+ * Each such word breaks down into 3 ranges.
+ *
+ * osGGGGGggggg   osBBBBBbbb   osRRRRRrrr
+ *
+ * Thus we have 8 bits for each B and R table entry, and 10 bits for G (good
+ * as G is the most noticable one). The s bit for each represents the sign,
+ * and o represents the overflow.
+ *
+ * For R and B we pack the table by taking the 11 bit representation of their
+ * values, and toggling bit 10 in the U and V tables.
+ *
+ * For the green case we calculate 4*G (thus effectively using 10 bits for the
+ * valid range) truncate to 12 bits. We toggle bit 11 in the Y table.
+ */
+
+#include "yuv2rgb.h"
+
+enum
+{
+    FLAGS         = 0x40080100
+};
+
+#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)])
+#define READY(Y)    tables[Y]
+#define FIXUP(Y)                 \
+do {                             \
+    int tmp = (Y) & FLAGS;       \
+    if (tmp != 0)                \
+    {                            \
+        tmp  -= tmp>>8;          \
+        (Y)  |= tmp;             \
+        tmp   = FLAGS & ~(Y>>1); \
+        (Y)  += tmp>>8;          \
+    }                            \
+} while (0 == 1)
+
+#define STORE(Y,DSTPTR)           \
+do {                              \
+    uint32_t Y2       = (Y);      \
+    uint8_t  *DSTPTR2 = (DSTPTR); \
+    (DSTPTR2)[0] = (Y2);          \
+    (DSTPTR2)[1] = (Y2)>>22;      \
+    (DSTPTR2)[2] = (Y2)>>11;      \
+} while (0 == 1)
+
+void yuv420_2_rgb888(uint8_t  *dst_ptr,
+               const uint8_t  *y_ptr,
+               const uint8_t  *u_ptr,
+               const uint8_t  *v_ptr,
+                     int32_t   width,
+                     int32_t   height,
+                     int32_t   y_span,
+                     int32_t   uv_span,
+                     int32_t   dst_span,
+               const uint32_t *tables,
+                     int32_t   dither)
+{
+    height -= 1;
+    while (height > 0)
+    {
+        height -= width<<16;
+        height += 1<<16;
+        while (height < 0)
+        {
+            /* Do 2 column pairs */
+            uint32_t uv, y0, y1;
+
+            uv  = READUV(*u_ptr++,*v_ptr++);
+            y1  = uv + READY(y_ptr[y_span]);
+            y0  = uv + READY(*y_ptr++);
+            FIXUP(y1);
+            FIXUP(y0);
+            STORE(y1, &dst_ptr[dst_span]);
+            STORE(y0, dst_ptr);
+            dst_ptr += 3;
+            y1  = uv + READY(y_ptr[y_span]);
+            y0  = uv + READY(*y_ptr++);
+            FIXUP(y1);
+            FIXUP(y0);
+            STORE(y1, &dst_ptr[dst_span]);
+            STORE(y0, dst_ptr);
+            dst_ptr += 3;
+            height += (2<<16);
+        }
+        if ((height>>16) == 0)
+        {
+            /* Trailing column pair */
+            uint32_t uv, y0, y1;
+
+            uv = READUV(*u_ptr,*v_ptr);
+            y1 = uv + READY(y_ptr[y_span]);
+            y0 = uv + READY(*y_ptr++);
+            FIXUP(y1);
+            FIXUP(y0);
+            STORE(y0, &dst_ptr[dst_span]);
+            STORE(y1, dst_ptr);
+            dst_ptr += 3;
+        }
+        dst_ptr += dst_span*2-width*3;
+        y_ptr   += y_span*2-width;
+        u_ptr   += uv_span-(width>>1);
+        v_ptr   += uv_span-(width>>1);
+        height = (height<<16)>>16;
+        height -= 2;
+    }
+    if (height == 0)
+    {
+        /* Trail row */
+        height -= width<<16;
+        height += 1<<16;
+        while (height < 0)
+        {
+            /* Do a row pair */
+            uint32_t uv, y0, y1;
+
+            uv  = READUV(*u_ptr++,*v_ptr++);
+            y1  = uv + READY(*y_ptr++);
+            y0  = uv + READY(*y_ptr++);
+            FIXUP(y1);
+            FIXUP(y0);
+            STORE(y1, dst_ptr);
+            dst_ptr += 3;
+            STORE(y0, dst_ptr);
+            dst_ptr += 3;
+            height += (2<<16);
+        }
+        if ((height>>16) == 0)
+        {
+            /* Trailing pix */
+            uint32_t uv, y0;
+
+            uv = READUV(*u_ptr++,*v_ptr++);
+            y0 = uv + READY(*y_ptr++);
+            FIXUP(y0);
+            STORE(y0, dst_ptr);
+            dst_ptr += 3;
+        }
+    }
+}

android/android-opencv/jni/yuv420sp2rgb.c

+#include <string.h>
+#include <jni.h>
+
+#include <yuv420sp2rgb.h>
+#include <yuv2rgb.h>
+
+/*
+ YUV 4:2:0 image with a plane of 8 bit Y samples followed by an interleaved
+ U/V plane containing 8 bit 2x2 subsampled chroma samples.
+ except the interleave order of U and V is reversed.
+
+ H V
+ Y Sample Period      1 1
+ U (Cb) Sample Period 2 2
+ V (Cr) Sample Period 2 2
+ */
+
+/*
+ size of a char:
+ find . -name limits.h -exec grep CHAR_BIT {} \;
+ */
+
+#ifndef max
+#define max(a,b) (a > b ? a : b )
+#define min(a,b) (a < b ? a : b )
+#endif
+enum
+{
+    FLAGS         = 0x40080100
+};
+
+#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)])
+#define READY(Y)    tables[Y]
+#define FIXUP(Y)                 \
+do {                             \
+    int tmp = (Y) & FLAGS;       \
+    if (tmp != 0)                \
+    {                            \
+        tmp  -= tmp>>8;          \
+        (Y)  |= tmp;             \
+        tmp   = FLAGS & ~(Y>>1); \
+        (Y)  += tmp>>8;          \
+    }                            \
+} while (0 == 1)
+
+#define STORE(Y,DSTPTR)           \
+do {                              \
+    uint32_t Y2       = (Y);      \
+    uint8_t  *DSTPTR2 = (DSTPTR); \
+    (DSTPTR2)[2] = (Y2);          \
+    (DSTPTR2)[1] = (Y2)>>22;      \
+    (DSTPTR2)[0] = (Y2)>>11;      \
+} while (0 == 1)
+
+typedef unsigned char byte;
+const int bytes_per_pixel = 2;
+void color_convert_common(const unsigned char *pY, const unsigned char *pUV, int width, int height,
+                          unsigned char *buffer, int grey)
+{
+#define LOOKUP 1
+#if ! LOOKUP
+  int nR, nG, nB;
+#endif
+  int dest_span = 3 * width;
+  unsigned char *out = buffer;
+  if (grey)
+  {
+    memcpy(out, pY, width * height * sizeof(unsigned char));
+  }
+  else
+  {
+
+#if LOOKUP
+    const uint32_t* tables = yuv2rgb565_table;
+    const byte* nY = pY;
+    const byte* nUV = pUV;
+    int idx = 0;
+    while (nY+width < pUV)
+    {
+      int y = (idx / width);
+      int x = (idx % width);
+      byte Y = *nY;
+      byte Y2 = nY[width];
+      byte V = *nUV;
+      byte U = *(nUV + 1);
+      /* Do 2 row pairs */
+      uint32_t uv, y0, y1;
+
+      uv = READUV(U,V);
+      y1 = uv + READY(Y);
+      y0 = uv + READY(Y2);
+      FIXUP(y1);
+      FIXUP(y0);
+      STORE(y1, &out[dest_span]);
+      STORE(y0, out);
+      out += 3;
+      Y = *(++nY);
+      Y2 = nY[width];
+      y1 = uv + READY(Y);
+      y0 = uv + READY(Y2);
+      FIXUP(y1);
+      FIXUP(y0);
+      STORE(y1, &out[dest_span]);
+      STORE(y0, out);
+      out += 3;
+      height += (2 << 16);
+      ++nY;
+      nUV = pUV + (y / 2) * width + 2 * (x / 2);
+      idx+=2;
+    }
+#else
+    const byte* nY = pY;
+    const byte* nUV = pUV;
+    int idx = 0;
+    while (nY < pUV)
+    {
+
+      int y = (idx / width);
+      int x = (idx % width);
+      int Y = *nY;
+      int V = *nUV;
+      int U = *(nUV + 1);
+
+      Y -= 16;
+      V -= 128;
+      U -= 128;
+      if (y < 0)
+      y = 0;
+
+      nB = (int)(1192 * Y + 2066 * U);
+      nG = (int)(1192 * Y - 833 * V - 400 * U);
+      nR = (int)(1192 * Y + 1634 * V);
+
+      nR = min(262143, max(0, nR));
+      nG = min(262143, max(0, nG));
+      nB = min(262143, max(0, nB));
+
+      nR >>= 10;
+      nR &= 0xff;
+      nG >>= 10;
+      nG &= 0xff;
+      nB >>= 10;
+      nB &= 0xff;
+
+      *(out++) = (unsigned char)nR;
+      *(out++) = (unsigned char)nG;
+      *(out++) = (unsigned char)nB;
+      nY += 1;
+      nUV = pUV + (y / 2) * width + 2 * (x / 2);
+      ++idx;
+    }
+#endif
+  }
+
+
+}

android/android-opencv/res/layout/camera.xml

+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent" android:layout_height="fill_parent"
+	android:background="@drawable/cameraback">
+	<!--<SurfaceView-->
+	<com.opencv.camera.NativePreviewer
+		android:id="@+id/nativepreviewer" android:layout_width="400dip"
+		android:layout_height="300dip" android:layout_alignParentLeft="true"
+		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
+		android:layout_marginRight="20dip" />
+	<LinearLayout android:id="@+id/glview_layout"
+		android:layout_width="400dip" android:layout_height="300dip"
+		android:layout_alignParentLeft="true" android:layout_margin="20dip"
+		android:gravity="center_horizontal|center_vertical"
+		android:layout_marginRight="20dip">
+	</LinearLayout>
+	<LinearLayout android:layout_width="wrap_content"
+		android:layout_height="fill_parent" android:orientation="vertical"
+		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
+		android:layout_alignParentRight="true">
+		<ImageButton android:src="@android:drawable/ic_menu_camera"
+			android:id="@+id/button_capture" android:layout_width="60dip"
+			android:layout_height="60dip" android:layout_marginBottom="10dip"></ImageButton>
+			<ImageButton android:src="@android:drawable/ic_menu_preferences"
+			android:id="@+id/button_camera_settings" android:layout_width="60dip"
+			android:layout_height="60dip" android:layout_marginBottom="10dip"></ImageButton>
+	</LinearLayout>
+</RelativeLayout>

android/android-jni/res/layout/camerasettings.xml → android/android-opencv/res/layout/camerasettings.xml

@@ -27,7 +27,7 @@
 			android:prompt="@string/camera_mode_prompt" android:entries="@array/camera_mode">
 		</Spinner>
 	</LinearLayout>
-	
+
 		<LinearLayout android:id="@+id/LinearLayout01"
 		android:layout_width="wrap_content" android:layout_height="wrap_content"
 		android:gravity="center_vertical">
@@ -37,7 +37,7 @@
 			android:layout_height="wrap_content" android:saveEnabled="true"
 			android:prompt="@string/whitebalance_prompt" android:entries="@array/whitebalance">
 		</Spinner>
-	</LinearLayout>
-	
+</LinearLayout>
+
 
 </LinearLayout>

android/android-jni/src/com/opencv/OpenCV.java → android/android-opencv/src/com/opencv/OpenCV.java

@@ -107,7 +107,7 @@ public class OpenCV extends Activity {
 		FrameLayout frame = new FrameLayout(getApplication());
 
 		// Create our Preview view and set it as the content of our activity.
-		mPreview = new NativePreviewer(getApplication(), 400, 300);
+		mPreview = new NativePreviewer(getApplication(), 640, 480);
 
 		LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT,
 				LayoutParams.WRAP_CONTENT);
@@ -154,4 +154,4 @@ public class OpenCV extends Activity {
 
 	}
 
-}
+}
\ No newline at end of file

android/android-opencv/src/com/opencv/camera/CameraActivity.java

+package com.opencv.camera;
+
+import java.util.LinkedList;
+
+import android.app.Activity;
+import android.content.pm.ActivityInfo;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.LinearLayout;
+
+import com.opencv.camera.CameraButtonsHandler.CaptureListener;
+import com.opencv.opengl.GL2CameraViewer;
+
+public abstract class CameraActivity extends Activity implements CaptureListener {
+
+	/** Called when the activity is first created. */
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setFullscreen();
+		setOrientation();
+		disableScreenTurnOff();
+		setContentView(com.opencv.R.layout.camera);
+		cameraButtonHandler = new CameraButtonsHandler(this,this);
+		mPreview = (NativePreviewer) findViewById(com.opencv.R.id.nativepreviewer);
+		LinearLayout glview_layout = (LinearLayout) findViewById(com.opencv.R.id.glview_layout);
+		glview = new GL2CameraViewer(getApplication(), true, 0, 0);
+		glview_layout.addView(glview);
+	}
+
+	/**
+	 * Handle the capture button as follows...
+	 */
+	@Override
+	public boolean onKeyUp(int keyCode, KeyEvent event) {
+
+		switch (keyCode) {
+		case KeyEvent.KEYCODE_CAMERA:
+		case KeyEvent.KEYCODE_SPACE:
+		case KeyEvent.KEYCODE_DPAD_CENTER:
+			cameraButtonHandler.setIsCapture(true);
+			return true;
+
+		default:
+			return super.onKeyUp(keyCode, event);
+		}
+
+	}
+
+	/**
+	 * Handle the capture button as follows... On some phones there is no
+	 * capture button, only trackball
+	 */
+	@Override
+	public boolean onTrackballEvent(MotionEvent event) {
+		if (event.getAction() == MotionEvent.ACTION_UP) {
+			cameraButtonHandler.setIsCapture(true);
+			return true;
+		}
+		return super.onTrackballEvent(event);
+	}
+
+	/**
+	 * Avoid that the screen get's turned off by the system.
+	 */
+	public void disableScreenTurnOff() {
+		getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
+				WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+	}
+
+	/**
+	 * Set's the orientation to landscape, as this is needed by AndAR.
+	 */
+	public void setOrientation() {
+		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+	}
+
+	/**
+	 * Maximize the application.
+	 */
+	public void setFullscreen() {
+		requestWindowFeature(Window.FEATURE_NO_TITLE);
+		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+				WindowManager.LayoutParams.FLAG_FULLSCREEN);
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		mPreview.onPause();
+		glview.onPause();
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+		mPreview.setParamsFromPrefs(getApplicationContext());
+		glview.onResume();
+		mPreview.onResume();
+		setCallbackStack();
+	}
+
+	protected void setCallbackStack() {
+		LinkedList<NativeProcessor.PoolCallback> callbackstack = getCallBackStack();
+		if (callbackstack == null){
+			callbackstack = new LinkedList<NativeProcessor.PoolCallback>();
+			callbackstack.add(glview.getDrawCallback());
+		}
+		mPreview.addCallbackStack(callbackstack);
+	}
+
+	/**
+	 * Overide this and provide your processors to the camera
+	 * 
+	 * @return null for default drawing
+	 */
+	protected abstract LinkedList<NativeProcessor.PoolCallback> getCallBackStack();
+	public void onCapture(){
+		
+	}
+
+	protected NativePreviewer mPreview;
+	protected GL2CameraViewer glview;
+	protected CameraButtonsHandler cameraButtonHandler;
+}

android/android-opencv/src/com/opencv/camera/CameraButtonsHandler.java

+package com.opencv.camera;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ImageButton;
+
+public class CameraButtonsHandler {
+	/** Constructs a buttons handler, will register with the capture button
+	 * and the camera settings button. 
+	 * @param a The activity that has inflated the com.opencv.R.layout.camera
+	 * as its layout.
+	 */
+	public CameraButtonsHandler(Activity a, CaptureListener l) {
+		ImageButton capture = (ImageButton) a
+				.findViewById(com.opencv.R.id.button_capture);
+		ImageButton settings = (ImageButton) a
+				.findViewById(com.opencv.R.id.button_camera_settings);
+		capture.setOnClickListener(capture_listener);
+		settings.setOnClickListener(settings_listener);
+		captureListener = l;
+		ctx = a;
+	}
+	
+	public CameraButtonsHandler(Activity a) {
+		ImageButton capture = (ImageButton) a
+				.findViewById(com.opencv.R.id.button_capture);
+		ImageButton settings = (ImageButton) a
+				.findViewById(com.opencv.R.id.button_camera_settings);
+		capture.setOnClickListener(capture_listener);
+		settings.setOnClickListener(settings_listener);
+		ctx = a;
+	}
+	
+	
+	/** Check if the capture button has been pressed
+	 * @return true if the capture button has been pressed
+	 */
+	synchronized public boolean isCapture(){
+		return capture_flag;
+	}
+	
+	/** Reset the capture flag 
+	 */
+	synchronized public void resetIsCapture(){
+		capture_flag = false;
+	}
+	
+	/** Manually set the flag - call this on any event that should trigger
+	 * a capture
+	 * @param isCapture true if a capture should take place
+	 */
+	synchronized public void setIsCapture(boolean isCapture){
+		capture_flag = isCapture;
+		if(capture_flag && captureListener != null){
+			captureListener.onCapture();
+		}
+	}
+	
+	private OnClickListener capture_listener = new View.OnClickListener() {
+		@Override
+		public void onClick(View v) {
+			setIsCapture(true);
+		}
+	};
+	private OnClickListener settings_listener = new View.OnClickListener() {
+		@Override
+		public void onClick(View v) {
+			Intent configurer = new Intent(ctx,
+					CameraConfig.class);
+			ctx.startActivity(configurer);
+		}
+	};
+
+	interface CaptureListener{
+		public void onCapture();
+	}
+	private CaptureListener captureListener;
+	private Context ctx;		
+	private boolean capture_flag = false;
+}

android/android-jni/src/com/opencv/camera/CameraConfig.java → android/android-opencv/src/com/opencv/camera/CameraConfig.java

@@ -171,7 +171,7 @@ public class CameraConfig extends Activity {
 
 			}
 		});
-		
+
 		whitebalance_spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
 
 			@Override

android/android-jni/src/com/opencv/camera/NativePreviewer.java → android/android-opencv/src/com/opencv/camera/NativePreviewer.java

@@ -29,7 +29,7 @@ public class NativePreviewer extends SurfaceView implements
 	 * Constructor useful for defining a NativePreviewer in android layout xml
 	 * 
 	 * @param context
-	 * @param attributes
+	 * @param attributes 
 	 */
 	public NativePreviewer(Context context, AttributeSet attributes) {
 		super(context, attributes);
@@ -47,7 +47,7 @@ public class NativePreviewer extends SurfaceView implements
 				"preview_width", 600);
 		preview_height = attributes.getAttributeIntValue("opencv",
 				"preview_height", 600);
-
+		
 		Log.d("NativePreviewer", "Trying to use preview size of "
 				+ preview_width + " " + preview_height);
 
@@ -92,17 +92,17 @@ public class NativePreviewer extends SurfaceView implements
 	 * @param height
 	 *            desired height
 	 */
-	public void setPreviewSize(int width, int height) {
+	public void setPreviewSize(int width, int height){
 		preview_width = width;
 		preview_height = height;
-
+		
 		Log.d("NativePreviewer", "Trying to use preview size of "
 				+ preview_width + " " + preview_height);
 
 	}
-
-	public void setParamsFromPrefs(Context ctx) {
-		int size[] = { 0, 0 };
+	
+	public void setParamsFromPrefs(Context ctx){
+		int size[] ={0,0};
 		CameraConfig.readImageSize(ctx, size);
 		int mode = CameraConfig.readCameraMode(ctx);
 		setPreviewSize(size[0], size[1]);
@@ -146,7 +146,7 @@ public class NativePreviewer extends SurfaceView implements
 		}
 		preview_width = best_width;
 		preview_height = best_height;
-
+		
 		Log.d("NativePreviewer", "Determined compatible preview size is: ("
 				+ preview_width + "," + preview_height + ")");
 
@@ -159,10 +159,10 @@ public class NativePreviewer extends SurfaceView implements
 		if (parameters.getSupportedWhiteBalance().contains(whitebalance_mode)) {
 			parameters.setWhiteBalance(whitebalance_mode);
 		}
-		if (parameters.getSupportedAntibanding().contains(
-				Camera.Parameters.ANTIBANDING_OFF)) {
-			parameters.setAntibanding(Camera.Parameters.ANTIBANDING_OFF);
-		}
+//		if (parameters.getSupportedAntibanding().contains(
+//				Camera.Parameters.ANTIBANDING_OFF)) {
+//			parameters.setAntibanding(Camera.Parameters.ANTIBANDING_OFF);
+//		}
 
 		List<String> fmodes = mCamera.getParameters().getSupportedFocusModes();
 		// for(String x: fmodes){
@@ -476,7 +476,7 @@ public class NativePreviewer extends SurfaceView implements
 
 	public void setGrayscale(boolean b) {
 		processor.setGrayscale(b);
-
+		
 	}
 
 }
\ No newline at end of file

android/android-jni/src/com/opencv/opengl/GL2CameraViewer.java → android/android-opencv/src/com/opencv/opengl/GL2CameraViewer.java

@@ -361,6 +361,12 @@ public class GL2CameraViewer extends GLSurfaceView{
     	else
     		Log.e("android-opencv", "null glcamera!!!!");
     }
+    public void clear(){
+    	if(mglcamera != null)
+    		mglcamera.clear();
+    	else
+    		Log.e("android-opencv", "null glcamera!!!!");
+    }
     
     private class Renderer implements GLSurfaceView.Renderer {
     	

android/android-opencv/src/com/opencv/utils/BitmapBridge.java

+package com.opencv.utils;
+
+import java.nio.ByteBuffer;
+
+import com.opencv.jni.Mat;
+import com.opencv.jni.Size;
+import com.opencv.jni.opencv;
+
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+
+public class BitmapBridge {
+	static void copyBitmap(Bitmap bmap, Mat mat) throws Exception {
+		if ((bmap.getConfig() == null) || bmap.getConfig() == Config.ARGB_8888)
+			throw new Exception("bad config");
+		Size sz = new Size(bmap.getWidth(), bmap.getHeight());
+		mat.create(sz, opencv.CV_8UC4);
+		ByteBuffer buffer = ByteBuffer.allocate(4 * bmap.getWidth()
+				* bmap.getHeight());
+		bmap.copyPixelsToBuffer(buffer);
+		opencv.copyBufferToMat(mat, buffer);
+
+	}
+
+	static Bitmap matToBitmap(Mat mat) {
+		Bitmap bmap = Bitmap.createBitmap(mat.getCols(), mat.getRows(),
+				Config.ARGB_8888);
+		ByteBuffer buffer = ByteBuffer.allocate(4 * bmap.getWidth()
+				* bmap.getHeight());
+		opencv.copyMatToBuffer(buffer, mat);
+		bmap.copyPixelsFromBuffer(buffer);
+		return bmap;
+	}
+}

android/apps/CVCamera/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+project(CVCamera)
+
+add_subdirectory(jni)

android/apps/CVCamera/Makefile

-# The path to the NDK, requires crystax version r-4 for now, due to support
-# for the standard library
-
-# load environment from local make file
-LOCAL_ENV_MK=local.env.mk
-ifneq "$(wildcard $(LOCAL_ENV_MK))" ""
-include $(LOCAL_ENV_MK)
-else
-$(shell cp sample.$(LOCAL_ENV_MK) $(LOCAL_ENV_MK))
-$(info ERROR local environement not setup! try:)
-$(info gedit $(LOCAL_ENV_MK))
-$(error Please setup the $(LOCAL_ENV_MK) - the default was just created')
-endif
-ifndef ARM_TARGETS
-ARM_TARGETS="armeabi armeabi-v7a"
-endif
-ANDROID_NDK_BASE = $(ANDROID_NDK_ROOT)
-
-$(info OPENCV_CONFIG = $(OPENCV_CONFIG))
-
-ifndef PROJECT_PATH
-$(info PROJECT_PATH defaulting to this directory)
-PROJECT_PATH=.
-endif
-
-
-# The name of the native library
-LIBNAME = libcvcamera.so
-
-
-# Find all the C++ sources in the native folder
-SOURCES = $(wildcard jni/*.cpp)
-HEADERS = $(wildcard jni/*.h)
-
-ANDROID_MKS = $(wildcard jni/*.mk)
-
-SWIG_IS = $(wildcard jni/*.i)
-
-SWIG_MAIN = jni/cvcamera.i
-
-SWIG_JAVA_DIR = src/com/theveganrobot/cvcamera/jni
-SWIG_JAVA_OUT = $(wildcard $(SWIG_JAVA_DIR)/*.java)
-
-
-SWIG_C_DIR = jni/gen
-SWIG_C_OUT = $(SWIG_C_DIR)/cvcamera_swig.cpp
-
-BUILD_DEFS=OPENCV_CONFIG=$(OPENCV_CONFIG) \
-	PROJECT_PATH=$(PROJECT_PATH) \
-	V=$(V) \
-	$(NDK_FLAGS) \
-	ARM_TARGETS=$(ARM_TARGETS)
-
-# The real native library stripped of symbols
-LIB		= libs/armeabi-v7a/$(LIBNAME) libs/armeabi/$(LIBNAME)
-
-
-all:	$(LIB)
-
-
-#calls the ndk-build script, passing it OPENCV_ROOT and OPENCV_LIBS_DIR
-$(LIB): $(SWIG_C_OUT) $(SOURCES) $(HEADERS) $(ANDROID_MKS)
-	$(ANDROID_NDK_BASE)/ndk-build $(BUILD_DEFS)
-
-
-#this creates the swig wrappers
-$(SWIG_C_OUT): $(SWIG_IS)
-	make clean-swig &&\
-	mkdir -p $(SWIG_C_DIR) &&\
-	mkdir -p $(SWIG_JAVA_DIR) &&\
-	swig -java -c++ -I../../android-jni/jni -package  "com.theveganrobot.cvcamera.jni" \
-	-outdir $(SWIG_JAVA_DIR) \
-	-o $(SWIG_C_OUT) $(SWIG_MAIN)
-	
-	
-#clean targets
-.PHONY: clean  clean-swig cleanall
-
-#this deletes the generated swig java and the generated c wrapper
-clean-swig:
-	rm -f $(SWIG_JAVA_OUT) $(SWIG_C_OUT)
-	
-#does clean-swig and then uses the ndk-build clean
-clean: clean-swig
-	$(ANDROID_NDK_BASE)/ndk-build clean $(BUILD_DEFS)
-

android/apps/CVCamera/build.sh

-make V=0

android/apps/CVCamera/clean.sh

-make OPENCV_ROOT=../../opencv V=0 clean

android/apps/CVCamera/default.properties

@@ -7,6 +7,6 @@
 # "build.properties", and override values to adapt the script to your
 # project structure.
 
-android.library.reference.1=../../android-jni
+android.library.reference.1=../../android-opencv
 # Project target.
 target=android-7

android/apps/CVCamera/jni/Android.mk

-# date: Summer, 2010 
-# author: Ethan Rublee
-# contact: ethan.rublee@gmail.com
-#
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-#define OPENCV_INCLUDES and OPENCV_LIBS
-include $(OPENCV_CONFIG)
-
-LOCAL_LDLIBS += $(OPENCV_LIBS) $(ANDROID_OPENCV_LIBS) -llog -lGLESv2
-    
-LOCAL_C_INCLUDES +=  $(OPENCV_INCLUDES) $(ANDROID_OPENCV_INCLUDES)
-
-LOCAL_MODULE    := cvcamera
-
-LOCAL_SRC_FILES := Processor.cpp gen/cvcamera_swig.cpp
-
-include $(BUILD_SHARED_LIBRARY)
-

android/apps/CVCamera/jni/Application.mk

-# The ARMv7 is significanly faster due to the use of the hardware FPU
-APP_ABI := $(ARM_TARGETS)
\ No newline at end of file

android/apps/CVCamera/jni/CMakeLists.txt

+#########################################################
+# Find opencv and android-opencv
+#########################################################
+
+set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../../build 
+    CACHE PATH "The path where you built opencv for android")
+set(AndroidOpenCV_DIR ${CMAKE_SOURCE_DIR}/../../android-opencv/build 
+    CACHE PATH "The path where you built android-opencv")
+
+find_package(OpenCV REQUIRED)
+FIND_PACKAGE(AndroidOpenCV REQUIRED )
+
+#########################################################
+#c flags, included, and lib dependencies
+#########################################################
+
+#notice the "recycling" of CMAKE_C_FLAGS
+#this is necessary to pick up android flags
+set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+set( LIBRARY_DEPS ${AndroidOpenCV_LIBS} ${OpenCV_LIBS} )
+if(ANDROID)
+  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl)
+endif(ANDROID)
+
+#########################################################
+#SWIG STUFF
+#########################################################
+#the java package to place swig generated java files in
+set(MY_PACKAGE com.theveganrobot.cvcamera.jni)
+
+if(NOT ANDROID)
+  #non android swig and jni
+  #jni is available by default on android
+  find_package(JNI REQUIRED)
+  include_directories(${JNI_INCLUDE_DIRS})
+  FIND_PACKAGE(SWIG)
+endif()
+
+INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
+
+if(ANDROID)
+  #this will set the output path for the java package
+  #and properly create the package declarations in generated java sources
+  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
+endif(ANDROID)
+
+#this add's the swig path for the opencv wrappers
+SET(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} "-I${AndroidOpenCV_SWIG_DIR}" )
+
+SET_SOURCE_FILES_PROPERTIES(cvcamera.i PROPERTIES CPLUSPLUS ON)
+
+#add the swig module, giving it the name, java, and then all of the source files
+SWIG_ADD_MODULE(cvcamera java 
+                cvcamera.i #swig file
+                Processor.cpp #cpp files can be compiled to
+                )
+             
+#link the module like any other   
+target_link_libraries(cvcamera ${LIBRARY_DEPS} )

android/apps/CVCamera/sample.local.env.mk

-#location of android-opencv port of OpenCV to android
-OPENCV_CONFIG=../../build/android-opencv.mk
-ANDROID_NDK_ROOT=$(HOME)/android-ndk-r4-crystax
-ARM_TARGETS="armeabi armeabi-v7a"

android/apps/Calibration/default.properties

@@ -7,6 +7,6 @@
 # "build.properties", and override values to adapt the script to your
 # project structure.
 
-android.library.reference.1=../../android-jni
+android.library.reference.1=../../android-opencv/
 # Project target.
 target=android-7

android/apps/Calibration/src/com/opencv/calibration/Calibration.java

@@ -204,9 +204,9 @@ public class Calibration extends Activity implements CalibrationCallback {
 
 		setFullscreen();
 		disableScreenTurnOff();
-		setContentView(R.layout.camera);
+		setContentView(R.layout.calib_camera);
 		mPreview = (NativePreviewer) findViewById(R.id.nativepreviewer);
-		mPreview.setPreviewSize(1000, 500);
+		mPreview.setPreviewSize(800, 400);
 		mPreview.setGrayscale(true);
 		LinearLayout glview_layout = (LinearLayout) findViewById(R.id.glview_layout);
 		glview = new GL2CameraViewer(getApplication(), false, 0, 0);

android/apps/OpenCV_SAMPLE/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+	package="com.OpenCV_SAMPLE" android:versionCode="1"
+	android:versionName="1.0">
+	<application android:label="@string/app_name"
+		android:debuggable="true" android:icon="@drawable/icon">
+		<activity android:name=".OpenCV_SAMPLE" android:label="@string/app_name"
+			android:screenOrientation="landscape" android:configChanges="orientation|keyboardHidden|keyboard">
+			<intent-filter>
+				<action android:name="android.intent.action.MAIN" />
+				<category android:name="android.intent.category.LAUNCHER" />
+			</intent-filter>
+		</activity>
+		<!-- These activities are defined in the android-opencv library, and just 
+			reused here -->
+		<activity android:name="com.opencv.camera.CameraConfig"
+			android:label="@string/app_name" android:screenOrientation="landscape"
+			android:configChanges="orientation|keyboardHidden|keyboard">
+		</activity>
+	</application>
+
+	<uses-sdk android:minSdkVersion="7" />
+
+	<!-- set the opengl version -->
+	<uses-feature android:glEsVersion="0x00020000" />
+	<!-- use the camera -->
+	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
+
+</manifest> 
\ No newline at end of file

android/apps/OpenCV_SAMPLE/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+project(OpenCV_SAMPLE)
+
+add_subdirectory(jni)

android/default.properties.in → android/apps/OpenCV_SAMPLE/default.properties

 # This file is automatically generated by Android Tools.
 # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
+#
 # This file must be checked in Version Control Systems.
-# 
+#
 # To customize properties used by the Ant build system use,
 # "build.properties", and override values to adapt the script to your
 # project structure.
 
 # Project target.
 target=android-7
+android.library.reference.1=../../android-opencv/

android/apps/OpenCV_SAMPLE/jni/CMakeLists.txt

+#########################################################
+# Find opencv and android-opencv
+#########################################################
+
+set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../../build 
+    CACHE PATH "The path where you built opencv for android")
+set(AndroidOpenCV_DIR ${CMAKE_SOURCE_DIR}/../../android-opencv/build 
+    CACHE PATH "The path where you built android-opencv")
+
+find_package(OpenCV REQUIRED)
+FIND_PACKAGE(AndroidOpenCV REQUIRED )
+
+#########################################################
+#c flags, included, and lib dependencies
+#########################################################
+
+#notice the "recycling" of CMAKE_C_FLAGS
+#this is necessary to pick up android flags
+set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+set( LIBRARY_DEPS ${AndroidOpenCV_LIBS} ${OpenCV_LIBS} )
+if(ANDROID)
+  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl)
+endif(ANDROID)
+
+#########################################################
+#SWIG STUFF
+#########################################################
+#the java package to place swig generated java files in
+set(MY_PACKAGE com.OpenCV_SAMPLE.jni )
+set(MY_MODULE OpenCV_SAMPLE )
+set(MY_SWIG 
+    OpenCV_SAMPLE.i #swig file
+    )
+set(MY_SRCS
+    cvsample.cpp #cpp files can be compiled to
+    )
+
+if(NOT ANDROID)
+  #non android swig and jni
+  #jni is available by default on android
+  find_package(JNI REQUIRED)
+  include_directories(${JNI_INCLUDE_DIRS})
+  FIND_PACKAGE(SWIG)
+endif()
+
+INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
+
+if(ANDROID)
+  #this will set the output path for the java package
+  #and properly create the package declarations in generated java sources
+  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
+endif(ANDROID)
+
+#this add's the swig path for the opencv wrappers
+SET(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} "-I${AndroidOpenCV_SWIG_DIR}" )
+
+SET_SOURCE_FILES_PROPERTIES(${MY_SWIG} PROPERTIES CPLUSPLUS ON)
+
+#add the swig module, giving it the name, java, and then all of the source files
+SWIG_ADD_MODULE(${MY_MODULE} java 
+                ${MY_SWIG}
+                ${MY_SRCS}
+                )
+#link the module like any other   
+target_link_libraries(${MY_MODULE} ${LIBRARY_DEPS} )

android/apps/OpenCV_SAMPLE/jni/OpenCV_SAMPLE.i

+/* File : foobar.i */
+%module OpenCV_SAMPLE
+
+/*
+ * the java import code muse be included for the opencv jni wrappers
+ * this means that the android project must reference opencv/android as a project
+ * see the default.properties for how this is done
+ */
+%pragma(java) jniclassimports=%{
+import com.opencv.jni.*; //import the android-opencv jni wrappers
+%}
+
+%pragma(java) jniclasscode=%{
+  static {
+    try {
+        //load up our shared libraries
+        System.loadLibrary("android-opencv");
+        System.loadLibrary("OpenCV_SAMPLE");
+      } catch (UnsatisfiedLinkError e) {
+        //badness
+        throw e;
+    }
+  }
+
+%}
+
+//import the android-cv.i file so that swig is aware of all that has been previous defined
+//notice that it is not an include....
+%import "android-cv.i"
+
+%{
+#include "cvsample.h"
+using cv::Mat;
+%}
+
+//make sure to import the image_pool as it is 
+//referenced by the Processor java generated
+//class
+%typemap(javaimports) CVSample "
+import com.opencv.jni.*;// import the opencv java bindings
+"
+class CVSample
+{
+public:
+  void canny(const Mat& input, Mat& output, int edgeThresh);
+  void invert(Mat& inout);
+  void blur(Mat& inout, int half_kernel_size);
+};

android/apps/OpenCV_SAMPLE/jni/cvsample.cpp

+#include "cvsample.h"
+#include <opencv2/imgproc/imgproc.hpp>
+
+void CVSample::canny(const cv::Mat& input, cv::Mat& output, int edgeThresh)
+{
+  if (input.empty())
+    return;
+  cv::Mat gray;
+  if (input.channels() == 3)
+  {
+    cv::cvtColor(input, gray, CV_RGB2GRAY);
+  }
+  else
+    gray = input;
+  cv::Canny(gray, output, edgeThresh, edgeThresh * 3, 3);
+}
+
+void CVSample::invert(cv::Mat& inout)
+{
+  cv::bitwise_not(inout, inout);
+}
+void CVSample::blur(cv::Mat& inout, int half_kernel_size)
+{
+  int ksz = half_kernel_size*2 + 1;
+  cv::Size kernel(ksz,ksz);
+  cv::blur(inout,inout,kernel);
+}

android/apps/OpenCV_SAMPLE/jni/cvsample.h

+#pragma once
+
+#include <opencv2/core/core.hpp>
+
+class CVSample
+{
+public:
+  void canny(const cv::Mat& input, cv::Mat& output, int edgeThresh);
+  void invert(cv::Mat& inout);
+  void blur(cv::Mat& inout, int half_kernel_size);
+};

android/apps/OpenCV_SAMPLE/project_create.sh

+#this generates an ant based cli build of the android-jni project
+android update project --name OpenCV_SAMPLE \
+--path .