SET( ENABLE_SSSE3 OFF CACHE INTERNAL "" FORCE )
#Set output folder to ${CMAKE_BINARY_DIR}
-set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
\ No newline at end of file
+set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "root for library output, set this to change where android libs are compiled to" )
endif()
add_subdirectory(androidcamera)
+ add_subdirectory(java)
endif()
add_subdirectory(calib3d)
--- /dev/null
+# ----------------------------------------------------------------------------
+# CMake file for java support
+# ----------------------------------------------------------------------------
+project(opencv_java)
+
+SET(OPENCV_JAVA_MODULES objdetect features2d imgproc video highgui ml core)
+SET(OPENCV_EXTRA_JAVA_MODULES calib3d contrib legacy flann)
+IF(ANDROID AND NOT BUILD_SHARED_LIBS)
+ LIST(APPEND OPENCV_EXTRA_JAVA_MODULES androidcamera)
+ENDIF()
+
+SET(GEN_JAVA "${CMAKE_CURRENT_SOURCE_DIR}/gen_java.py")
+SET(HDR_PARSER "${CMAKE_CURRENT_SOURCE_DIR}/../python/src2/hdr_parser.py")
+
+foreach(module ${OPENCV_JAVA_MODULES})
+ IF(${module} STREQUAL core)
+ SET (module_cppheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include/opencv2/${module}/${module}.hpp")
+ SET (module_cheaders "")
+ ELSE()
+ FILE(GLOB module_cheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include/opencv2/${module}/*.h")
+ FILE(GLOB module_cppheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include/opencv2/${module}/*.hpp")
+ ENDIF()
+ list(SORT module_cheaders)
+ list(SORT module_cppheaders)
+
+ add_custom_command(
+ OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${module}.java
+ OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp
+ COMMAND ${PYTHON_EXECUTABLE} -B "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_cheaders} ${module_cppheaders}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${GEN_JAVA}
+ DEPENDS ${HDR_PARSER}
+ DEPENDS ${module_headers}
+ )
+endforeach()
+
+set(target "opencv_java")
+include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+
+FILE(GLOB handwrittren_cpp_sources "${CMAKE_CURRENT_SOURCE_DIR}/srccpp/*.cpp")
+
+SET (generated_cpp_sources "")
+SET (generated_java_sources "")
+SET (dependent_libs "")
+SET (dependent_extra_libs "")
+
+foreach(module ${OPENCV_JAVA_MODULES})
+ LIST(APPEND generated_cpp_sources "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp")
+ LIST(APPEND generated_java_sources "${CMAKE_CURRENT_BINARY_DIR}/${module}.java")
+ LIST(APPEND dependent_libs opencv_${module})
+ include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include")
+endforeach()
+
+foreach(module ${OPENCV_EXTRA_JAVA_MODULES})
+ LIST(APPEND dependent_extra_libs opencv_${module})
+ include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include")
+endforeach()
+
+#SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L/home/andreyk/OpenCV2/trunk/opencv/android/build/libs/armeabi-v7a")
+
+add_library(${target} SHARED ${handwrittren_cpp_sources} ${generated_cpp_sources})
+
+target_link_libraries(${target} ${dependent_libs} ${dependent_extra_libs} ${OPENCV_LINKER_LIBS})
+if(ANDROID)
+ target_link_libraries(${target} jnigraphics)
+endif()
+
+#add_dependencies(${the_target} ${dependent_extra_libs} ${dependent_libs})
+
+# Additional target properties
+set_target_properties(${target} PROPERTIES
+ OUTPUT_NAME "${target}"
+ ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+ RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+ INSTALL_NAME_DIR lib
+ )
+
+add_custom_target(opecv_java_api ALL DEPENDS ${target})
+
+IF(ANDROID)
+ # create Android library project in build folder
+ add_custom_command(TARGET opecv_java_api COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/res")
+
+ FILE(GLOB android_lib_project_files "${CMAKE_CURRENT_SOURCE_DIR}/android/*")
+ foreach(lib_file ${android_lib_project_files})
+ if(NOT IS_DIRECTORY ${lib_file})
+ add_custom_command(TARGET opecv_java_api COMMAND ${CMAKE_COMMAND} -E copy "${lib_file}" "${CMAKE_BINARY_DIR}" DEPENDS "${lib_file}")
+ endif()
+ endforeach()
+ENDIF()
+
+FILE(GLOB java_project_files "${CMAKE_CURRENT_SOURCE_DIR}/srcjava/*.java")
+SET(JAVA_OUTPUT_DIR "${CMAKE_BINARY_DIR}/src/org/opencv")
+add_custom_command(TARGET opecv_java_api COMMAND ${CMAKE_COMMAND} -E make_directory "${JAVA_OUTPUT_DIR}")
+
+foreach(java_file ${java_project_files} ${generated_java_sources})
+ add_custom_command(TARGET opecv_java_api COMMAND ${CMAKE_COMMAND} -E copy "${java_file}" "${JAVA_OUTPUT_DIR}" DEPENDS "${java_file}" DEPENDS "${JAVA_OUTPUT_DIR}")
+endforeach()
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<classpath>\r
+ <classpathentry kind="src" path="src"/>\r
+ <classpathentry kind="src" path="gen"/>\r
+ <classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>\r
+ <classpathentry kind="output" path="bin"/>\r
+</classpath>\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<projectDescription>\r
+ <name>OpenCVJavaAPI</name>\r
+ <comment></comment>\r
+ <projects>\r
+ </projects>\r
+ <buildSpec>\r
+ <buildCommand>\r
+ <name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>org.eclipse.jdt.core.javabuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>com.android.ide.eclipse.adt.ApkBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ </buildSpec>\r
+ <natures>\r
+ <nature>com.android.ide.eclipse.adt.AndroidNature</nature>\r
+ <nature>org.eclipse.jdt.core.javanature</nature>\r
+ </natures>\r
+</projectDescription>\r
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>\r
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"\r
+ package="org.opencv.JavaAPI"\r
+ android:versionCode="1"\r
+ android:versionName="1.0">\r
+ <application android:label="OpenCVJavaAPI">\r
+ <activity android:name="OpenCVJavaAPI"\r
+ android:label="OpenCVJavaAPI">\r
+ <intent-filter>\r
+ <action android:name="android.intent.action.MAIN" />\r
+ <category android:name="android.intent.category.LAUNCHER" />\r
+ </intent-filter>\r
+ </activity>\r
+ </application>\r
+</manifest> \r
--- /dev/null
+# 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.
+
+android.library=true
+# Project target.
+target=android-8
--- /dev/null
+import sys, re, os.path\r
+from string import Template\r
+\r
+try:\r
+ from cStringIO import StringIO\r
+except:\r
+ from StringIO import StringIO\r
+\r
+ctype2j = {\r
+ # c : (j, jn, jni, jni code)\r
+ "" : ("", "long", "jlong", ""), # c-tor\r
+ "void" : ("void", "void", "void", ""),\r
+ "bool" : ("boolean", "boolean","jboolean", "Z"),\r
+ "int" : ("int", "int", "jint", "I"),\r
+ "long" : ("int", "int", "jint", "I"),\r
+ "float" : ("float", "float", "jfloat", "F"),\r
+ "double" : ("double", "double", "jdouble", "D"),\r
+ "size_t" : ("long", "long", "jlong", "J"),\r
+ "env" : ("", "", "JNIEnv*", ""), # dummy 'env'\r
+ "cls" : ("", "", "jclass", ""), # dummy 'cls'\r
+#\r
+ "Mat" : ("Mat", (("size_t", ".nativeObj"),), "*%(n)s", "J"),\r
+ "Point" : ("Point", (("double", ".x"), ("double", ".y")), "cv::Point((int)%(n)s_x, (int)%(n)s_y)", "DD"),\r
+ "Point2f" : ("Point", (("double", ".x"), ("double", ".y")), "cv::Point2f((float)%(n)s_x, (float)%(n)s_y)", "DD"),\r
+ "Point2d" : ("Point", (("double", ".x"), ("double", ".y")), "cv::Point2d(%(n)s_x, %(n)s_y)", "DD"),\r
+ "Point3i" : ("Point", (("double", ".x"), ("double", ".y"), ("double", ".z")),\\r
+ "cv::Point3i((int)%(n)s_x, (int)%(n)s_y, (int)%(n)s_z)", "DDD"),\r
+ "Point3f" : ("Point", (("double", ".x"), ("double", ".y"), ("double", ".z")),\\r
+ "cv::Point3f((float)%(n)s_x, (float)%(n)s_y, (float)%(n)s_z)", "DDD"),\r
+ "Point3d" : ("Point", (("double", ".x"), ("double", ".y"), ("double", ".z")),\\r
+ "cv::Point3d(%(n)s_x, %(n)s_y, %(n)s_z)", "DDD"),\r
+ "Rect" : ("Rect", (("int", ".x"), ("int", ".y"), ("int", ".width"), ("int", ".height")), \\r
+ "cv::Rect(%(n)s_x, %(n)s_y, %(n)s_width, %(n)s_height)", "IIII"),\r
+ "Size" : ("Size", (("int", ".width"), ("int", ".height")), "cv::Size(%(n)s_width, %(n)s_height)", "II"),\r
+ "Scalar" : ("Scalar", (("double", ".v0"), ("double", ".v1"), ("double", ".v2"), ("double", ".v3")),\\r
+ "cv::Scalar(%(n)s_v0, %(n)s_v1, %(n)s_v2, %(n)s_v3)", "DDDD"),\r
+\r
+}\r
+\r
+class ConstInfo(object):\r
+ def __init__(self, cname, name, val):\r
+## self.name = re.sub(r"^cv\.", "", name).replace(".", "_")\r
+ self.cname = cname\r
+ self.name = re.sub(r"^Cv", "", name)\r
+ #self.name = re.sub(r"([a-z])([A-Z])", r"\1_\2", name)\r
+ #self.name = self.name.upper()\r
+ self.value = val\r
+\r
+\r
+class ClassInfo(object):\r
+ def __init__(self, decl): # [ 'class/struct cname', [bases], [modlist] ]\r
+ name = decl[0]\r
+ name = name[name.find(" ")+1:].strip()\r
+ self.cname = self.name = self.jname = re.sub(r"^cv\.", "", name)\r
+ self.cname =self.cname.replace(".", "::")\r
+ self.jname = re.sub(r"^Cv", "", self.jname)\r
+ self.methods = {}\r
+ self.consts = [] # using a list to save the occurence order\r
+ for m in decl[2]:\r
+ if m.startswith("="):\r
+ self.jname = m[1:]\r
+\r
+\r
+class ArgInfo(object):\r
+ def __init__(self, arg_tuple): # [ ctype, name, def val, [mod], argno ]\r
+ self.ctype = arg_tuple[0]\r
+ self.name = arg_tuple[1]\r
+ self.defval = arg_tuple[2]\r
+ self.out = "/O" in arg_tuple[3] or "/IO" in arg_tuple[3]\r
+\r
+## def isbig(self):\r
+## return self.ctype == "Mat" or self.ctype == "vector_Mat"\r
+\r
+\r
+class FuncInfo(object):\r
+ def __init__(self, decl): # [ funcname, return_ctype, [modifiers], [args] ]\r
+ name = re.sub(r"^cv\.", "", decl[0])\r
+ self.cname = name.replace(".", "::")\r
+ classname = ""\r
+ dpos = name.rfind(".")\r
+ if dpos >= 0:\r
+ classname = name[:dpos]\r
+ name = name[dpos+1:]\r
+ self.classname = classname\r
+ self.jname = self.name = name\r
+ if "[" in name:\r
+ self.jname = "getelem"\r
+ for m in decl[2]:\r
+ if m.startswith("="):\r
+ self.jname = m[1:]\r
+ self.jn_name = "n_" + self.jname\r
+ self.jni_name= re.sub(r"_", "_1", self.jn_name)\r
+ if self.classname:\r
+ self.jni_name = "00024" + self.classname + "_" + self.jni_name\r
+ self.static = ["","static"][ "/S" in decl[2] ]\r
+ self.ctype = decl[1] or ""\r
+ self.args = []\r
+ self.jni_suffix = "__"\r
+ if self.classname and self.ctype and not self.static: # non-static class methods except c-tors\r
+ self.jni_suffix += "J" # artifical 'self'\r
+ for a in decl[3]:\r
+ ai = ArgInfo(a)\r
+ self.args.append(ai)\r
+ self.jni_suffix += ctype2j.get(ai.ctype, ["","","",""])[3]\r
+\r
+\r
+\r
+class FuncFamilyInfo(object):\r
+ def __init__(self, decl): # [ funcname, return_ctype, [modifiers], [args] ]\r
+ self.funcs = []\r
+ self.funcs.append( FuncInfo(decl) )\r
+ self.jname = self.funcs[0].jname\r
+ self.isconstructor = self.funcs[0].name == self.funcs[0].classname\r
+\r
+\r
+\r
+ def add_func(self, fi):\r
+ self.funcs.append( fi )\r
+\r
+\r
+class JavaWrapperGenerator(object):\r
+ def __init__(self):\r
+ self.clear()\r
+\r
+ def clear(self):\r
+ self.classes = { "Mat" : ClassInfo([ 'class Mat', [], [] ]) }\r
+ self.funcs = {}\r
+ self.consts = [] # using a list to save the occurence order\r
+ self.module = ""\r
+ self.java_code = StringIO()\r
+ self.cpp_code = StringIO()\r
+ self.ported_func_counter = 0\r
+ self.func_counter = 0\r
+\r
+ def add_class(self, decl):\r
+ classinfo = ClassInfo(decl)\r
+ if classinfo.name in self.classes:\r
+ print "Generator error: class %s (%s) is duplicated" % \\r
+ (classinfo.name, classinfo.cname)\r
+ sys.exit(-1)\r
+ self.classes[classinfo.name] = classinfo\r
+ if classinfo.name in ctype2j:\r
+ print "Duplicated class: " + classinfo.name\r
+ sys.exit(-1)\r
+ ctype2j[classinfo.name] = (classinfo.jname, (("size_t", ".nativeObj"),), "*%(n)s", "J")\r
+\r
+\r
+ def add_const(self, decl): # [ "const cname", val, [], [] ]\r
+ consts = self.consts\r
+ name = decl[0].replace("const ", "").strip()\r
+ name = re.sub(r"^cv\.", "", name)\r
+ cname = name.replace(".", "::")\r
+ # check if it's a class member\r
+ dpos = name.rfind(".")\r
+ if dpos >= 0:\r
+ classname = name[:dpos]\r
+ name = name[dpos+1:]\r
+ if classname in self.classes:\r
+ consts = self.classes[classname].consts\r
+ else:\r
+ # this class isn't wrapped\r
+ # skipping this const\r
+ return\r
+ constinfo = ConstInfo(cname, name, decl[1])\r
+ # checking duplication\r
+ for c in consts:\r
+ if c.name == constinfo.name:\r
+ print "Generator error: constant %s (%s) is duplicated" \\r
+ % (constinfo.name, constinfo.cname)\r
+ sys.exit(-1)\r
+ consts.append(constinfo)\r
+\r
+ def add_func(self, decl):\r
+ ffi = FuncFamilyInfo(decl)\r
+ func_map = self.funcs\r
+ classname = ffi.funcs[0].classname\r
+ if classname:\r
+ if classname in self.classes:\r
+ func_map = self.classes[classname].methods\r
+ else:\r
+ print "Generator error: the class %s for method %s is missing" % \\r
+ (classname, ffi.jname)\r
+ sys.exit(-1)\r
+ if ffi.jname in func_map:\r
+ func_map[ffi.jname].add_func(ffi.funcs[0])\r
+ else:\r
+ func_map[ffi.jname] = ffi\r
+\r
+ def save(self, path, name, buf):\r
+ f = open(path + "/" + name, "wt")\r
+ f.write(buf.getvalue())\r
+ f.close()\r
+\r
+ def gen(self, srcfiles, module, output_path):\r
+ self.clear()\r
+ self.module = module\r
+ parser = hdr_parser.CppHeaderParser()\r
+\r
+ # step 1: scan the headers and build more descriptive maps of classes, consts, functions\r
+ for hdr in srcfiles:\r
+ decls = parser.parse(hdr)\r
+ for decl in decls:\r
+ name = decl[0]\r
+ if name.startswith("struct") or name.startswith("class"):\r
+ self.add_class(decl)\r
+ pass\r
+ elif name.startswith("const"):\r
+ self.add_const(decl)\r
+ else: # function\r
+ self.add_func(decl)\r
+ pass\r
+\r
+ # java module header\r
+ self.java_code.write(\\r
+"""package org.opencv;\r
+\r
+public class %(module)s {\r
+\r
+ //Load the native jni library\r
+ static {\r
+ System.loadLibrary("opencv_java");\r
+ }\r
+\r
+ public static final int\r
+ CV_8U = 0,\r
+ CV_8S = 1,\r
+ CV_16U = 2,\r
+ CV_16S = 3,\r
+ CV_32S = 4,\r
+ CV_32F = 5,\r
+ CV_64F = 6,\r
+ CV_USRTYPE1 = 7,\r
+ IPL_BORDER_CONSTANT = 0,\r
+ IPL_BORDER_REPLICATE = 1,\r
+ IPL_BORDER_REFLECT = 2,\r
+ IPL_BORDER_WRAP = 3,\r
+ IPL_BORDER_REFLECT_101 = 4,\r
+ IPL_BORDER_TRANSPARENT = 5;\r
+""" % {"module" : module} )\r
+\r
+ # cpp module header\r
+ self.cpp_code.write(\\r
+"""// This file is auto-generated, please don't edit!\r
+\r
+#include <jni.h>\r
+\r
+""" % {"module" : module})\r
+ self.cpp_code.write( "\n".join(['#include "opencv2/%s/%s"' % (module, os.path.basename(f)) \\r
+ for f in srcfiles]) )\r
+ self.cpp_code.write("\n\n")\r
+\r
+ # step 2: generate the code for global constants\r
+ self.gen_consts()\r
+\r
+ # step 3: generate the code for all the global functions\r
+ self.gen_funcs()\r
+\r
+ # step 4: generate code for the classes\r
+ #self.gen_classes() # !!! tempory disabled !!!\r
+\r
+ # java module tail\r
+ self.java_code.write("}\n")\r
+\r
+ self.save(output_path, module+".java", self.java_code)\r
+ self.save(output_path, module+".cpp", self.cpp_code)\r
+\r
+ print "Done %i of %i funcs." % (self.ported_func_counter, self.func_counter)\r
+\r
+\r
+ def gen_consts(self):\r
+ # generate the code for global constants\r
+ if self.consts:\r
+ self.java_code.write("""\r
+ public static final int\r
+ """ + """,\r
+ """.join(["%s = %s" % (c.name, c.value) for c in self.consts]) + \\r
+ ";\n\n")\r
+\r
+\r
+ def gen_func(self, fi, isoverload):\r
+ self.func_counter += 1\r
+\r
+ # java part & cpp part:\r
+ # // c_decl\r
+ # e.g:\r
+ # // void add(Mat src1, Mat src2, Mat dst, Mat mask = Mat(), int dtype = -1)\r
+ c_decl = "%s %s %s(%s)" % \\r
+ ( fi.static, fi.ctype, fi.cname, \\r
+ ", ".join(a.ctype + " " + a.name + [""," = "+a.defval][bool(a.defval)] for a in fi.args) )\r
+ indent = ""\r
+ if fi.classname:\r
+ indent = " " * 4\r
+ self.java_code.write( "\n %s// %s\n" % (indent, c_decl) )\r
+ self.cpp_code.write( "\n//\n//%s\n//\n" % c_decl )\r
+ # check if we 'know' all the types\r
+ if fi.ctype and fi.ctype!="Mat" and fi.ctype[0].isupper(): # ret val is class, NYI (TODO!)\r
+ self.java_code.write( " %s// Return type '%s' is not yet supported, skipping the function\n\n"\\r
+ % (indent, fi.ctype) )\r
+ print "SKIP:", c_decl, "\n\tdue to RET type", fi.ctype\r
+ return\r
+ types = [fi.ctype]\r
+ types.extend([a.ctype for a in fi.args])\r
+ for t in types:\r
+ if t not in ctype2j:\r
+ self.java_code.write( " %s// Unknown type '%s', skipping the function\n\n" % (indent, t) )\r
+ print "SKIP:", c_decl, "\n\tdue to ARG type", t\r
+ return\r
+ for a in fi.args:\r
+ if a.ctype[0].isupper() and a.ctype != "Mat" and a.out: # C++ reference to a class (gcc disallows temp obj reference)\r
+ self.java_code.write( " %s// Unknown type '%s&', skipping the function\n\n" % (indent, t) )\r
+ print "SKIP:", c_decl, "\n\tdue to ARG type", a.ctype + "&"\r
+ return\r
+ if fi.cname == "minEnclosingCircle":\r
+ self.java_code.write( " %s// Temporary skipping the function %s\n\n" % (indent, fi.cname) )\r
+ print "SKIP:", c_decl, "\n\tdue to Temporary filtering"\r
+ return\r
+\r
+ self.ported_func_counter += 1\r
+ # java args\r
+ args = fi.args[:]\r
+ if args and args[-1].defval:\r
+ isoverload = True\r
+ suffix = fi.jni_suffix\r
+\r
+ while True:\r
+\r
+ # java native method args\r
+ jn_args = []\r
+ if fi.classname and fi.ctype and not fi.static: # non-static class method except c-tor\r
+ jn_args.append(ArgInfo([ "size_t", "nativeObj", "", [], "" ])) # adding 'this'\r
+ for a in args:\r
+ if a.ctype[0].isupper(): # Point/Rect/...\r
+ #"Point" : ("Point", [["int", ".x"], ["int", ".y"]], ...)\r
+ fields = ctype2j[a.ctype][1]\r
+ for f in fields:\r
+ jn_args.append( ArgInfo([ f[0], a.name + f[1], "", [], "" ]) )\r
+ else:\r
+ jn_args.append(a)\r
+\r
+ # jni (cpp) function args\r
+ jni_args = [ArgInfo([ "env", "env", "", [], "" ]), ArgInfo([ "cls", "cls", "", [], "" ])]\r
+ if fi.classname and fi.ctype and not fi.static:\r
+ jni_args.append(ArgInfo([ "size_t", "self", "", [], "" ]))\r
+ for a in args:\r
+ if a.ctype[0].isupper(): # Point/Rect/...\r
+ #"Point" : ("Point", [["int", ".x"], ["int", ".y"]], ...)\r
+ fields = ctype2j[a.ctype][1]\r
+ for f in fields:\r
+ jni_args.append( ArgInfo([ f[0], a.name + f[1].replace(".","_"), "", [], "" ]) )\r
+ else:\r
+ jni_args.append(a)\r
+\r
+ # java part:\r
+ # private java NATIVE method decl\r
+ # e.g.\r
+ # private static native void n_add(long src1, long src2, long dst, long mask, int dtype);\r
+ jn_type = ""\r
+ if fi.ctype == "Mat":\r
+ jn_type = "long"\r
+ elif fi.ctype[0].isupper():\r
+ jn_type = "NYI" # TODO: NYI\r
+ else:\r
+ jn_type = ctype2j[fi.ctype][1]\r
+\r
+ self.java_code.write( Template(\\r
+ " ${indent}private static native $jn_type $jn_name($jn_args);\n").substitute(\\r
+ indent = indent, \\r
+ jn_type=jn_type, \\r
+ jn_name=fi.jn_name, \\r
+ jn_args=", ".join(["%s %s" % (ctype2j[a.ctype][1], a.name.replace(".","_")) for a in jn_args])\r
+ ) );\r
+\r
+ # java part:\r
+ # public java wrapper method impl (calling native one above)\r
+ # e.g.\r
+ # public static void add( Mat src1, Mat src2, Mat dst, Mat mask, int dtype )\r
+ # { n_add( src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype ); }\r
+ impl_code = " return $jn_name($jn_args_call); "\r
+ if fi.ctype == "void":\r
+ impl_code = " $jn_name($jn_args_call); "\r
+ elif fi.ctype == "": # c-tor\r
+ impl_code = " nativeObj = $jn_name($jn_args_call); "\r
+ elif fi.ctype in self.classes: # wrapped class\r
+ impl_code = " return new %s( $jn_name($jn_args_call) ); " % \\r
+ self.classes[fi.ctype].jname\r
+\r
+ static = "static"\r
+ if fi.classname:\r
+ static = fi.static\r
+\r
+ self.java_code.write( Template(\\r
+ " ${indent}public $static $j_type $j_name($j_args)").substitute(\\r
+ indent = indent, \\r
+ static=static, \\r
+ j_type=ctype2j[fi.ctype][0], \\r
+ j_name=fi.jname, \\r
+ j_args=", ".join(["%s %s" % (ctype2j[a.ctype][0], a.name) for a in args]) \\r
+ ) )\r
+\r
+ self.java_code.write( Template("\n $indent{ " + impl_code + " }\n").substitute(\\r
+ indent = indent, \\r
+ jn_name=fi.jn_name, \\r
+ jn_args_call=", ".join([a.name + ["",".nativeObj"][ctype2j[a.ctype][0]=="Mat"] for a in jn_args])\\r
+ ) )\r
+\r
+ # cpp part:\r
+ # jni_func(..) { return cv_func(..); }\r
+ ret = "return "\r
+ if fi.ctype == "void":\r
+ ret = ""\r
+ elif fi.ctype == "Mat":\r
+ ret = "return (jlong) new cv::Mat"\r
+ elif fi.ctype[0].isupper():\r
+ ret = NYI # NYI\r
+\r
+ cvname = "cv::" + fi.name\r
+ j2cvargs = []\r
+ if fi.classname:\r
+ if not fi.ctype: # c-tor\r
+ cvname = "(jlong) new cv::" + fi.classname\r
+ elif fi.static:\r
+ cvname = "cv::%s::%s" % (fi.classname, fi.name)\r
+ else:\r
+ cvname = "%s->%s" % ("me", fi.name)\r
+ j2cvargs.append(\\r
+ "cv::%s* me = (cv::%s*) self; //TODO: check for NULL" % \\r
+ (fi.classname, fi.classname) \\r
+ )\r
+ cvargs = []\r
+ for a in args:\r
+ cva = a.name\r
+ if a.ctype[0].isupper(): # Point/Rect/...\r
+ # "Point" : ("Point", (("int", ".x"), ("int", ".y")), "Point(%(n)s_x, %(n)s_y)", "II")\r
+ # Point(p_x, p_y)\r
+ cva = ctype2j[a.ctype][2] % {"n" : a.name}\r
+ if a.ctype == "Mat":\r
+ j2cvargs.append("cv::Mat* %s = (cv::Mat*) %s_nativeObj; //TODO: check for NULL"\\r
+ % (a.name, a.name))\r
+ pass\r
+ cvargs.append(cva)\r
+\r
+ rtype = "NYI"\r
+ if fi.ctype == "Mat":\r
+ rtype = "jlong"\r
+ elif fi.ctype[0].isupper():\r
+ rtype = "NYI" # TODO: NYI\r
+ else:\r
+ rtype = ctype2j[fi.ctype][2]\r
+\r
+ self.cpp_code.write ( Template( \\r
+"""\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+JNIEXPORT $rtype JNICALL Java_org_opencv_${module}_$fname\r
+ ($args);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+JNIEXPORT $rtype JNICALL Java_org_opencv_${module}_$fname\r
+ ($args)\r
+{\r
+ $j2cv\r
+ $ret( $cvname( $cvargs ) );\r
+}\r
+\r
+""" ).substitute( \\r
+ rtype = rtype, \\r
+ module = self.module, \\r
+ fname = fi.jni_name + ["",suffix][isoverload], \\r
+ args = ", ".join(["%s %s" % (ctype2j[a.ctype][2], a.name) for a in jni_args]), \\r
+ j2cv = "\n ".join([a for a in j2cvargs]), \\r
+ ret = ret, \\r
+ cvname = cvname, \\r
+ cvargs = ", ".join([a for a in cvargs]), \\r
+ ) )\r
+\r
+ # processing args with default values\r
+ if args and args[-1].defval:\r
+ a = args.pop()\r
+ suffix = suffix[0:-len(ctype2j[a.ctype][3])]\r
+ else:\r
+ break\r
+\r
+\r
+\r
+ def gen_funcs(self):\r
+ # generate the code for all the global functions\r
+ indent = "\t"\r
+ fflist = self.funcs.items()\r
+ fflist.sort()\r
+ for name, ffi in fflist:\r
+ assert not ffi.funcs[0].classname, "Error: global func is a class member - "+name\r
+ for fi in ffi.funcs:\r
+ self.gen_func(fi, len(ffi.funcs)>1)\r
+\r
+\r
+ def gen_classes(self):\r
+ # generate code for the classes (their methods and consts)\r
+ indent = "\t"\r
+ indent_m = indent + "\t"\r
+ classlist = self.classes.items()\r
+ classlist.sort()\r
+ for name, ci in classlist:\r
+ self.java_code.write( "\n" + indent + "// class %s" % (ci.cname) + "\n" )\r
+ self.java_code.write( indent + "public static class %s {\n\n" % (ci.jname) )\r
+\r
+ # self\r
+ self.java_code.write( indent_m + "protected final long nativeObj;\n" )\r
+ self.java_code.write( indent_m + "protected %s(long addr) { nativeObj = addr; }\n\n" \\r
+ % name );\r
+ # constants\r
+ if ci.consts:\r
+ prefix = "\n" + indent_m + "\t\t"\r
+ s = indent_m + "public static final int" + prefix +\\r
+ ("," + prefix).join(["%s = %s" % (c.name, c.value) for c in ci.consts]) + ";\n\n"\r
+ self.java_code.write( s )\r
+ # c-tors\r
+ fflist = ci.methods.items()\r
+ fflist.sort()\r
+ for n, ffi in fflist:\r
+ if ffi.isconstructor:\r
+ for fi in ffi.funcs:\r
+ self.gen_func(fi, len(ffi.funcs)>1)\r
+ self.java_code.write( "\n" )\r
+ for n, ffi in fflist:\r
+ if not ffi.isconstructor:\r
+ for fi in ffi.funcs:\r
+ self.gen_func(fi, len(ffi.funcs)>1)\r
+\r
+ self.java_code.write( "\n" + indent + "}\n\n" )\r
+\r
+\r
+if __name__ == "__main__":\r
+ if len(sys.argv) < 4:\r
+ print "Usage:\n", \\r
+ os.path.basename(sys.argv[0]), \\r
+ "<full path to hdr_parser.py> <module name> <C++ header> [<C++ header>...]"\r
+ print "Current args are: ", ", ".join(["'"+a+"'" for a in sys.argv])\r
+ exit(0)\r
+\r
+ dstdir = "."\r
+ hdr_parser_path = os.path.abspath(sys.argv[1])\r
+ if hdr_parser_path.endswith(".py"):\r
+ hdr_parser_path = os.path.dirname(hdr_parser_path)\r
+ sys.path.append(hdr_parser_path)\r
+ import hdr_parser\r
+ module = sys.argv[2]\r
+ srcfiles = sys.argv[3:]\r
+ print "Generating module '" + module + "' from headers:\n\t" + "\n\t".join(srcfiles)\r
+ generator = JavaWrapperGenerator()\r
+ generator.gen(srcfiles, module, dstdir)\r
+\r
+\r
+\r
--- /dev/null
+#include <jni.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nCreateMat\r
+ * Signature: (III)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCreateMat__III\r
+ (JNIEnv *, jclass, jint, jint, jint);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nCreateMat\r
+ * Signature: (IIIDDDD)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCreateMat__IIIDDDD\r
+ (JNIEnv *, jclass, jint, jint, jint, jdouble, jdouble, jdouble, jdouble);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nDispose\r
+ * Signature: (J)V\r
+ */\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nDispose\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nType\r
+ * Signature: (J)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nType\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nRows\r
+ * Signature: (J)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nRows\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nCols\r
+ * Signature: (J)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nCols\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nData\r
+ * Signature: (J)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nData\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nIsEmpty\r
+ * Signature: (J)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsEmpty\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nIsCont\r
+ * Signature: (J)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsCont\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nIsSubmat\r
+ * Signature: (J)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsSubmat\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nSubmat\r
+ * Signature: (JIIII)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nSubmat\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jint);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nClone\r
+ * Signature: (J)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nClone\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nPutD\r
+ * Signature: (JIII[D)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutD\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jdoubleArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nPutF\r
+ * Signature: (JIII[F)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutF\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jfloatArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nPutI\r
+ * Signature: (JIII[I)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutI\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jintArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nPutS\r
+ * Signature: (JIII[S)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutS\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jshortArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nPutB\r
+ * Signature: (JIII[B)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutB\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jbyteArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nGetB\r
+ * Signature: (JIII[B)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetB\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jbyteArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nGetS\r
+ * Signature: (JIII[S)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetS\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jshortArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nGetI\r
+ * Signature: (JIII[I)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetI\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jintArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nGetF\r
+ * Signature: (JIII[F)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetF\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jfloatArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nGetD\r
+ * Signature: (JIII[D)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetD\r
+ (JNIEnv *, jclass, jlong, jint, jint, jint, jdoubleArray);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nSetTo\r
+ * Signature: (JDDDD)V\r
+ */\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nSetTo\r
+ (JNIEnv *, jclass, jlong, jdouble, jdouble, jdouble, jdouble);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nCopyTo\r
+ * Signature: (JJ)V\r
+ */\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nCopyTo\r
+ (JNIEnv *, jclass, jlong, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nDot\r
+ * Signature: (JJ)D\r
+ */\r
+JNIEXPORT jdouble JNICALL Java_org_opencv_Mat_nDot\r
+ (JNIEnv *, jclass, jlong, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nCross\r
+ * Signature: (JJ)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCross\r
+ (JNIEnv *, jclass, jlong, jlong);\r
+\r
+/*\r
+ * Class: org_opencv_Mat\r
+ * Method: nInv\r
+ * Signature: (J)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nInv\r
+ (JNIEnv *, jclass, jlong);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+\r
+#include "opencv2/core/core.hpp"\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nType\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->type( );\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nRows\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->rows;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nCols\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->cols;\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nData\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return (jlong) me->data;\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsEmpty\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->empty();\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsCont\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->isContinuous();\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_Mat_nIsSubmat\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return me->isSubmatrix();\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nSubmat\r
+ (JNIEnv* env, jclass cls, jlong self, jint r1, jint r2, jint c1, jint c2)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ return (jlong) new cv::Mat(*me, cv::Range(r1, r2>0 ? r2 : me->rows), cv::Range(c1, c2>0 ? c2 : me->cols));\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nClone\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ cv::Mat* it = new cv::Mat();\r
+ me->copyTo(*it);\r
+ return (jlong) it;\r
+}\r
+\r
+// unlike other nPut()-s this one (with double[]) should convert input values to correct type\r
+#define PUT_ITEM(T, R, C) for(int ch=0; ch<me->channels() & count>0; ch++,count--) *((T*)me->ptr(R, C)+ch) = cv::saturate_cast<T>(*(src+ch))\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutD\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+\r
+ int rest = ((me->rows - row) * me->cols - col) * me->channels();\r
+ if(count>rest) count = rest;\r
+ int res = count;\r
+ double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ double* src = values;\r
+ int r, c;\r
+ for(c=col; c<me->cols & count>0; c++)\r
+ {\r
+ switch(me->depth()) {\r
+ case CV_8U: PUT_ITEM(uchar, row, c); break;\r
+ case CV_8S: PUT_ITEM(schar, row, c); break;\r
+ case CV_16U: PUT_ITEM(ushort, row, c); break;\r
+ case CV_16S: PUT_ITEM(short, row, c); break;\r
+ case CV_32S: PUT_ITEM(int, row, c); break;\r
+ case CV_32F: PUT_ITEM(float, row, c); break;\r
+ case CV_64F: PUT_ITEM(double, row, c); break;\r
+ }\r
+ src++;\r
+ }\r
+\r
+ for(r=row+1; r<me->rows & count>0; r++)\r
+ for(c=0; c<me->cols & count>0; c++)\r
+ {\r
+ switch(me->depth()) {\r
+ case CV_8U: PUT_ITEM(uchar, r, c); break;\r
+ case CV_8S: PUT_ITEM(schar, r, c); break;\r
+ case CV_16U: PUT_ITEM(ushort, r, c); break;\r
+ case CV_16S: PUT_ITEM(short, r, c); break;\r
+ case CV_32S: PUT_ITEM(int, r, c); break;\r
+ case CV_32F: PUT_ITEM(float, r, c); break;\r
+ case CV_64F: PUT_ITEM(double, r, c); break;\r
+ }\r
+ src++;\r
+ }\r
+\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+\r
+template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count, char* buff)\r
+{\r
+ if(! m) return 0;\r
+ if(! buff) return 0;\r
+\r
+ int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);\r
+ if(count>rest) count = rest;\r
+ int res = count;\r
+\r
+ if( m->isContinuous() )\r
+ {\r
+ memcpy(m->ptr(row, col), buff, count);\r
+ } else {\r
+ // row by row\r
+ int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row\r
+ if(count<num) num = count;\r
+ uchar* data = m->ptr(row++, col);\r
+ while(count>0){\r
+ memcpy(data, buff, num);\r
+ count -= num;\r
+ buff += num;\r
+ num = m->cols * m->channels() * sizeof(T);\r
+ if(count<num) num = count;\r
+ data = m->ptr(row++, 0);\r
+ }\r
+ }\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutB\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_put<char>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutS\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_put<short>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutI\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_put<int>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nPutF\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_put<float>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+\r
+\r
+template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char* buff)\r
+{\r
+ if(! m) return 0;\r
+ if(! buff) return 0;\r
+\r
+ int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);\r
+ if(count>rest) count = rest;\r
+ int res = count;\r
+\r
+ if( m->isContinuous() )\r
+ {\r
+ memcpy(buff, m->ptr(row, col), count);\r
+ } else {\r
+ // row by row\r
+ int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row\r
+ if(count<num) num = count;\r
+ uchar* data = m->ptr(row++, col);\r
+ while(count>0){\r
+ memcpy(buff, data, num);\r
+ count -= num;\r
+ buff += num;\r
+ num = m->cols * m->channels() * sizeof(T);\r
+ if(count<num) num = count;\r
+ data = m->ptr(row++, 0);\r
+ }\r
+ }\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetB\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_get<char>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetS\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_get<short>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetI\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_get<int>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetF\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_get<float>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_opencv_Mat_nGetD\r
+ (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self;\r
+ if(! self) return 0; // no native object behind\r
+ if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type\r
+ if(me->rows<=row || me->cols<=col) return 0; // indexes out of range\r
+ \r
+ char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);\r
+ int res = mat_get<double>(me, row, col, count, values);\r
+ env->ReleasePrimitiveArrayCritical(vals, values, 0);\r
+ return res;\r
+}\r
+\r
+\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nSetTo\r
+ (JNIEnv* env, jclass cls, jlong self, jdouble v0, jdouble v1, jdouble v2, jdouble v3)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ me->setTo( cv::Scalar(v0, v1, v2, v3), cv::Mat() );\r
+}\r
+\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nCopyTo\r
+ (JNIEnv* env, jclass cls, jlong self, jlong m)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ cv::Mat* _m = (cv::Mat*) m; //TODO: check for NULL\r
+ me->copyTo( *_m );\r
+}\r
+\r
+JNIEXPORT jdouble JNICALL Java_org_opencv_Mat_nDot\r
+ (JNIEnv* env, jclass cls, jlong self, jlong m)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ cv::Mat* _m = (cv::Mat*) m; //TODO: check for NULL\r
+ return me->dot( *_m );\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCross\r
+ (JNIEnv* env, jclass cls, jlong self, jlong it)\r
+{\r
+ return 0; //NYI\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nInv\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ return 0; //NYI\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCreateMat__III\r
+ (JNIEnv* env, jclass cls, jint _rows, jint _cols, jint _type)\r
+{\r
+ return (jlong) new cv::Mat( _rows, _cols, _type );\r
+}\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_Mat_nCreateMat__IIIDDDD\r
+ (JNIEnv* env, jclass cls, jint _rows, jint _cols, jint _type, jdouble v0, jdouble v1, jdouble v2, jdouble v3)\r
+{\r
+ return (jlong) new cv::Mat( _rows, _cols, _type, cv::Scalar(v0, v1, v2, v3) );\r
+}\r
+\r
+JNIEXPORT void JNICALL Java_org_opencv_Mat_nDispose\r
+ (JNIEnv* env, jclass cls, jlong self)\r
+{\r
+ cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL\r
+ delete me;\r
+}\r
+\r
--- /dev/null
+#include <jni.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/*\r
+ * Class: org_opencv_utils\r
+ * Method: nBitmapToMat(Bitmap b)\r
+ * Signature: (L)J\r
+ */\r
+JNIEXPORT jlong JNICALL Java_org_opencv_utils_nBitmapToMat\r
+ (JNIEnv *, jclass, jobject);\r
+\r
+/*\r
+ * Class: org_opencv_utils\r
+ * Method: nBitmapToMat(long m, Bitmap b)\r
+ * Signature: (JL)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_utils_nMatToBitmap\r
+ (JNIEnv *, jclass, jlong, jobject);\r
+\r
+\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#include "opencv2/core/core.hpp"\r
+\r
+#include <android/bitmap.h>\r
+\r
+JNIEXPORT jlong JNICALL Java_org_opencv_utils_nBitmapToMat\r
+ (JNIEnv * env, jclass cls, jobject bitmap)\r
+{\r
+ AndroidBitmapInfo info;\r
+ void* pixels;\r
+ cv::Mat* m = NULL;\r
+\r
+ if ( AndroidBitmap_getInfo(env, bitmap, &info) < 0 )\r
+ return 0; // can't get info\r
+\r
+ if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)\r
+ return 0; // incompatible format\r
+\r
+ if ( AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0 )\r
+ return 0; // can't get pixels\r
+\r
+ m = new cv::Mat(info.height, info.width, CV_8UC4);\r
+ memcpy(m->data, pixels, info.height * info.width * 4);\r
+\r
+ AndroidBitmap_unlockPixels(env, bitmap);\r
+\r
+ return (jlong)m;\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_opencv_utils_nMatToBitmap\r
+ (JNIEnv * env, jclass cls, jlong m, jobject bitmap)\r
+{\r
+ AndroidBitmapInfo info;\r
+ void* pixels;\r
+ cv::Mat* mat = (cv::Mat*) m;\r
+\r
+ if ( m == 0 )\r
+ return false; // no native Mat behind\r
+\r
+ if ( AndroidBitmap_getInfo(env, bitmap, &info) < 0 )\r
+ return false; // can't get info\r
+\r
+ if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)\r
+ return false; // incompatible format\r
+\r
+ if ( AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0 )\r
+ return false; // can't get pixels\r
+\r
+ memcpy(pixels, mat->data, info.height * info.width * 4);\r
+\r
+ AndroidBitmap_unlockPixels(env, bitmap);\r
+\r
+ return true;\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Mat {\r
+\r
+ public static class CvType {\r
+ \r
+ // predefined type constants\r
+ public static final CvType\r
+ CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),\r
+ CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),\r
+ CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),\r
+ CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),\r
+ CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),\r
+ CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),\r
+ CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);\r
+ \r
+ // type depth constants\r
+ public static final int CV_8U = 0, \r
+ CV_8S = 1, \r
+ CV_16U = 2, \r
+ CV_16S = 3, \r
+ CV_32S = 4, \r
+ CV_32F = 5, \r
+ CV_64F = 6, \r
+ CV_USRTYPE1=7;\r
+ \r
+ private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);\r
+\r
+ private final int value;\r
+ \r
+ protected CvType(int depth, int channels) {\r
+ if(channels<=0 || channels>=CV_CN_MAX) {\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Channels count should be 1.." + (CV_CN_MAX-1) );\r
+ }\r
+ if(depth<0 || depth>=CV_DEPTH_MAX) {\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Data type depth should be 0.." + (CV_DEPTH_MAX-1) );\r
+ }\r
+ value = (depth & (CV_DEPTH_MAX-1)) + ((channels-1) << CV_CN_SHIFT); \r
+ }\r
+\r
+ protected CvType(int val) { value = val; }\r
+\r
+ public static final CvType CV_8UC(int ch) { return new CvType(CV_8U, ch); }\r
+ \r
+ public static final CvType CV_8SC(int ch) { return new CvType(CV_8S, ch); }\r
+ \r
+ public static final CvType CV_16UC(int ch) { return new CvType(CV_16U, ch); }\r
+ \r
+ public static final CvType CV_16SC(int ch) { return new CvType(CV_16S, ch); }\r
+ \r
+ public static final CvType CV_32SC(int ch) { return new CvType(CV_32S, ch); }\r
+ \r
+ public static final CvType CV_32FC(int ch) { return new CvType(CV_32F, ch); }\r
+ \r
+ public static final CvType CV_64FC(int ch) { return new CvType(CV_64F, ch); }\r
+ \r
+ public final int toInt() { return value; }\r
+ \r
+ public final int channels() { return (value >> CV_CN_SHIFT) + 1; }\r
+ \r
+ public final int depth() { return value & (CV_DEPTH_MAX-1); }\r
+ \r
+ public final boolean isInteger() { return depth() < CV_32F; }\r
+\r
+ public final int CV_ELEM_SIZE() { \r
+ int depth = value & (CV_DEPTH_MAX-1);\r
+ switch (depth) {\r
+ case CV_8U:\r
+ case CV_8S:\r
+ return channels();\r
+ case CV_16U:\r
+ case CV_16S:\r
+ return 2 * channels();\r
+ case CV_32S:\r
+ case CV_32F:\r
+ return 4 * channels();\r
+ case CV_64F:\r
+ return 8 * channels();\r
+ default:\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Unsupported CvType value: " + value );\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public final String toString() {\r
+ String s;\r
+ switch (depth()) {\r
+ case CV_8U:\r
+ s = "CV_8U";\r
+ break;\r
+ case CV_8S:\r
+ s = "CV_8S";\r
+ break;\r
+ case CV_16U:\r
+ s = "CV_16U";\r
+ break;\r
+ case CV_16S:\r
+ s = "CV_16S";\r
+ break;\r
+ case CV_32S:\r
+ s = "CV_32S";\r
+ break;\r
+ case CV_32F:\r
+ s = "CV_32F";\r
+ break;\r
+ case CV_64F:\r
+ s = "CV_64F";\r
+ break;\r
+ default:\r
+ s = "CV_USRTYPE1";\r
+ }\r
+ \r
+ return s + "(" + channels() + ")";\r
+ }\r
+ \r
+ // hashCode() has to be overridden if equals() is\r
+ @Override\r
+ public final int hashCode() { return value; }\r
+\r
+ @Override\r
+ public final boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if ( !(obj instanceof CvType) ) return false;\r
+ CvType other = (CvType) obj;\r
+ return value == other.value;\r
+ }\r
+ }\r
+\r
+ protected Mat(long nativeMat) {\r
+ /*if(nativeMat == 0) \r
+ throw new java.lang.UnsupportedOperationException("Native object address is NULL");*/\r
+ this.nativeObj = nativeMat;\r
+ }\r
+ \r
+ public Mat(int rows, int cols, CvType type) {\r
+ this( nCreateMat(rows, cols, type.toInt()) );\r
+ }\r
+\r
+ public Mat(int rows, int cols, CvType type, double v0, double v1, double v2, double v3) {\r
+ this( nCreateMat(rows, cols, type.toInt(), v0, v1, v2, v3) );\r
+ }\r
+\r
+ public Mat(int rows, int cols, CvType type, double v0, double v1, double v2) {\r
+ this( nCreateMat(rows, cols, type.toInt(), v0, v1, v2, 0) );\r
+ }\r
+\r
+ public Mat(int rows, int cols, CvType type, double v0, double v1) {\r
+ this( nCreateMat(rows, cols, type.toInt(), v0, v1, 0, 0) );\r
+ }\r
+\r
+ public Mat(int rows, int cols, CvType type, double v0) {\r
+ this( nCreateMat(rows, cols, type.toInt(), v0, 0, 0, 0) );\r
+ }\r
+\r
+ public void dispose() {\r
+ if(nativeObj != 0)\r
+ nDispose(nativeObj);\r
+ nativeObj = 0;\r
+ }\r
+ \r
+ @Override\r
+ protected void finalize() throws Throwable {\r
+ dispose();\r
+ super.finalize();\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ if(nativeObj == 0) return "Mat [ nativeObj=NULL ]";\r
+ return "Mat [ " +\r
+ rows() + "*" + cols() + "*" + type() + \r
+ ", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +\r
+ ", nativeObj=0x" + Long.toHexString(nativeObj) + \r
+ ", dataAddr=0x" + Long.toHexString(dataAddr()) + \r
+ " ]";\r
+ }\r
+ \r
+ public boolean empty() {\r
+ if(nativeObj == 0) return true;\r
+ return nIsEmpty(nativeObj); \r
+}\r
+\r
+ private void checkNull() {\r
+ if(nativeObj == 0) \r
+ throw new java.lang.UnsupportedOperationException("Native object address is NULL");\r
+ }\r
+ \r
+ public CvType type() {\r
+ checkNull();\r
+ return new CvType( nType(nativeObj) );\r
+ }\r
+ public int depth() { return type().depth(); }\r
+ public int channels() { return type().channels(); }\r
+ public int elemSize() { return type().CV_ELEM_SIZE(); }\r
+\r
+ public int rows() {\r
+ if(nativeObj == 0) \r
+ return 0;\r
+ return nRows(nativeObj);\r
+ }\r
+ public int height() { return rows(); }\r
+ public int cols() {\r
+ if(nativeObj == 0) \r
+ return 0;\r
+ return nCols(nativeObj);\r
+ }\r
+ public int width() { return cols(); }\r
+ public int total() { return rows() * cols(); }\r
+\r
+ public long dataAddr() {\r
+ if(nativeObj == 0) \r
+ return 0;\r
+ return nData(nativeObj);\r
+ }\r
+\r
+ public boolean isContinuous() {\r
+ if(nativeObj == 0) \r
+ return false; // maybe throw an exception instead?\r
+ return nIsCont(nativeObj);\r
+ }\r
+\r
+ public boolean isSubmatrix() {\r
+ if(nativeObj == 0) \r
+ return false; // maybe throw an exception instead?\r
+ return nIsSubmat(nativeObj);\r
+ }\r
+\r
+ public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd) {\r
+ checkNull();\r
+ return new Mat( nSubmat(nativeObj, rowStart, rowEnd, colStart, colEnd) );\r
+ }\r
+ public Mat rowRange(int start, int end) { return submat(start, end, 0, -1); }\r
+ public Mat row(int num) { return submat(num, num+1, 0, -1); }\r
+ public Mat colRange(int start, int end) { return submat(0, -1, start, end); }\r
+ public Mat col(int num) { return submat(0, -1, num, num+1); }\r
+ \r
+ public Mat clone() {\r
+ checkNull();\r
+ return new Mat( nClone(nativeObj) );\r
+ }\r
+ \r
+ public int put(int row, int col, double...data) {\r
+ checkNull();\r
+ if(data != null)\r
+ return nPutD(nativeObj, row, col, data.length, data);\r
+ else\r
+ return 0;\r
+ }\r
+ \r
+ public int put(int row, int col, float[] data) {\r
+ checkNull();\r
+ if(data != null) {\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_32F) {\r
+ return nPutF(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ } else return 0;\r
+ }\r
+ \r
+ public int put(int row, int col, int[] data) {\r
+ checkNull();\r
+ if(data != null) {\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_32S) {\r
+ return nPutI(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ } else return 0;\r
+ }\r
+ \r
+ public int put(int row, int col, short[] data) {\r
+ checkNull();\r
+ if(data != null) {\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_16U || t.depth() == CvType.CV_16S) {\r
+ return nPutS(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ } else return 0;\r
+ }\r
+ \r
+ public int put(int row, int col, byte[] data) {\r
+ checkNull();\r
+ if(data != null) {\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_8U || t.depth() == CvType.CV_8S) {\r
+ return nPutB(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ } else return 0;\r
+ }\r
+ \r
+ public int get(int row, int col, byte[] data) {\r
+ checkNull();\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_8U || t.depth() == CvType.CV_8S) {\r
+ return nGetB(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ }\r
+\r
+ public int get(int row, int col, short[] data) {\r
+ checkNull();\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_16U || t.depth() == CvType.CV_16S) {\r
+ return nGetS(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ }\r
+\r
+ public int get(int row, int col, int[] data) {\r
+ checkNull();\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_32S) {\r
+ return nGetI(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ }\r
+\r
+ public int get(int row, int col, float[] data) {\r
+ checkNull();\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_32F) {\r
+ return nGetF(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ }\r
+\r
+ public int get(int row, int col, double[] data) {\r
+ checkNull();\r
+ CvType t = type(); \r
+ if(t.depth() == CvType.CV_64F) {\r
+ return nGetD(nativeObj, row, col, data.length, data);\r
+ }\r
+ throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
+ }\r
+\r
+\r
+ public void setTo(double v0, double v1, double v2, double v3) {\r
+ checkNull();\r
+ nSetTo(nativeObj, v0, v1, v2, v3);\r
+ }\r
+ public void setTo(double v0, double v1, double v2) { setTo(v0, v1, v2, 0); }\r
+ public void setTo(double v0, double v1) { setTo(v0, v1, 0, 0); }\r
+ public void setTo(double v0) { setTo(v0, 0, 0, 0); }\r
+ \r
+ public void copyTo(Mat m) {\r
+ checkNull();\r
+ if(m.nativeObj == 0) \r
+ throw new java.lang.UnsupportedOperationException("Destination native object address is NULL");\r
+ nCopyTo(nativeObj, m.nativeObj);\r
+ }\r
+ \r
+ public double dot(Mat m) {\r
+ checkNull();\r
+ return nDot(nativeObj, m.nativeObj);\r
+ }\r
+ \r
+ public Mat cross(Mat m) {\r
+ checkNull();\r
+ return new Mat( nCross(nativeObj, m.nativeObj) );\r
+ }\r
+\r
+ public Mat inv() {\r
+ checkNull();\r
+ return new Mat( nInv(nativeObj) );\r
+ }\r
+ \r
+ public long getNativeObjAddr() {\r
+ return nativeObj;\r
+ }\r
+ \r
+ // native stuff\r
+ static { System.loadLibrary("opencv_java"); }\r
+ protected long nativeObj;\r
+ private static native long nCreateMat(int rows, int cols, int type);\r
+ private static native long nCreateMat(int rows, int cols, int type, double v0, double v1, double v2, double v3);\r
+ private static native void nDispose(long self);\r
+ private static native int nType(long self);\r
+ private static native int nRows(long self);\r
+ private static native int nCols(long self);\r
+ private static native long nData(long self);\r
+ private static native boolean nIsEmpty(long self);\r
+ private static native boolean nIsCont(long self);\r
+ private static native boolean nIsSubmat(long self);\r
+ private static native long nSubmat(long self, int rowStart, int rowEnd, int colStart, int colEnd);\r
+ private static native long nClone(long self);\r
+ private static native int nPutD(long self, int row, int col, int count, double[] data);\r
+ private static native int nPutF(long self, int row, int col, int count, float[] data);\r
+ private static native int nPutI(long self, int row, int col, int count, int[] data);\r
+ private static native int nPutS(long self, int row, int col, int count, short[] data);\r
+ private static native int nPutB(long self, int row, int col, int count, byte[] data);\r
+ private static native int nGetB(long self, int row, int col, int count, byte[] vals);\r
+ private static native int nGetS(long self, int row, int col, int count, short[] vals);\r
+ private static native int nGetI(long self, int row, int col, int count, int[] vals);\r
+ private static native int nGetF(long self, int row, int col, int count, float[] vals);\r
+ private static native int nGetD(long self, int row, int col, int count, double[] vals);\r
+ private static native void nSetTo(long self, double v0, double v1, double v2, double v3);\r
+ private static native void nCopyTo(long self, long mat);\r
+ private static native double nDot(long self, long mat);\r
+ private static native long nCross(long self, long mat);\r
+ private static native long nInv(long self);\r
+\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Point {\r
+ \r
+ public double x, y;\r
+ \r
+ public Point(double x, double y) {\r
+ this.x = x;\r
+ this.y = y;\r
+ }\r
+ \r
+ public Point() {\r
+ this(0, 0);\r
+ }\r
+\r
+ public Point clone() {\r
+ return new Point(x, y);\r
+ }\r
+ \r
+ public double dot(Point p) {\r
+ return x * p.x + y * p.y;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(x);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(y);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if ( ! (obj instanceof Point) ) return false;\r
+ Point it = (Point) obj;\r
+ return x == it.x && y == it.y;\r
+ }\r
+\r
+ public boolean inside(Rect r) {\r
+ return r.contains(this);\r
+ }\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Point3 {\r
+\r
+ public double x, y, z;\r
+\r
+ public Point3(double x, double y, double z) {\r
+ this.x = x;\r
+ this.y = y;\r
+ this.z = z;\r
+ }\r
+\r
+ public Point3() {\r
+ this(0, 0, 0);\r
+ }\r
+\r
+ public Point3(Point p) {\r
+ x = p.x;\r
+ y = p.y;\r
+ z = 0;\r
+ }\r
+\r
+ public Point3 clone() {\r
+ return new Point3(x, y, z);\r
+ }\r
+\r
+ public double dot(Point3 p) {\r
+ return x * p.x + y * p.y + z * p.z;\r
+ }\r
+\r
+ public Point3 cross(Point3 p) {\r
+ return new Point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(x);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(y);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(z);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof Point3)) return false;\r
+ Point3 it = (Point3) obj;\r
+ return x == it.x && y == it.y && z == it.z;\r
+ }\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Rect {\r
+ \r
+ int x, y, width, height;\r
+\r
+ public Rect(int x, int y, int width, int height) {\r
+ this.x = x;\r
+ this.y = y;\r
+ this.width = width;\r
+ this.height = height;\r
+ }\r
+\r
+ public Rect() {\r
+ this(0, 0, 0, 0);\r
+ }\r
+ \r
+ public Rect(Point p1, Point p2) {\r
+ x = (int) (p1.x < p2.x ? p1.x : p2.x); \r
+ y = (int) (p1.y < p2.y ? p1.y : p2.y);\r
+ width = (int) (p1.x > p2.x ? p1.x : p2.x) - x; \r
+ height = (int) (p1.y > p2.y ? p1.y : p2.y) - y;\r
+ }\r
+\r
+ public Rect(Point p, Size s) {\r
+ this((int)p.x, (int)p.y, s.width, s.height);\r
+ }\r
+ \r
+ public Rect clone() {\r
+ return new Rect(x, y, width, height);\r
+ }\r
+ \r
+ public Point tl() {\r
+ return new Point(x, y);\r
+ }\r
+\r
+ public Point br() {\r
+ return new Point(x + width, y + height);\r
+ }\r
+\r
+ public Size size() {\r
+ return new Size(width, height);\r
+ }\r
+\r
+ public double area() {\r
+ return width * height;\r
+ }\r
+\r
+ public boolean contains(Point p) {\r
+ return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(height);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(width);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(x);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(y);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof Rect)) return false;\r
+ Rect it = (Rect) obj;\r
+ return x == it.x && y == it.y && width == it.width && height == it.height;\r
+ }\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Scalar {\r
+ \r
+ public double v0, v1, v2, v3;\r
+\r
+ public Scalar(double v0, double v1, double v2, double v3) {\r
+ this.v0 = v0;\r
+ this.v1 = v1;\r
+ this.v2 = v2;\r
+ this.v3 = v3;\r
+ }\r
+\r
+ public Scalar(double v0, double v1, double v2) {\r
+ this(v0, v1, v2, 0);\r
+ }\r
+ \r
+ public Scalar(double v0, double v1) {\r
+ this(v0, v1, 0, 0);\r
+ }\r
+ \r
+ public Scalar(double v0) {\r
+ this(v0, 0, 0, 0);\r
+ }\r
+ \r
+ public static Scalar all(double v) {\r
+ return new Scalar(v, v, v, v);\r
+ }\r
+ \r
+ public Scalar clone() {\r
+ return new Scalar(v0, v1, v2, v3);\r
+ }\r
+\r
+ public Scalar mul(Scalar it, double scale) {\r
+ return new Scalar( v0 * it.v0 * scale, v1 * it.v1 * scale, \r
+ v2 * it.v2 * scale, v3 * it.v3 * scale );\r
+ }\r
+\r
+ public Scalar mul(Scalar it) {\r
+ return mul(it, 1);\r
+ }\r
+ public Scalar conj() {\r
+ return new Scalar(v0, -v1, -v2, -v3);\r
+ }\r
+\r
+ public boolean isReal() {\r
+ return v1 == 0 && v2 == 0 && v3 == 0;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(v0);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(v1);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(v2);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(v3);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof Scalar)) return false;\r
+ Scalar it = (Scalar) obj;\r
+ return v0 == it.v0 && v1 == it.v1 && v2 == it.v2 && v3 == it.v3;\r
+ }\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+public class Size {\r
+\r
+ public int width, height;\r
+\r
+ public Size(int width, int height) {\r
+ this.width = width;\r
+ this.height = height;\r
+ }\r
+ \r
+ public Size() {\r
+ this(0, 0);\r
+ }\r
+ \r
+ public Size(Point p) {\r
+ width = (int) p.x;\r
+ height = (int) p.y;\r
+ }\r
+ \r
+ public double area() {\r
+ return width * height;\r
+ }\r
+\r
+ public Size clone() {\r
+ return new Size(width, height);\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(height);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(width);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof Size)) return false;\r
+ Size it = (Size) obj;\r
+ return width == it.width && height == it.height;\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opencv;\r
+\r
+import android.graphics.Bitmap;\r
+\r
+public class utils {\r
+\r
+ public static Mat BitmapToMat(Bitmap b) {\r
+ return new Mat( nBitmapToMat(b) );\r
+ }\r
+ \r
+ public static boolean MatToBitmap(Mat m, Bitmap b) {\r
+ return nMatToBitmap(m.nativeObj, b); \r
+ }\r
+\r
+ // native stuff\r
+ static { System.loadLibrary("opencv_java"); }\r
+ private static native long nBitmapToMat(Bitmap b);\r
+ private static native boolean nMatToBitmap(long m, Bitmap b);\r
+}\r
projects / platform / upstream / opencv.git / commitdiff