Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

At-like function for Java/Kotlin

Browse Source
pull/20221/head
Giles Payne 4 years ago
parent 3e513ee6ab
commit 3b42e19505
9 changed files with 574 additions and 2 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      CMakeLists.txt
  2. 11
      cmake/android/android_gradle_projects.cmake
  3. 452
      modules/core/misc/java/src/java/core+Mat.java
  4. 99
      modules/core/misc/java/src/java/core+MatAt.kt
  5. 1
      modules/java/android_sdk/android_gradle_lib/build.gradle
  6. 1
      modules/java/android_sdk/build.gradle.in
  7. 4
      modules/java/generator/gen_java.py
  8. 6
      platforms/android/build_sdk.py
  9. 1
      samples/android/build.gradle.in

1
CMakeLists.txt
Unescape View File

@ -467,6 +467,7 @@ OCV_OPTION(BUILD_ANDROID_SERVICE "Build OpenCV Manager for Google Play" OFF I
OCV_OPTION(BUILD_CUDA_STUBS "Build CUDA modules stubs when no CUDA SDK" OFF IF (NOT APPLE_FRAMEWORK) )
OCV_OPTION(BUILD_JAVA "Enable Java support" (ANDROID OR NOT CMAKE_CROSSCOMPILING) IF (ANDROID OR (NOT APPLE_FRAMEWORK AND NOT WINRT)) )
OCV_OPTION(BUILD_OBJC "Enable Objective-C support" ON IF APPLE_FRAMEWORK )
OCV_OPTION(BUILD_KOTLIN_EXTENSIONS "Build Kotlin extensions (Android)" ON IF ANDROID )
# OpenCV installation options
# ===================================================

11
cmake/android/android_gradle_projects.cmake
Unescape View File

@ -2,6 +2,17 @@
set(ANDROID_GRADLE_PLUGIN_VERSION "3.2.1" CACHE STRING "Android Gradle Plugin version")
message(STATUS "Android Gradle Plugin version: ${ANDROID_GRADLE_PLUGIN_VERSION}")
set(KOTLIN_PLUGIN_VERSION "1.5.10" CACHE STRING "Kotlin Plugin version")
message(STATUS "kotlin Plugin version: ${KOTLIN_GRADLE_PLUGIN_VERSION}")
if(BUILD_KOTLIN_EXTENSIONS)
set(KOTLIN_PLUGIN_DECLARATION "apply plugin: 'kotlin-android'" CACHE STRING "Kotlin Plugin version")
set(KOTLIN_STD_LIB "implementation 'org.jetbrains.kotlin:kotlin-stdlib:${KOTLIN_PLUGIN_VERSION}'" CACHE STRING "Kotlin Standard Library dependency")
else()
set(KOTLIN_PLUGIN_DECLARATION "" CACHE STRING "Kotlin Plugin version")
set(KOTLIN_STD_LIB "" CACHE STRING "Kotlin Standard Library dependency")
endif()
set(GRADLE_VERSION "5.6.4" CACHE STRING "Gradle version")
message(STATUS "Gradle version: ${GRADLE_VERSION}")

452
modules/core/misc/java/src/java/core+Mat.java
Unescape View File

@ -1128,6 +1128,458 @@ public class Mat {
return cols();
}
// javadoc:Mat::at(clazz, row, col)
@SuppressWarnings("unchecked")
public <T> Atable<T> at(Class<T> clazz, int row, int col) {
if (clazz == Byte.class || clazz == byte.class) {
return (Atable<T>)new AtableByte(this, row, col);
} else if (clazz == Double.class || clazz == double.class) {
return (Atable<T>)new AtableDouble(this, row, col);
} else if (clazz == Float.class || clazz == float.class) {
return (Atable<T>)new AtableFloat(this, row, col);
} else if (clazz == Integer.class || clazz == int.class) {
return (Atable<T>)new AtableInteger(this, row, col);
} else if (clazz == Short.class || clazz == short.class) {
return (Atable<T>)new AtableShort(this, row, col);
} else {
throw new RuntimeException("Unsupported class type");
}
}
// javadoc:Mat::at(clazz, idx)
@SuppressWarnings("unchecked")
public <T> Atable<T> at(Class<T> clazz, int[] idx) {
if (clazz == Byte.class || clazz == byte.class) {
return (Atable<T>)new AtableByte(this, idx);
} else if (clazz == Double.class || clazz == double.class) {
return (Atable<T>)new AtableDouble(this, idx);
} else if (clazz == Float.class || clazz == float.class) {
return (Atable<T>)new AtableFloat(this, idx);
} else if (clazz == Integer.class || clazz == int.class) {
return (Atable<T>)new AtableInteger(this, idx);
} else if (clazz == Short.class || clazz == short.class) {
return (Atable<T>)new AtableShort(this, idx);
} else {
throw new RuntimeException("Unsupported class parameter");
}
}
public static class Tuple2<T> {
public Tuple2(T _0, T _1) {
this._0 = _0;
this._1 = _1;
}
public T get_0() {
return _0;
}
public T get_1() {
return _1;
}
private final T _0;
private final T _1;
}
public static class Tuple3<T> {
public Tuple3(T _0, T _1, T _2) {
this._0 = _0;
this._1 = _1;
this._2 = _2;
}
public T get_0() {
return _0;
}
public T get_1() {
return _1;
}
public T get_2() {
return _2;
}
private final T _0;
private final T _1;
private final T _2;
}
public static class Tuple4<T> {
public Tuple4(T _0, T _1, T _2, T _3) {
this._0 = _0;
this._1 = _1;
this._2 = _2;
this._3 = _3;
}
public T get_0() {
return _0;
}
public T get_1() {
return _1;
}
public T get_2() {
return _2;
}
public T get_3() {
return _3;
}
private final T _0;
private final T _1;
private final T _2;
private final T _3;
}
public interface Atable<T> {
T getV();
void setV(T v);
Tuple2<T> getV2c();
void setV2c(Tuple2<T> v);
Tuple3<T> getV3c();
void setV3c(Tuple3<T> v);
Tuple4<T> getV4c();
void setV4c(Tuple4<T> v);
}
private static class AtableBase {
protected AtableBase(Mat mat, int row, int col) {
this.mat = mat;
indices = new int[2];
indices[0] = row;
indices[1] = col;
}
protected AtableBase(Mat mat, int[] indices) {
this.mat = mat;
this.indices = indices;
}
protected final Mat mat;
protected final int[] indices;
}
private static class AtableByte extends AtableBase implements Atable<Byte> {
public AtableByte(Mat mat, int row, int col) {
super(mat, row, col);
}
public AtableByte(Mat mat, int[] indices) {
super(mat, indices);
}
@Override
public Byte getV() {
byte[] data = new byte[1];
mat.get(indices, data);
return data[0];
}
@Override
public void setV(Byte v) {
byte[] data = new byte[] { v };
mat.put(indices, data);
}
@Override
public Tuple2<Byte> getV2c() {
byte[] data = new byte[2];
mat.get(indices, data);
return new Tuple2<Byte>(data[0], data[1]);
}
@Override
public void setV2c(Tuple2<Byte> v) {
byte[] data = new byte[] { v._0, v._1 };
mat.put(indices, data);
}
@Override
public Tuple3<Byte> getV3c() {
byte[] data = new byte[3];
mat.get(indices, data);
return new Tuple3<Byte>(data[0], data[1], data[2]);
}
@Override
public void setV3c(Tuple3<Byte> v) {
byte[] data = new byte[] { v._0, v._1, v._2 };
mat.put(indices, data);
}
@Override
public Tuple4<Byte> getV4c() {
byte[] data = new byte[4];
mat.get(indices, data);
return new Tuple4<Byte>(data[0], data[1], data[2], data[3]);
}
@Override
public void setV4c(Tuple4<Byte> v) {
byte[] data = new byte[] { v._0, v._1, v._2, v._3 };
mat.put(indices, data);
}
}
private static class AtableDouble extends AtableBase implements Atable<Double> {
public AtableDouble(Mat mat, int row, int col) {
super(mat, row, col);
}
public AtableDouble(Mat mat, int[] indices) {
super(mat, indices);
}
@Override
public Double getV() {
double[] data = new double[1];
mat.get(indices, data);
return data[0];
}
@Override
public void setV(Double v) {
double[] data = new double[] { v };
mat.put(indices, data);
}
@Override
public Tuple2<Double> getV2c() {
double[] data = new double[2];
mat.get(indices, data);
return new Tuple2<Double>(data[0], data[1]);
}
@Override
public void setV2c(Tuple2<Double> v) {
double[] data = new double[] { v._0, v._1 };
mat.put(indices, data);
}
@Override
public Tuple3<Double> getV3c() {
double[] data = new double[3];
mat.get(indices, data);
return new Tuple3<Double>(data[0], data[1], data[2]);
}
@Override
public void setV3c(Tuple3<Double> v) {
double[] data = new double[] { v._0, v._1, v._2 };
mat.put(indices, data);
}
@Override
public Tuple4<Double> getV4c() {
double[] data = new double[4];
mat.get(indices, data);
return new Tuple4<Double>(data[0], data[1], data[2], data[3]);
}
@Override
public void setV4c(Tuple4<Double> v) {
double[] data = new double[] { v._0, v._1, v._2, v._3 };
mat.put(indices, data);
}
}
private static class AtableFloat extends AtableBase implements Atable<Float> {
public AtableFloat(Mat mat, int row, int col) {
super(mat, row, col);
}
public AtableFloat(Mat mat, int[] indices) {
super(mat, indices);
}
@Override
public Float getV() {
float[] data = new float[1];
mat.get(indices, data);
return data[0];
}
@Override
public void setV(Float v) {
float[] data = new float[] { v };
mat.put(indices, data);
}
@Override
public Tuple2<Float> getV2c() {
float[] data = new float[2];
mat.get(indices, data);
return new Tuple2<Float>(data[0], data[1]);
}
@Override
public void setV2c(Tuple2<Float> v) {
float[] data = new float[] { v._0, v._1 };
mat.put(indices, data);
}
@Override
public Tuple3<Float> getV3c() {
float[] data = new float[3];
mat.get(indices, data);
return new Tuple3<Float>(data[0], data[1], data[2]);
}
@Override
public void setV3c(Tuple3<Float> v) {
float[] data = new float[] { v._0, v._1, v._2 };
mat.put(indices, data);
}
@Override
public Tuple4<Float> getV4c() {
float[] data = new float[4];
mat.get(indices, data);
return new Tuple4<Float>(data[0], data[1], data[2], data[3]);
}
@Override
public void setV4c(Tuple4<Float> v) {
double[] data = new double[] { v._0, v._1, v._2, v._3 };
mat.put(indices, data);
}
}
private static class AtableInteger extends AtableBase implements Atable<Integer> {
public AtableInteger(Mat mat, int row, int col) {
super(mat, row, col);
}
public AtableInteger(Mat mat, int[] indices) {
super(mat, indices);
}
@Override
public Integer getV() {
int[] data = new int[1];
mat.get(indices, data);
return data[0];
}
@Override
public void setV(Integer v) {
int[] data = new int[] { v };
mat.put(indices, data);
}
@Override
public Tuple2<Integer> getV2c() {
int[] data = new int[2];
mat.get(indices, data);
return new Tuple2<Integer>(data[0], data[1]);
}
@Override
public void setV2c(Tuple2<Integer> v) {
int[] data = new int[] { v._0, v._1 };
mat.put(indices, data);
}
@Override
public Tuple3<Integer> getV3c() {
int[] data = new int[3];
mat.get(indices, data);
return new Tuple3<Integer>(data[0], data[1], data[2]);
}
@Override
public void setV3c(Tuple3<Integer> v) {
int[] data = new int[] { v._0, v._1, v._2 };
mat.put(indices, data);
}
@Override
public Tuple4<Integer> getV4c() {
int[] data = new int[4];
mat.get(indices, data);
return new Tuple4<Integer>(data[0], data[1], data[2], data[3]);
}
@Override
public void setV4c(Tuple4<Integer> v) {
int[] data = new int[] { v._0, v._1, v._2, v._3 };
mat.put(indices, data);
}
}
private static class AtableShort extends AtableBase implements Atable<Short> {
public AtableShort(Mat mat, int row, int col) {
super(mat, row, col);
}
public AtableShort(Mat mat, int[] indices) {
super(mat, indices);
}
@Override
public Short getV() {
short[] data = new short[1];
mat.get(indices, data);
return data[0];
}
@Override
public void setV(Short v) {
short[] data = new short[] { v };
mat.put(indices, data);
}
@Override
public Tuple2<Short> getV2c() {
short[] data = new short[2];
mat.get(indices, data);
return new Tuple2<Short>(data[0], data[1]);
}
@Override
public void setV2c(Tuple2<Short> v) {
short[] data = new short[] { v._0, v._1 };
mat.put(indices, data);
}
@Override
public Tuple3<Short> getV3c() {
short[] data = new short[3];
mat.get(indices, data);
return new Tuple3<Short>(data[0], data[1], data[2]);
}
@Override
public void setV3c(Tuple3<Short> v) {
short[] data = new short[] { v._0, v._1, v._2 };
mat.put(indices, data);
}
@Override
public Tuple4<Short> getV4c() {
short[] data = new short[4];
mat.get(indices, data);
return new Tuple4<Short>(data[0], data[1], data[2], data[3]);
}
@Override
public void setV4c(Tuple4<Short> v) {
short[] data = new short[] { v._0, v._1, v._2, v._3 };
mat.put(indices, data);
}
}
// javadoc:Mat::getNativeObjAddr()
public long getNativeObjAddr() {
return nativeObj;

99
modules/core/misc/java/src/java/core+MatAt.kt
Unescape View File

@ -0,0 +1,99 @@
package org.opencv.core
import org.opencv.core.Mat.*
import java.lang.RuntimeException
/***
* Example use:
*
* val (b, g, r) = mat.at<UByte>(50, 50).v3c
* mat.at<UByte>(50, 50).val = T3(245u, 113u, 34u)
*
*/
@Suppress("UNCHECKED_CAST")
inline fun <reified T> Mat.at(row: Int, col: Int) : Atable<T> =
when (T::class) {
Byte::class, Double::class, Float::class, Int::class, Short::class -> this.at(
T::class.java,
row,
col
)
UByte::class -> AtableUByte(this, row, col) as Atable<T>
else -> throw RuntimeException("Unsupported class type")
}
@Suppress("UNCHECKED_CAST")
inline fun <reified T> Mat.at(idx: IntArray) : Atable<T> =
when (T::class) {
Byte::class, Double::class, Float::class, Int::class, Short::class -> this.at(
T::class.java,
idx
)
UByte::class -> AtableUByte(this, idx) as Atable<T>
else -> throw RuntimeException("Unsupported class type")
}
class AtableUByte(val mat: Mat, val indices: IntArray): Atable<UByte> {
constructor(mat: Mat, row: Int, col: Int) : this(mat, intArrayOf(row, col))
override fun getV(): UByte {
val data = ByteArray(1)
mat[indices, data]
return data[0].toUByte()
}
override fun setV(v: UByte) {
val data = byteArrayOf(v.toByte())
mat.put(indices, data)
}
override fun getV2c(): Tuple2<UByte> {
val data = ByteArray(2)
mat[indices, data]
return Tuple2(data[0].toUByte(), data[1].toUByte())
}
override fun setV2c(v: Tuple2<UByte>) {
val data = byteArrayOf(v._0.toByte(), v._1.toByte())
mat.put(indices, data)
}
override fun getV3c(): Tuple3<UByte> {
val data = ByteArray(3)
mat[indices, data]
return Tuple3(data[0].toUByte(), data[1].toUByte(), data[2].toUByte())
}
override fun setV3c(v: Tuple3<UByte>) {
val data = byteArrayOf(v._0.toByte(), v._1.toByte(), v._2.toByte())
mat.put(indices, data)
}
override fun getV4c(): Tuple4<UByte> {
val data = ByteArray(4)
mat[indices, data]
return Tuple4(data[0].toUByte(), data[1].toUByte(), data[2].toUByte(), data[3].toUByte())
}
override fun setV4c(v: Tuple4<UByte>) {
val data = byteArrayOf(v._0.toByte(), v._1.toByte(), v._2.toByte(), v._3.toByte())
mat.put(indices, data)
}
}
operator fun <T> Tuple2<T>.component1(): T = this._0
operator fun <T> Tuple2<T>.component2(): T = this._1
operator fun <T> Tuple3<T>.component1(): T = this._0
operator fun <T> Tuple3<T>.component2(): T = this._1
operator fun <T> Tuple3<T>.component3(): T = this._2
operator fun <T> Tuple4<T>.component1(): T = this._0
operator fun <T> Tuple4<T>.component2(): T = this._1
operator fun <T> Tuple4<T>.component3(): T = this._2
operator fun <T> Tuple4<T>.component4(): T = this._3
fun <T> T2(_0: T, _1: T) : Tuple2<T> = Tuple2(_0, _1)
fun <T> T3(_0: T, _1: T, _2: T) : Tuple3<T> = Tuple3(_0, _1, _2)
fun <T> T4(_0: T, _1: T, _2: T, _3: T) : Tuple4<T> = Tuple4(_0, _1, _2, _3)

1
modules/java/android_sdk/android_gradle_lib/build.gradle
Unescape View File

@ -1,4 +1,5 @@
apply plugin: 'com.android.library'
@KOTLIN_PLUGIN_DECLARATION@
def openCVersionName = "@OPENCV_VERSION@"
def openCVersionCode = ((@OPENCV_VERSION_MAJOR@ * 100 + @OPENCV_VERSION_MINOR@) * 100 + @OPENCV_VERSION_PATCH@) * 10 + 0

1
modules/java/android_sdk/build.gradle.in
Unescape View File

@ -89,6 +89,7 @@
//
apply plugin: 'com.android.library'
@KOTLIN_PLUGIN_DECLARATION@
def openCVersionName = "@OPENCV_VERSION@"
def openCVersionCode = ((@OPENCV_VERSION_MAJOR@ * 100 + @OPENCV_VERSION_MINOR@) * 100 + @OPENCV_VERSION_PATCH@) * 10 + 0

4
modules/java/generator/gen_java.py
Unescape View File

@ -1236,13 +1236,13 @@ JNIEXPORT void JNICALL Java_org_opencv_%(module)s_%(j_cls)s_delete
def copy_java_files(java_files_dir, java_base_path, default_package_path='org/opencv/'):
global total_files, updated_files
java_files = []
re_filter = re.compile(r'^.+\.(java|aidl)(.in)?$')
re_filter = re.compile(r'^.+\.(java|aidl|kt)(.in)?$')
for root, dirnames, filenames in os.walk(java_files_dir):
java_files += [os.path.join(root, filename) for filename in filenames if re_filter.match(filename)]
java_files = [f.replace('\\', '/') for f in java_files]
re_package = re.compile(r'^package +(.+);')
re_prefix = re.compile(r'^.+[\+/]([^\+]+).(java|aidl)(.in)?$')
re_prefix = re.compile(r'^.+[\+/]([^\+]+).(java|aidl|kt)(.in)?$')
for java_file in java_files:
src = checkFileRemap(java_file)
with open(src, 'r') as f:

6
platforms/android/build_sdk.py
Unescape View File

@ -159,6 +159,7 @@ class Builder:
self.debug_info = True if config.debug_info else False
self.no_samples_build = True if config.no_samples_build else False
self.opencl = True if config.opencl else False
self.no_kotlin = True if config.no_kotlin else False
def get_cmake(self):
if not self.config.use_android_buildtools and check_executable(['cmake', '--version']):
@ -219,6 +220,7 @@ class Builder:
CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(),
INSTALL_CREATE_DISTRIB="ON",
WITH_OPENCL="OFF",
BUILD_KOTLIN_EXTENSIONS="ON",
WITH_IPP=("ON" if abi.haveIPP() else "OFF"),
WITH_TBB="ON",
BUILD_EXAMPLES="OFF",
@ -240,6 +242,9 @@ class Builder:
if self.opencl:
cmake_vars['WITH_OPENCL'] = "ON"
if self.no_kotlin:
cmake_vars['BUILD_KOTLIN_EXTENSIONS'] = "OFF"
if self.config.modules_list is not None:
cmd.append("-DBUILD_LIST='%s'" % self.config.modules_list)
@ -359,6 +364,7 @@ if __name__ == "__main__":
parser.add_argument('--debug_info', action="store_true", help="Build with debug information (useful for Release mode: BUILD_WITH_DEBUG_INFO=ON)")
parser.add_argument('--no_samples_build', action="store_true", help="Do not build samples (speeds up build)")
parser.add_argument('--opencl', action="store_true", help="Enable OpenCL support")
parser.add_argument('--no_kotlin', action="store_true", help="Disable Kotlin extensions")
args = parser.parse_args()
log.basicConfig(format='%(message)s', level=log.DEBUG)

1
samples/android/build.gradle.in
Unescape View File

@ -8,6 +8,7 @@ buildscript {
}
dependencies {
classpath 'com.android.tools.build:gradle:@ANDROID_GRADLE_PLUGIN_VERSION@'
classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:@KOTLIN_PLUGIN_VERSION@'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files

Write Preview
Loading…
Cancel
Save