mirror of
https://github.com/opencv/opencv.git
synced 2026-07-29 07:13:02 +04:00
merged 2.4 into trunk
This commit is contained in:
Vadim Pisarevsky
+26
-22
@@ -6,7 +6,7 @@ if(NOT ANDROID OR NOT PYTHON_EXECUTABLE OR ANDROID_NATIVE_API_LEVEL LESS 8)
|
||||
endif()
|
||||
|
||||
set(the_description "The java bindings")
|
||||
ocv_add_module(java BINDINGS opencv_core opencv_imgproc OPTIONAL opencv_objdetect opencv_features2d opencv_video opencv_highgui opencv_ml opencv_calib3d opencv_photo)
|
||||
ocv_add_module(java BINDINGS opencv_core opencv_imgproc OPTIONAL opencv_objdetect opencv_features2d opencv_video opencv_highgui opencv_ml opencv_calib3d opencv_photo opencv_nonfree)
|
||||
ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cpp")
|
||||
|
||||
# get list of modules to wrap
|
||||
@@ -56,23 +56,25 @@ foreach(module ${OPENCV_JAVA_MODULES})
|
||||
endforeach()
|
||||
|
||||
# first run (to get list of generated files)
|
||||
file(REMOVE_RECURSE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/")
|
||||
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out")
|
||||
execute_process(COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_headers}
|
||||
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out"
|
||||
OUTPUT_QUIET ERROR_QUIET)
|
||||
file(GLOB_RECURSE ${module}_generated_java_sources RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/" "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/*.java")
|
||||
ocv_list_add_prefix(${module}_generated_java_sources "${CMAKE_CURRENT_BINARY_DIR}/")
|
||||
if(module_headers)
|
||||
file(REMOVE_RECURSE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/")
|
||||
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out")
|
||||
execute_process(COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_headers}
|
||||
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out"
|
||||
OUTPUT_QUIET ERROR_QUIET)
|
||||
file(GLOB_RECURSE ${module}_generated_java_sources RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/" "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/*.java")
|
||||
ocv_list_add_prefix(${module}_generated_java_sources "${CMAKE_CURRENT_BINARY_DIR}/")
|
||||
|
||||
# second run (at build time)
|
||||
add_custom_command(OUTPUT ${${module}_generated_java_sources} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp"
|
||||
COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_headers}
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
||||
DEPENDS "${GEN_JAVA}" "${HDR_PARSER}" ${module_headers})
|
||||
# second run (at build time)
|
||||
add_custom_command(OUTPUT ${${module}_generated_java_sources} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp"
|
||||
COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_headers}
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
||||
DEPENDS "${GEN_JAVA}" "${HDR_PARSER}" ${module_headers})
|
||||
|
||||
list(APPEND java_hdr_deps ${module_headers})
|
||||
list(APPEND generated_cpp_sources "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp")
|
||||
list(APPEND generated_java_sources ${${module}_generated_java_sources})
|
||||
list(APPEND java_hdr_deps ${module_headers})
|
||||
list(APPEND generated_cpp_sources "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp")
|
||||
list(APPEND generated_java_sources ${${module}_generated_java_sources})
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# get handwritten files used for wrappers generation
|
||||
@@ -183,12 +185,13 @@ if(ANDROID)
|
||||
|
||||
# manifest, jni, Eclipse project
|
||||
file(GLOB_RECURSE android_lib_project_files RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/android/" "${CMAKE_CURRENT_SOURCE_DIR}/android/*")
|
||||
list(REMOVE_ITEM android_lib_project_files "${ANDROID_MANIFEST_FILE}")
|
||||
foreach(f ${android_lib_project_files})
|
||||
if(NOT f MATCHES "\\.svn")
|
||||
add_custom_command(
|
||||
OUTPUT "${OpenCV_BINARY_DIR}/${f}"
|
||||
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/android/${f}" "${OpenCV_BINARY_DIR}/${f}"
|
||||
DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/android/${f}"
|
||||
MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/android/${f}"
|
||||
COMMENT "Generating ${f}"
|
||||
)
|
||||
|
||||
@@ -222,14 +225,17 @@ if(ANDROID)
|
||||
android_get_compatible_target(lib_target_sdk_target ${ANDROID_NATIVE_API_LEVEL} ${ANDROID_SDK_TARGET})
|
||||
|
||||
add_custom_command(
|
||||
OUTPUT ${lib_target_files}
|
||||
OUTPUT ${lib_target_files} "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}"
|
||||
COMMAND ${CMAKE_COMMAND} -E remove ${lib_target_files}
|
||||
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/android/${ANDROID_MANIFEST_FILE}" "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}"
|
||||
COMMAND ${ANDROID_EXECUTABLE} --silent create lib-project --path \"${OpenCV_BINARY_DIR}\" --target \"${lib_target_sdk_target}\" --name OpenCV --package org.opencv 2>\"${CMAKE_CURRENT_BINARY_DIR}/create_lib_project.log\"
|
||||
MAIN_DEPENDENCY "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}"
|
||||
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/android/${ANDROID_MANIFEST_FILE}" "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}"
|
||||
MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/android/${ANDROID_MANIFEST_FILE}"
|
||||
DEPENDS ${lib_proj_files}
|
||||
COMMENT "Generating OpenCV Android library project. SDK target: ${lib_target_sdk_target}"
|
||||
)
|
||||
install(FILES "${OpenCV_BINARY_DIR}/${ANDROID_PROJECT_PROPERTIES_FILE}" DESTINATION . COMPONENT main)
|
||||
install(FILES "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}" DESTINATION . COMPONENT main)
|
||||
|
||||
if(ANT_EXECUTABLE AND ANDROID_TOOLS_Pkg_Revision GREATER 13)
|
||||
# build the library project
|
||||
@@ -247,9 +253,7 @@ if(ANDROID)
|
||||
list(APPEND lib_target_files "${OpenCV_BINARY_DIR}/bin/classes.jar")
|
||||
endif()
|
||||
|
||||
add_custom_target(${lib_target}
|
||||
SOURCES ${lib_proj_files} ${lib_target_files}
|
||||
)
|
||||
add_custom_target(${lib_target} SOURCES ${lib_proj_files} ${lib_target_files} "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}")
|
||||
|
||||
add_dependencies(${lib_target} ${api_target})
|
||||
add_dependencies(${the_module} ${lib_target})
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<projectDescription>
|
||||
<name>OpenCV-2.4.beta</name>
|
||||
<name>OpenCV-2.4.0</name>
|
||||
<comment></comment>
|
||||
<projects>
|
||||
</projects>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
package="org.opencv"
|
||||
android:versionCode="1"
|
||||
android:versionName="1.0">
|
||||
android:versionCode="240"
|
||||
android:versionName="2.4.0">
|
||||
</manifest>
|
||||
|
||||
@@ -23,10 +23,12 @@ public class UtilsTest extends OpenCVTestCase {
|
||||
Bitmap bmp16 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt16);
|
||||
Mat m16 = new Mat();
|
||||
Utils.bitmapToMat(bmp16, m16);
|
||||
assertTrue(m16.rows() == 512 && m16.cols() == 512 && m16.type() == CvType.CV_8UC4);
|
||||
|
||||
BitmapFactory.Options opt32 = new BitmapFactory.Options();
|
||||
/*BitmapFactory.Options opt32 = new BitmapFactory.Options();
|
||||
opt32.inPreferredConfig = Bitmap.Config.ARGB_8888;
|
||||
Bitmap bmp32 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt32);
|
||||
Bitmap bmp32 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt32);*/
|
||||
Bitmap bmp32 = bmp16.copy(Bitmap.Config.ARGB_8888, false);
|
||||
Mat m32 = new Mat();
|
||||
Utils.bitmapToMat(bmp32, m32);
|
||||
|
||||
@@ -34,6 +36,7 @@ public class UtilsTest extends OpenCVTestCase {
|
||||
|
||||
double maxDiff = Core.norm(m16, m32, Core.NORM_INF);
|
||||
Log.d("Bmp->Mat", "bmp16->Mat vs bmp32->Mat diff = " + maxDiff);
|
||||
|
||||
assertTrue(maxDiff <= 8 /* 8 == 2^8 / 2^5 */);
|
||||
}
|
||||
|
||||
|
||||
@@ -4,6 +4,7 @@ import org.opencv.calib3d.Calib3d;
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfDouble;
|
||||
import org.opencv.core.MatOfPoint2f;
|
||||
import org.opencv.core.MatOfPoint3f;
|
||||
import org.opencv.core.Point;
|
||||
@@ -174,15 +175,17 @@ public class Calib3dTest extends OpenCVTestCase {
|
||||
|
||||
public void testFindChessboardCornersMatSizeMat() {
|
||||
Size patternSize = new Size(9, 6);
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, dst);
|
||||
assertTrue(!dst.empty());
|
||||
MatOfPoint2f corners = new MatOfPoint2f();
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, corners);
|
||||
assertTrue(!corners.empty());
|
||||
}
|
||||
|
||||
public void testFindChessboardCornersMatSizeMatInt() {
|
||||
Size patternSize = new Size(9, 6);
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, dst, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
|
||||
MatOfPoint2f corners = new MatOfPoint2f();
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, corners, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
|
||||
+ Calib3d.CALIB_CB_FAST_CHECK);
|
||||
assertTrue(!dst.empty());
|
||||
assertTrue(!corners.empty());
|
||||
}
|
||||
|
||||
public void testFindCirclesGridDefaultMatSizeMat() {
|
||||
@@ -515,7 +518,7 @@ public class Calib3dTest extends OpenCVTestCase {
|
||||
|
||||
Mat rvec = new Mat();
|
||||
Mat tvec = new Mat();
|
||||
Calib3d.solvePnP(points3d, points2d, intrinsics, new Mat(), rvec, tvec);
|
||||
Calib3d.solvePnP(points3d, points2d, intrinsics, new MatOfDouble(), rvec, tvec);
|
||||
|
||||
Mat truth_rvec = new Mat(3, 1, CvType.CV_64F);
|
||||
truth_rvec.put(0, 0, 0, Math.PI / 2, 0);
|
||||
|
||||
@@ -1284,14 +1284,14 @@ public class CoreTest extends OpenCVTestCase {
|
||||
rgba0.setTo(new Scalar(10, 20, 30, 40));
|
||||
List<Mat> src = Arrays.asList(rgba0);
|
||||
List<Mat> dst = Arrays.asList(gray3, gray2, gray1, gray0, getMat(CvType.CV_8UC3, 0, 0, 0));
|
||||
MatOfInt fromTo = new MatOfInt(1, new int[]
|
||||
{ 3, 0,
|
||||
MatOfInt fromTo = new MatOfInt(
|
||||
3, 0,
|
||||
3, 1,
|
||||
2, 2,
|
||||
0, 3,
|
||||
2, 4,
|
||||
1, 5,
|
||||
0, 6 }
|
||||
0, 6
|
||||
);
|
||||
|
||||
Core.mixChannels(src, dst, fromTo);
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
package org.opencv.test.core;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvException;
|
||||
import org.opencv.core.CvType;
|
||||
@@ -11,8 +13,6 @@ import org.opencv.core.Scalar;
|
||||
import org.opencv.core.Size;
|
||||
import org.opencv.test.OpenCVTestCase;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
public class MatTest extends OpenCVTestCase {
|
||||
|
||||
public void testAdjustROI() {
|
||||
@@ -272,21 +272,72 @@ public class MatTest extends OpenCVTestCase {
|
||||
assertEquals(5, Core.countNonZero(eye));
|
||||
|
||||
}
|
||||
|
||||
public Mat getTestMat(int size, int type) {
|
||||
Mat m = new Mat(size, size, type);
|
||||
final int ch = CvType.channels(type);
|
||||
double buff[] = new double[size*size * ch];
|
||||
for(int i=0; i<size; i++)
|
||||
for(int j=0; j<size; j++)
|
||||
for(int k=0; k<ch; k++) {
|
||||
buff[i*size*ch + j*ch + k] = 100*i + 10*j + k;
|
||||
}
|
||||
m.put(0, 0, buff);
|
||||
return m;
|
||||
}
|
||||
|
||||
public void testGetIntInt() {
|
||||
Mat src = new Mat(3, 3, CvType.CV_8U, new Scalar(2));
|
||||
double[] actualArray = src.get(1, 1);
|
||||
public void testGetIntInt_8U() {
|
||||
Mat m = getTestMat(5, CvType.CV_8UC2);
|
||||
|
||||
assertTrue(Arrays.equals(new double[] { 2 }, actualArray));
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0, 1}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240, 241}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {255, 255}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230, 231}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {255, 255}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntInt_32S() {
|
||||
Mat m = getTestMat(5, CvType.CV_32SC3);
|
||||
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0, 1, 2}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240, 241, 242}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {440, 441, 442}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230, 231, 232}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {340, 341, 342}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntInt_64F() {
|
||||
Mat m = getTestMat(5, CvType.CV_64FC1);
|
||||
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {440}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {340}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntIntByteArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat m = getTestMat(5, CvType.CV_8UC3);
|
||||
byte[] goodData = new byte[9];
|
||||
byte[] badData = new byte[7];
|
||||
m.get(1, 1, goodData);
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, goodData);
|
||||
|
||||
assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 }, goodData));
|
||||
assertEquals(9, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] { 110, 111, 112, 120, 121, 122, (byte) 130, (byte) 131, (byte) 132 }, goodData));
|
||||
|
||||
try {
|
||||
m.get(2, 2, badData);
|
||||
@@ -294,38 +345,105 @@ public class MatTest extends OpenCVTestCase {
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// expected
|
||||
}
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte buff00[] = new byte[3];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(3, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] {(byte) 230, (byte) 231, (byte) 232}, buff00));
|
||||
byte buff11[] = new byte[3];
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(3, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] {(byte) 255, (byte) 255, (byte) 255}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntDoubleArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_64F);
|
||||
double[] doubleArray = { 1.0, 2.0, 3.0 };
|
||||
Mat m = getTestMat(5, CvType.CV_64F);
|
||||
double buff[] = new double[4];
|
||||
|
||||
int numOfBytes = src.get(0, 0, doubleArray);
|
||||
assertEquals(24, numOfBytes);
|
||||
}
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
assertEquals(32, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] { 110, 120, 130, 140 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
double buff00[] = new double[2];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] {230, 240}, buff00));
|
||||
double buff11[] = new double[] {0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] {340, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntFloatArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_32F);
|
||||
float[] floatArray = { 3.0f, 1.0f, 4.0f };
|
||||
Mat m = getTestMat(5, CvType.CV_32F);
|
||||
float buff[] = new float[4];
|
||||
|
||||
int numOfBytes = src.get(0, 0, floatArray);
|
||||
assertEquals(12, numOfBytes);
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] { 110, 120, 130, 140 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
float buff00[] = new float[2];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] {230, 240}, buff00));
|
||||
float buff11[] = new float[] {0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(4, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] {340, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntIntArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_32S);
|
||||
int[] intArray = { 3, 1, 4, 7 };
|
||||
Mat m = getTestMat(5, CvType.CV_32SC2);
|
||||
int[] buff = new int[6];
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
int numOfBytes = src.get(0, 0, intArray);
|
||||
assertEquals(16, numOfBytes);
|
||||
assertEquals(24, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] { 110, 111, 120, 121, 130, 131 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
int buff00[] = new int[4];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] {230, 231, 240, 241}, buff00));
|
||||
int buff11[] = new int[]{0, 0, 0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] {340, 341, 0, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntShortArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_16U);
|
||||
short[] data = { 3, 1, 4, 7 };
|
||||
Mat m = getTestMat(5, CvType.CV_16SC2);
|
||||
short[] buff = new short[6];
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
int numOfBytes = src.get(1, 1, data);
|
||||
assertEquals(2, numOfBytes);
|
||||
assertEquals(12, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] { 110, 111, 120, 121, 130, 131 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
short buff00[] = new short[4];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] {230, 231, 240, 241}, buff00));
|
||||
short buff11[] = new short[]{0, 0, 0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(4, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] {340, 341, 0, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetNativeObjAddr() {
|
||||
@@ -528,9 +646,33 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntByteArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3);
|
||||
byte[] bytes = new byte[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, bytes);
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };
|
||||
byte[] buff0 = new byte[] { 10, 20, 30, 40, 50, 60 };
|
||||
byte[] buff1 = new byte[] { -1, -2, -3, -4, -5, -6 };
|
||||
|
||||
int bytesNum = m.put(1, 2, buff0);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = m.get(1, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff0));
|
||||
|
||||
bytesNum = sm.put(0, 0, buff1);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = sm.get(0, 0, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff1));
|
||||
bytesNum = m.get(2, 3, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff1));
|
||||
|
||||
Mat m1 = m.row(1);
|
||||
bytesNum = m1.get(0, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff0));
|
||||
|
||||
try {
|
||||
byte[] bytes2 = new byte[] { 10, 20, 30, 40, 50 };
|
||||
@@ -542,21 +684,41 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntDoubleArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3);
|
||||
m.put(1, 1, 10, 20, 30, 40, 50, 60);
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
int bytesNum = m.put(1, 2, 10, 20, 30, 40, 50, 60);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = m.get(1, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{10, 20, 30, 40, 50, 60}));
|
||||
|
||||
try {
|
||||
m.put(2, 2, 11, 22, 33, 44, 55);
|
||||
fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// expected
|
||||
}
|
||||
bytesNum = sm.put(0, 0, 255, 254, 253, 252, 251, 250);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = sm.get(0, 0, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));
|
||||
bytesNum = m.get(2, 3, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));
|
||||
}
|
||||
|
||||
public void testPutIntIntFloatArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_32FC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_32FC3, new Scalar(1, 2, 3));
|
||||
float[] elements = new float[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(4, 3, elements);
|
||||
|
||||
assertEquals(elements.length * 4, bytesNum);
|
||||
Mat m1 = m.row(4);
|
||||
float buff[] = new float[3];
|
||||
bytesNum = m1.get(0, 4, buff);
|
||||
assertEquals(buff.length * 4, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[]{40, 50, 60}, buff));
|
||||
assertArrayEquals(new double[]{10, 20, 30}, m.get(4, 3), EPS);
|
||||
|
||||
try {
|
||||
float[] elements2 = new float[] { 10, 20, 30, 40, 50 };
|
||||
@@ -568,9 +730,18 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntIntArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_32SC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_32SC3, new Scalar(-1, -2, -3));
|
||||
int[] elements = new int[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(0, 4, elements);
|
||||
|
||||
assertEquals(elements.length * 4, bytesNum);
|
||||
Mat m1 = m.col(4);
|
||||
int buff[] = new int[3];
|
||||
bytesNum = m1.get(0, 0, buff);
|
||||
assertEquals(buff.length * 4, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[]{10, 20, 30}, buff));
|
||||
assertArrayEquals(new double[]{40, 50, 60}, m.get(1, 0), EPS);
|
||||
|
||||
try {
|
||||
int[] elements2 = new int[] { 10, 20, 30, 40, 50 };
|
||||
@@ -582,9 +753,17 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntShortArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_16SC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_16SC3, new Scalar(-1, -2, -3));
|
||||
short[] elements = new short[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(2, 3, elements);
|
||||
|
||||
assertEquals(elements.length * 2, bytesNum);
|
||||
Mat m1 = m.col(3);
|
||||
short buff[] = new short[3];
|
||||
bytesNum = m1.get(2, 0, buff);
|
||||
assertTrue(Arrays.equals(new short[]{10, 20, 30}, buff));
|
||||
assertArrayEquals(new double[]{40, 50, 60}, m.get(2, 4), EPS);
|
||||
|
||||
try {
|
||||
short[] elements2 = new short[] { 10, 20, 30, 40, 50 };
|
||||
@@ -692,6 +871,15 @@ public class MatTest extends OpenCVTestCase {
|
||||
assertMatEqual(gray127, gray0);
|
||||
}
|
||||
|
||||
public void testSetToScalarMask() {
|
||||
Mat mask = gray0.clone();
|
||||
mask.put(1, 1, 1, 2, 3);
|
||||
gray0.setTo(new Scalar(1), mask);
|
||||
assertEquals(3, Core.countNonZero(gray0));
|
||||
Core.subtract(gray0, mask, gray0);
|
||||
assertEquals(0, Core.countNonZero(gray0));
|
||||
}
|
||||
|
||||
public void testSize() {
|
||||
assertEquals(new Size(matSize, matSize), gray0.size());
|
||||
|
||||
|
||||
+9
-13
@@ -86,18 +86,11 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 0.643284f),
|
||||
new DMatch(1, 1, 0, 0.92945856f),
|
||||
new DMatch(2, 1, 0, 0.2841479f),
|
||||
new DMatch(3, 1, 0, 0.9194034f),
|
||||
new DMatch(4, 1, 0, 0.3006621f)
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.083795f),
|
||||
new DMatch(2, 1, 0, 0.484352f),
|
||||
new DMatch(3, 0, 0, 1.098605f),
|
||||
new DMatch(4, 1, 0, 0.494587f)
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.098605f),
|
||||
new DMatch(2, 1, 0, 0.494587f),
|
||||
new DMatch(3, 1, 0, 0.484352f),
|
||||
new DMatch(4, 0, 0, 1.083795f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
@@ -183,6 +176,9 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
Log.d("knnMatch", "train = " + train);
|
||||
Log.d("knnMatch", "query = " + query);
|
||||
/*
|
||||
Log.d("knnMatch", "train = " + train);
|
||||
Log.d("knnMatch", "query = " + query);
|
||||
|
||||
matcher.add(train);
|
||||
matcher.knnMatch(query, matches, k);
|
||||
*/
|
||||
@@ -190,7 +186,7 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
for(int i = 0; i<matches.size(); i++)
|
||||
{
|
||||
MatOfDMatch vdm = matches.get(i);
|
||||
Log.d("knn", "vdm["+i+"]="+vdm.dump());
|
||||
//Log.d("knn", "vdm["+i+"]="+vdm.dump());
|
||||
assertTrue(Math.min(k, train.rows()) >= vdm.total());
|
||||
for(DMatch dm : vdm.toArray())
|
||||
{
|
||||
|
||||
+2
@@ -189,9 +189,11 @@ public class BruteForceHammingLUTDescriptorMatcherTest extends OpenCVTestCase {
|
||||
|
||||
matcher.match(query, train, matches);
|
||||
|
||||
/*
|
||||
OpenCVTestRunner.Log("matches found: " + matches.size());
|
||||
for (DMatch m : matches.toArray())
|
||||
OpenCVTestRunner.Log(m.toString());
|
||||
*/
|
||||
|
||||
assertArrayDMatchEquals(truth, matches.toArray(), EPS);
|
||||
}
|
||||
|
||||
+5
-12
@@ -84,18 +84,11 @@ public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 3.175296f),
|
||||
new DMatch(1, 1, 0, 3.5954158f),
|
||||
new DMatch(2, 1, 0, 1.2537984f),
|
||||
new DMatch(3, 1, 0, 3.5761614f),
|
||||
new DMatch(4, 1, 0, 1.3250958f)
|
||||
*/
|
||||
new DMatch(0, 1, 0, 6.920234f),
|
||||
new DMatch(1, 0, 0, 6.1294847f),
|
||||
new DMatch(2, 1, 0, 2.6545324f),
|
||||
new DMatch(3, 1, 0, 6.1675916f),
|
||||
new DMatch(4, 1, 0, 2.679859f)
|
||||
new DMatch(0, 1, 0, 6.9202342f),
|
||||
new DMatch(1, 1, 0, 6.1675916f),
|
||||
new DMatch(2, 1, 0, 2.6798589f),
|
||||
new DMatch(3, 1, 0, 2.6545324f),
|
||||
new DMatch(4, 0, 0, 6.1294847f)
|
||||
};
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
+4
-11
@@ -89,18 +89,11 @@ public class BruteForceSL2DescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, sqr(0.643284f)),
|
||||
new DMatch(1, 1, 0, sqr(0.92945856f)),
|
||||
new DMatch(2, 1, 0, sqr(0.2841479f)),
|
||||
new DMatch(3, 1, 0, sqr(0.9194034f)),
|
||||
new DMatch(4, 1, 0, sqr(0.3006621f))
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.1018577f),
|
||||
new DMatch(1, 0, 0, 1.1746116f),
|
||||
new DMatch(2, 1, 0, 0.23459719f),
|
||||
new DMatch(3, 0, 0, 1.2069331f),
|
||||
new DMatch(4, 1, 0, 0.2446168f)
|
||||
new DMatch(1, 0, 0, 1.2069331f),
|
||||
new DMatch(2, 1, 0, 0.2446168f),
|
||||
new DMatch(3, 1, 0, 0.2345972f),
|
||||
new DMatch(4, 0, 0, 1.1746116f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
|
||||
+4
-11
@@ -158,18 +158,11 @@ public class FlannBasedDescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 0.643284f),
|
||||
new DMatch(1, 1, 0, 0.92945856f),
|
||||
new DMatch(2, 1, 0, 0.2841479f),
|
||||
new DMatch(3, 1, 0, 0.9194034f),
|
||||
new DMatch(4, 1, 0, 0.3006621f)
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.083795f),
|
||||
new DMatch(2, 1, 0, 0.484352f),
|
||||
new DMatch(3, 0, 0, 1.098605f),
|
||||
new DMatch(4, 1, 0, 0.494587f)
|
||||
new DMatch(1, 0, 0, 1.098605f),
|
||||
new DMatch(2, 1, 0, 0.494587f),
|
||||
new DMatch(3, 1, 0, 0.484352f),
|
||||
new DMatch(4, 0, 0, 1.083795f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
|
||||
+7
-2
@@ -16,6 +16,11 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
DescriptorExtractor extractor;
|
||||
int matSize;
|
||||
|
||||
public static void assertDescriptorsClose(Mat expected, Mat actual, int allowedDistance) {
|
||||
double distance = Core.norm(expected, actual, Core.NORM_HAMMING);
|
||||
assertTrue("expected:<" + allowedDistance + "> but was:<" + distance + ">", distance <= allowedDistance);
|
||||
}
|
||||
|
||||
private Mat getTestImg() {
|
||||
Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
|
||||
Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
|
||||
@@ -50,7 +55,7 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
6, 74, 6, 129, 2, 130, 56, 0, 36, 132, 66, 165, 172, 6, 3, 72, 102, 61, 163, 214, 0, 144, 65, 232, 4, 32, 138, 129, 4, 21, 37, 88);
|
||||
}
|
||||
};
|
||||
assertMatEqual(truth, descriptors);
|
||||
assertDescriptorsClose(truth, descriptors, 1);
|
||||
}
|
||||
|
||||
public void testCreate() {
|
||||
@@ -87,7 +92,7 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
6, 10, 22, 5, 2, 130, 56, 0, 44, 164, 66, 165, 140, 6, 1, 72, 38, 61, 163, 210, 0, 208, 1, 104, 4, 32, 10, 131, 0, 37, 37, 67);
|
||||
}
|
||||
};
|
||||
assertMatEqual(truth, descriptors);
|
||||
assertDescriptorsClose(truth, descriptors, 1);
|
||||
}
|
||||
|
||||
public void testWrite() {
|
||||
|
||||
@@ -9,6 +9,7 @@ import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfFloat;
|
||||
import org.opencv.core.MatOfInt;
|
||||
import org.opencv.core.MatOfInt4;
|
||||
import org.opencv.core.MatOfPoint;
|
||||
import org.opencv.core.MatOfPoint2f;
|
||||
import org.opencv.core.Point;
|
||||
@@ -242,9 +243,9 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
|
||||
public void testCalcBackProject() {
|
||||
List<Mat> images = Arrays.asList(grayChess);
|
||||
MatOfInt channels = new MatOfInt(1, new int[]{0});
|
||||
MatOfInt histSize = new MatOfInt(1, new int[]{10});
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0);
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
|
||||
Mat hist = new Mat();
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -259,9 +260,9 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() {
|
||||
List<Mat> images = Arrays.asList(gray128);
|
||||
MatOfInt channels = new MatOfInt(1, new int[]{0});
|
||||
MatOfInt histSize = new MatOfInt(1, new int[]{10});
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0);
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -274,11 +275,11 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2d() {
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2D() {
|
||||
List<Mat> images = Arrays.asList(gray255, gray128);
|
||||
MatOfInt channels = new MatOfInt(1, 0, 1);
|
||||
MatOfInt histSize = new MatOfInt(1, 10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0, 1);
|
||||
MatOfInt histSize = new MatOfInt(10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -291,11 +292,49 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat3D() {
|
||||
List<Mat> images = Arrays.asList(rgbLena);
|
||||
|
||||
Mat hist3D = new Mat();
|
||||
List<Mat> histList = Arrays.asList( new Mat[] {new Mat(), new Mat(), new Mat()} );
|
||||
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
|
||||
for(int i=0; i<rgbLena.channels(); i++)
|
||||
{
|
||||
Imgproc.calcHist(images, new MatOfInt(i), new Mat(), histList.get(i), histSize, ranges);
|
||||
|
||||
assertEquals(10, histList.get(i).checkVector(1));
|
||||
}
|
||||
|
||||
Core.merge(histList, hist3D);
|
||||
|
||||
assertEquals(CvType.CV_32FC3, hist3D.type());
|
||||
assertEquals(10, hist3D.checkVector(3));
|
||||
|
||||
Mat truth = new Mat(10, 1, CvType.CV_32FC3);
|
||||
truth.put(0, 0,
|
||||
0, 24870, 0,
|
||||
1863, 31926, 1,
|
||||
56682, 37677, 2260,
|
||||
77278, 44751, 32436,
|
||||
69397, 41343, 18526,
|
||||
27180, 40407, 18658,
|
||||
21101, 15993, 32042,
|
||||
8343, 18585, 47786,
|
||||
300, 6567, 80988,
|
||||
0, 25, 29447
|
||||
);
|
||||
|
||||
assertMatEqual(truth, hist3D, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
|
||||
List<Mat> images = Arrays.asList(gray255, gray128);
|
||||
MatOfInt channels = new MatOfInt(1, 0, 1);
|
||||
MatOfInt histSize = new MatOfInt(1, 10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0, 1);
|
||||
MatOfInt histSize = new MatOfInt(10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, true);
|
||||
@@ -382,26 +421,62 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testConvexHullMatMat() {
|
||||
Mat points = new Mat(1, 6, CvType.CV_32FC2);
|
||||
points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(20, 0),
|
||||
new Point(40, 0),
|
||||
new Point(30, 20),
|
||||
new Point(0, 20),
|
||||
new Point(20, 10),
|
||||
new Point(30, 10)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
|
||||
Imgproc.convexHull(points, dst);
|
||||
Imgproc.convexHull(points, hull);
|
||||
|
||||
Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
|
||||
expHull.put(0, 0, 4, 0, 3, 2, 0, 2, 2, 0);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
MatOfInt expHull = new MatOfInt(
|
||||
1, 2, 3, 0
|
||||
);
|
||||
assertMatEqual(expHull, hull, EPS);
|
||||
}
|
||||
|
||||
public void testConvexHullMatMatBooleanBoolean() {
|
||||
Mat points = new Mat(1, 6, CvType.CV_32FC2);
|
||||
points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(2, 0),
|
||||
new Point(4, 0),
|
||||
new Point(3, 2),
|
||||
new Point(0, 2),
|
||||
new Point(2, 1),
|
||||
new Point(3, 1)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
|
||||
Imgproc.convexHull(points, dst, true, true);
|
||||
// TODO_: write better test (last param == false)
|
||||
Imgproc.convexHull(points, hull, true);
|
||||
|
||||
Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
|
||||
expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
MatOfInt expHull = new MatOfInt(
|
||||
3, 2, 1, 0
|
||||
);
|
||||
assertMatEqual(expHull, hull, EPS);
|
||||
}
|
||||
|
||||
public void testConvexityDefects() {
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(20, 0),
|
||||
new Point(40, 0),
|
||||
new Point(30, 20),
|
||||
new Point(0, 20),
|
||||
new Point(20, 10),
|
||||
new Point(30, 10)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
Imgproc.convexHull(points, hull);
|
||||
|
||||
MatOfInt4 convexityDefects = new MatOfInt4();
|
||||
Imgproc.convexityDefects(points, hull, convexityDefects);
|
||||
|
||||
assertMatEqual(new MatOfInt4(3, 0, 5, 3620), convexityDefects);
|
||||
}
|
||||
|
||||
public void testCopyMakeBorderMatMatIntIntIntIntInt() {
|
||||
@@ -1277,11 +1352,11 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testIsContourConvex() {
|
||||
MatOfPoint2f contour1 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
|
||||
MatOfPoint contour1 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
|
||||
|
||||
assertFalse(Imgproc.isContourConvex(contour1));
|
||||
|
||||
MatOfPoint2f contour2 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
|
||||
MatOfPoint contour2 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
|
||||
|
||||
assertTrue(Imgproc.isContourConvex(contour2));
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package org.opencv.test.imgproc;
|
||||
|
||||
import org.opencv.core.MatOfFloat;
|
||||
import org.opencv.core.MatOfFloat6;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Rect;
|
||||
import org.opencv.imgproc.Subdiv2D;
|
||||
@@ -50,7 +50,7 @@ public class Subdiv2DTest extends OpenCVTestCase {
|
||||
s2d.insert( new Point(20, 10) );
|
||||
s2d.insert( new Point(20, 20) );
|
||||
s2d.insert( new Point(10, 20) );
|
||||
MatOfFloat triangles = new MatOfFloat();
|
||||
MatOfFloat6 triangles = new MatOfFloat6();
|
||||
s2d.getTriangleList(triangles);
|
||||
assertEquals(10, triangles.rows());
|
||||
/*
|
||||
|
||||
@@ -1 +1,2 @@
|
||||
include/opencv2/core/core.hpp
|
||||
../java/src/cpp/core_manual.hpp
|
||||
|
||||
+1399
-1385
File diff suppressed because it is too large
Load Diff
@@ -1,5 +1,5 @@
|
||||
import os, sys, re, string, glob
|
||||
allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "haartraining", "java", "python", "stitching", "traincascade", "ts", "photo"]
|
||||
allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "haartraining", "java", "python", "stitching", "traincascade", "ts", "photo", "videostab"]
|
||||
verbose = False
|
||||
show_warnings = True
|
||||
show_errors = True
|
||||
@@ -67,14 +67,47 @@ class JavadocGenerator(object):
|
||||
inf.close()
|
||||
outf.close()
|
||||
|
||||
def FinishParagraph(self, text):
|
||||
return text[:-1] + "</p>\n"
|
||||
|
||||
def ReformatForJavadoc(self, s):
|
||||
out = ""
|
||||
in_paragraph = False
|
||||
in_list = False
|
||||
for term in s.split("\n"):
|
||||
if term.startswith("*") or term.startswith("#."):
|
||||
term = " " + term
|
||||
in_list_item = False
|
||||
if term.startswith("*"):
|
||||
in_list_item = True
|
||||
if in_paragraph:
|
||||
out = self.FinishParagraph(out)
|
||||
in_paragraph = False
|
||||
if not in_list:
|
||||
out += " * <ul>\n"
|
||||
in_list = True
|
||||
term = " <li>" + term[1:]
|
||||
|
||||
if term.startswith("#."):
|
||||
in_list_item = True
|
||||
if in_paragraph:
|
||||
out = self.FinishParagraph(out)
|
||||
in_paragraph = False
|
||||
if not in_list:
|
||||
out += " * <ul>\n"
|
||||
in_list = True
|
||||
term = " <li>" + term[2:]
|
||||
|
||||
if not term:
|
||||
if in_paragraph:
|
||||
out = self.FinishParagraph(out)
|
||||
in_paragraph = False
|
||||
out += " *\n"
|
||||
else:
|
||||
if in_list and not in_list_item:
|
||||
in_list = False
|
||||
if out.endswith(" *\n"):
|
||||
out = out[:-3] + " * </ul>\n *\n"
|
||||
else:
|
||||
out += " * </ul>\n"
|
||||
pos_start = 0
|
||||
pos_end = min(77, len(term)-1)
|
||||
while pos_start < pos_end:
|
||||
@@ -91,12 +124,22 @@ class JavadocGenerator(object):
|
||||
pos_end += 1
|
||||
else:
|
||||
break
|
||||
out += " * " + term[pos_start:pos_end+1].rstrip() + "\n"
|
||||
if in_paragraph or term.startswith("@") or in_list_item:
|
||||
out += " * "
|
||||
else:
|
||||
in_paragraph = True
|
||||
out += " * <p>"
|
||||
out += term[pos_start:pos_end+1].rstrip() + "\n"
|
||||
pos_start = pos_end + 1
|
||||
pos_end = min(pos_start + 77, len(term)-1)
|
||||
|
||||
if in_paragraph:
|
||||
out = self.FinishParagraph(out)
|
||||
if in_list:
|
||||
out += " * </ul>\n"
|
||||
return out
|
||||
|
||||
def getJavaName(self, decl):
|
||||
def getJavaName(self, decl, methodSeparator = "."):
|
||||
name = "org.opencv."
|
||||
name += decl["module"]
|
||||
if "class" in decl:
|
||||
@@ -104,11 +147,11 @@ class JavadocGenerator(object):
|
||||
else:
|
||||
name += "." + decl["module"].capitalize()
|
||||
if "method" in decl:
|
||||
name += "." + decl["method"]
|
||||
name += methodSeparator + decl["method"]
|
||||
return name
|
||||
|
||||
def getDocURL(self, decl):
|
||||
url = "http://opencv.itseez.com/modules/"
|
||||
url = "http://docs.opencv.org/modules/"
|
||||
url += decl["module"]
|
||||
url += "/doc/"
|
||||
url += os.path.basename(decl["file"]).replace(".rst",".html")
|
||||
@@ -168,7 +211,7 @@ class JavadocGenerator(object):
|
||||
for see in decl["seealso"]:
|
||||
seedecl = self.definitions.get(see,None)
|
||||
if seedecl:
|
||||
doc += prefix + " * @see " + self.getJavaName(seedecl) + "\n"
|
||||
doc += prefix + " * @see " + self.getJavaName(seedecl, "#") + "\n"
|
||||
else:
|
||||
doc += prefix + " * @see " + see.replace("::",".") + "\n"
|
||||
prefix = " *\n"
|
||||
|
||||
@@ -499,7 +499,8 @@ class RstParser(object):
|
||||
def normalizeText(self, s):
|
||||
if s is None:
|
||||
return s
|
||||
s = re.sub(r"\.\. math::[ ]*\n+(.*?)(\n[ ]*\n|$)", mathReplace2, s)
|
||||
|
||||
s = re.sub(r"\.\. math::[ \r]*\n+((.|\n)*?)(\n[ \r]*\n|$)", mathReplace2, s)
|
||||
s = re.sub(r":math:`([^`]+?)`", mathReplace, s)
|
||||
s = re.sub(r" *:sup:", "^", s)
|
||||
|
||||
@@ -574,6 +575,7 @@ class RstParser(object):
|
||||
s = re.sub(r"[\n ]+\.", ".", s)
|
||||
|
||||
s = s.replace("**", "")
|
||||
s = re.sub(r"``([^\n]+?)``", "<code>\\1</code>", s)
|
||||
s = s.replace("``", "\"")
|
||||
s = s.replace("`", "\"")
|
||||
s = s.replace("\"\"", "\"")
|
||||
@@ -688,7 +690,7 @@ def mathReplace(match):
|
||||
m = m.replace("}", ")")
|
||||
|
||||
#print "%s ===> %s" % (match.group(0), m)
|
||||
return m
|
||||
return "<em>" + m + "</em>"
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) < 2:
|
||||
|
||||
+357
-155
@@ -2,11 +2,12 @@
|
||||
|
||||
#include "converters.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#include <android/log.h>
|
||||
#define MODULE_LOG_TAG "OpenCV.core.Mat"
|
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
|
||||
#else //DEBUG
|
||||
#define LOG_TAG "org.opencv.core.Mat"
|
||||
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
|
||||
#ifdef DEBUG
|
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
|
||||
#else //!DEBUG
|
||||
#define LOGD(...)
|
||||
#endif //DEBUG
|
||||
|
||||
@@ -1556,6 +1557,38 @@ JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1setTo__JDDDD
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Mat Mat::setTo(Scalar value, Mat mask = Mat())
|
||||
//
|
||||
|
||||
|
||||
JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1setTo__JDDDDJ
|
||||
(JNIEnv* env, jclass cls, jlong self, jdouble s_val0, jdouble s_val1, jdouble s_val2, jdouble s_val3, jlong mask_nativeObj)
|
||||
{
|
||||
try {
|
||||
LOGD("Mat::n_1setTo__JDDDDJ()");
|
||||
Mat* me = (Mat*) self; //TODO: check for NULL
|
||||
Scalar s(s_val0, s_val1, s_val2, s_val3);
|
||||
Mat& mask = *((Mat*)mask_nativeObj);
|
||||
Mat _retval_ = me->setTo( s, mask );
|
||||
|
||||
return (jlong) new Mat(_retval_);
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::n_1setTo__JDDDDJ() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::n_1setTo__JDDDDJ() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1setTo__JDDDDJ()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Mat Mat::setTo(Mat value, Mat mask = Mat())
|
||||
//
|
||||
@@ -1929,45 +1962,59 @@ JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1delete
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(!me || !me->data) return 0; // no native object behind
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
try {
|
||||
LOGD("Mat::nPutD()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(!me || !me->data) return 0; // no native object behind
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
int rest = ((me->rows - row) * me->cols - col) * me->channels();
|
||||
if(count>rest) count = rest;
|
||||
int res = count;
|
||||
double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
double* src = values;
|
||||
int r, c;
|
||||
for(c=col; c<me->cols && count>0; c++)
|
||||
{
|
||||
switch(me->depth()) {
|
||||
case CV_8U: PUT_ITEM(uchar, row, c); break;
|
||||
case CV_8S: PUT_ITEM(schar, row, c); break;
|
||||
case CV_16U: PUT_ITEM(ushort, row, c); break;
|
||||
case CV_16S: PUT_ITEM(short, row, c); break;
|
||||
case CV_32S: PUT_ITEM(int, row, c); break;
|
||||
case CV_32F: PUT_ITEM(float, row, c); break;
|
||||
case CV_64F: PUT_ITEM(double, row, c); break;
|
||||
}
|
||||
}
|
||||
|
||||
for(r=row+1; r<me->rows && count>0; r++)
|
||||
for(c=0; c<me->cols && count>0; c++)
|
||||
int rest = ((me->rows - row) * me->cols - col) * me->channels();
|
||||
if(count>rest) count = rest;
|
||||
int res = count;
|
||||
double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
double* src = values;
|
||||
int r, c;
|
||||
for(c=col; c<me->cols && count>0; c++)
|
||||
{
|
||||
switch(me->depth()) {
|
||||
case CV_8U: PUT_ITEM(uchar, r, c); break;
|
||||
case CV_8S: PUT_ITEM(schar, r, c); break;
|
||||
case CV_16U: PUT_ITEM(ushort, r, c); break;
|
||||
case CV_16S: PUT_ITEM(short, r, c); break;
|
||||
case CV_32S: PUT_ITEM(int, r, c); break;
|
||||
case CV_32F: PUT_ITEM(float, r, c); break;
|
||||
case CV_64F: PUT_ITEM(double, r, c); break;
|
||||
case CV_8U: PUT_ITEM(uchar, row, c); break;
|
||||
case CV_8S: PUT_ITEM(schar, row, c); break;
|
||||
case CV_16U: PUT_ITEM(ushort, row, c); break;
|
||||
case CV_16S: PUT_ITEM(short, row, c); break;
|
||||
case CV_32S: PUT_ITEM(int, row, c); break;
|
||||
case CV_32F: PUT_ITEM(float, row, c); break;
|
||||
case CV_64F: PUT_ITEM(double, row, c); break;
|
||||
}
|
||||
}
|
||||
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
for(r=row+1; r<me->rows && count>0; r++)
|
||||
for(c=0; c<me->cols && count>0; c++)
|
||||
{
|
||||
switch(me->depth()) {
|
||||
case CV_8U: PUT_ITEM(uchar, r, c); break;
|
||||
case CV_8S: PUT_ITEM(schar, r, c); break;
|
||||
case CV_16U: PUT_ITEM(ushort, r, c); break;
|
||||
case CV_16S: PUT_ITEM(short, r, c); break;
|
||||
case CV_32S: PUT_ITEM(int, r, c); break;
|
||||
case CV_32F: PUT_ITEM(float, r, c); break;
|
||||
case CV_64F: PUT_ITEM(double, r, c); break;
|
||||
}
|
||||
}
|
||||
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nPutD() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nPutD() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nPutD()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1979,7 +2026,7 @@ template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count,
|
||||
if(! buff) return 0;
|
||||
|
||||
count *= sizeof(T);
|
||||
int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);
|
||||
int rest = ((m->rows - row) * m->cols - col) * m->elemSize();
|
||||
if(count>rest) count = rest;
|
||||
int res = count;
|
||||
|
||||
@@ -1988,14 +2035,14 @@ template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count,
|
||||
memcpy(m->ptr(row, col), buff, count);
|
||||
} else {
|
||||
// row by row
|
||||
int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row
|
||||
int num = (m->cols - col) * m->elemSize(); // 1st partial row
|
||||
if(count<num) num = count;
|
||||
uchar* data = m->ptr(row++, col);
|
||||
while(count>0){
|
||||
memcpy(data, buff, num);
|
||||
count -= num;
|
||||
buff += num;
|
||||
num = m->cols * m->channels() * sizeof(T);
|
||||
num = m->cols * m->elemSize();
|
||||
if(count<num) num = count;
|
||||
data = m->ptr(row++, 0);
|
||||
}
|
||||
@@ -2009,57 +2056,113 @@ extern "C" {
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutB
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<char>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nPutB()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<char>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nPutB() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nPutB() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nPutB()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutS
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<short>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nPutS()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<short>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nPutS() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nPutS() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nPutS()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutI
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<int>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nPutI()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<int>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nPutI() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nPutI() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nPutI()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutF
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<float>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nPutF()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_put<float>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nPutF() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nPutF() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nPutF()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2070,26 +2173,26 @@ template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char*
|
||||
if(! m) return 0;
|
||||
if(! buff) return 0;
|
||||
|
||||
count *= sizeof(T);
|
||||
int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);
|
||||
if(count>rest) count = rest;
|
||||
int res = count;
|
||||
int bytesToCopy = count * sizeof(T);
|
||||
int bytesRestInMat = ((m->rows - row) * m->cols - col) * m->elemSize();
|
||||
if(bytesToCopy > bytesRestInMat) bytesToCopy = bytesRestInMat;
|
||||
int res = bytesToCopy;
|
||||
|
||||
if( m->isContinuous() )
|
||||
{
|
||||
memcpy(buff, m->ptr(row, col), count);
|
||||
memcpy(buff, m->ptr(row, col), bytesToCopy);
|
||||
} else {
|
||||
// row by row
|
||||
int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row
|
||||
if(count<num) num = count;
|
||||
uchar* data = m->ptr(row++, col);
|
||||
while(count>0){//TODO: recheck this cycle for the case col!=0
|
||||
memcpy(buff, data, num);
|
||||
count -= num;
|
||||
buff += num;
|
||||
num = m->cols * m->channels() * sizeof(T);
|
||||
if(count<num) num = count;
|
||||
data = m->ptr(row++, 0);
|
||||
int bytesInRow = (m->cols - col) * m->elemSize(); // 1st partial row
|
||||
while(bytesToCopy > 0)
|
||||
{
|
||||
int len = std::min(bytesToCopy, bytesInRow);
|
||||
memcpy(buff, m->ptr(row, col), len);
|
||||
bytesToCopy -= len;
|
||||
buff += len;
|
||||
row++;
|
||||
col = 0;
|
||||
bytesInRow = m->cols * m->elemSize();
|
||||
}
|
||||
}
|
||||
return res;
|
||||
@@ -2100,96 +2203,180 @@ extern "C" {
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetB
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<char>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nGetB()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<char>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGetB() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGetB() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGetB()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetS
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<short>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nGetS()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<short>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGetS() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGetS() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGetS()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetI
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<int>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nGetI()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32S) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<int>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGetI() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGetI() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGetI()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetF
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<float>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nGetF()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_32F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<float>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGetF() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGetF() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGetF()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetD
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_64F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<double>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
try {
|
||||
LOGD("Mat::nGetD()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->depth() != CV_64F) return 0; // incompatible type
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
|
||||
int res = mat_get<double>(me, row, col, count, values);
|
||||
env->ReleasePrimitiveArrayCritical(vals, values, 0);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGetD() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGetD() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGetD()}");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Mat_nGet
|
||||
(JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
try {
|
||||
LOGD("Mat::nGet()");
|
||||
cv::Mat* me = (cv::Mat*) self;
|
||||
if(! self) return 0; // no native object behind
|
||||
if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
|
||||
|
||||
jdoubleArray res = env->NewDoubleArray(me->channels());
|
||||
if(res){
|
||||
jdouble buff[me->channels()];
|
||||
int i;
|
||||
switch(me->depth()){
|
||||
case CV_8U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned char*) me->ptr(row, col) + i); break;
|
||||
case CV_8S: for(i=0; i<me->channels(); i++) buff[i] = *((signed char*) me->ptr(row, col) + i); break;
|
||||
case CV_16U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned short*)me->ptr(row, col) + i); break;
|
||||
case CV_16S: for(i=0; i<me->channels(); i++) buff[i] = *((signed short*) me->ptr(row, col) + i); break;
|
||||
case CV_32S: for(i=0; i<me->channels(); i++) buff[i] = *((int*) me->ptr(row, col) + i); break;
|
||||
case CV_32F: for(i=0; i<me->channels(); i++) buff[i] = *((float*) me->ptr(row, col) + i); break;
|
||||
case CV_64F: for(i=0; i<me->channels(); i++) buff[i] = *((double*) me->ptr(row, col) + i); break;
|
||||
jdoubleArray res = env->NewDoubleArray(me->channels());
|
||||
if(res){
|
||||
jdouble buff[me->channels()];
|
||||
int i;
|
||||
switch(me->depth()){
|
||||
case CV_8U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned char*) me->ptr(row, col) + i); break;
|
||||
case CV_8S: for(i=0; i<me->channels(); i++) buff[i] = *((signed char*) me->ptr(row, col) + i); break;
|
||||
case CV_16U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned short*)me->ptr(row, col) + i); break;
|
||||
case CV_16S: for(i=0; i<me->channels(); i++) buff[i] = *((signed short*) me->ptr(row, col) + i); break;
|
||||
case CV_32S: for(i=0; i<me->channels(); i++) buff[i] = *((int*) me->ptr(row, col) + i); break;
|
||||
case CV_32F: for(i=0; i<me->channels(); i++) buff[i] = *((float*) me->ptr(row, col) + i); break;
|
||||
case CV_64F: for(i=0; i<me->channels(); i++) buff[i] = *((double*) me->ptr(row, col) + i); break;
|
||||
}
|
||||
env->SetDoubleArrayRegion(res, 0, me->channels(), buff);
|
||||
}
|
||||
env->SetDoubleArrayRegion(res, 0, me->channels(), buff);
|
||||
return res;
|
||||
} catch(cv::Exception e) {
|
||||
LOGD("Mat::nGet() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return 0;
|
||||
} catch (...) {
|
||||
LOGD("Mat::nGet() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nGet()}");
|
||||
return 0;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
JNIEXPORT jstring JNICALL Java_org_opencv_core_Mat_nDump
|
||||
@@ -2197,8 +2384,23 @@ JNIEXPORT jstring JNICALL Java_org_opencv_core_Mat_nDump
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL
|
||||
std::stringstream s;
|
||||
s << *me;
|
||||
return env->NewStringUTF(s.str().c_str());
|
||||
try {
|
||||
LOGD("Mat::nDump()");
|
||||
|
||||
s << *me;
|
||||
return env->NewStringUTF(s.str().c_str());
|
||||
} catch(cv::Exception e) {
|
||||
LOGE("Mat::nDump() catched cv::Exception: %s", e.what());
|
||||
jclass je = env->FindClass("org/opencv/core/CvException");
|
||||
if(!je) je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, e.what());
|
||||
return env->NewStringUTF("ERROR");
|
||||
} catch (...) {
|
||||
LOGE("Mat::nDump() catched unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {Mat::nDump()}");
|
||||
return env->NewStringUTF("ERROR");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
+457
-398
@@ -1,398 +1,457 @@
|
||||
#include "converters.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#include <android/log.h>
|
||||
#define MODULE_LOG_TAG "OpenCV.converters"
|
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
|
||||
#else //DEBUG
|
||||
#define LOGD(...)
|
||||
#endif //DEBUG
|
||||
|
||||
using namespace cv;
|
||||
|
||||
#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
|
||||
|
||||
|
||||
// vector_int
|
||||
|
||||
void Mat_to_vector_int(Mat& mat, vector<int>& v_int)
|
||||
{
|
||||
v_int.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1);
|
||||
v_int = (vector<int>) mat;
|
||||
}
|
||||
|
||||
void vector_int_to_Mat(vector<int>& v_int, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_int, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_double
|
||||
|
||||
void Mat_to_vector_double(Mat& mat, vector<double>& v_double)
|
||||
{
|
||||
v_double.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1);
|
||||
v_double = (vector<double>) mat;
|
||||
}
|
||||
|
||||
void vector_double_to_Mat(vector<double>& v_double, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_double, true);
|
||||
}
|
||||
|
||||
|
||||
// vector_float
|
||||
|
||||
void Mat_to_vector_float(Mat& mat, vector<float>& v_float)
|
||||
{
|
||||
v_float.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1);
|
||||
v_float = (vector<float>) mat;
|
||||
}
|
||||
|
||||
void vector_float_to_Mat(vector<float>& v_float, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_float, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_uchar
|
||||
|
||||
void Mat_to_vector_uchar(Mat& mat, vector<uchar>& v_uchar)
|
||||
{
|
||||
v_uchar.clear();
|
||||
CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1);
|
||||
v_uchar = (vector<uchar>) mat;
|
||||
}
|
||||
|
||||
void vector_uchar_to_Mat(vector<uchar>& v_uchar, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_uchar, true);
|
||||
}
|
||||
|
||||
void Mat_to_vector_char(Mat& mat, vector<char>& v_char)
|
||||
{
|
||||
v_char.clear();
|
||||
CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1);
|
||||
v_char = (vector<char>) mat;
|
||||
}
|
||||
|
||||
void vector_char_to_Mat(vector<char>& v_char, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_char, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_Rect
|
||||
|
||||
void Mat_to_vector_Rect(Mat& mat, vector<Rect>& v_rect)
|
||||
{
|
||||
v_rect.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1);
|
||||
v_rect = (vector<Rect>) mat;
|
||||
}
|
||||
|
||||
void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_rect, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_Point
|
||||
void Mat_to_vector_Point(Mat& mat, vector<Point>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1);
|
||||
v_point = (vector<Point>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2f
|
||||
void Mat_to_vector_Point2f(Mat& mat, vector<Point2f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1);
|
||||
v_point = (vector<Point2f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2d
|
||||
void Mat_to_vector_Point2d(Mat& mat, vector<Point2d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1);
|
||||
v_point = (vector<Point2d>) mat;
|
||||
}
|
||||
|
||||
|
||||
//vector_Point3i
|
||||
void Mat_to_vector_Point3i(Mat& mat, vector<Point3i>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1);
|
||||
v_point = (vector<Point3i>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3f
|
||||
void Mat_to_vector_Point3f(Mat& mat, vector<Point3f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1);
|
||||
v_point = (vector<Point3f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3d
|
||||
void Mat_to_vector_Point3d(Mat& mat, vector<Point3d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1);
|
||||
v_point = (vector<Point3d>) mat;
|
||||
}
|
||||
|
||||
|
||||
void vector_Point_to_Mat(vector<Point>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2f_to_Mat(vector<Point2f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2d_to_Mat(vector<Point2d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3i_to_Mat(vector<Point3i>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3f_to_Mat(vector<Point3f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3d_to_Mat(vector<Point3d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
//vector_KeyPoint
|
||||
void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp)
|
||||
{
|
||||
v_kp.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0);
|
||||
KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]);
|
||||
v_kp.push_back(kp);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat)
|
||||
{
|
||||
int count = v_kp.size();
|
||||
mat.create(count, 1, CV_32FC(7));
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
KeyPoint kp = v_kp[i];
|
||||
mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
//vector_Mat
|
||||
void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat)
|
||||
{
|
||||
v_mat.clear();
|
||||
if(mat.type() == CV_32SC2 && mat.cols == 1)
|
||||
{
|
||||
v_mat.reserve(mat.rows);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<int, 2> a = mat.at< Vec<int, 2> >(i, 0);
|
||||
long long addr = (((long long)a[0])<<32) | a[1];
|
||||
Mat& m = *( (Mat*) addr );
|
||||
v_mat.push_back(m);
|
||||
}
|
||||
} else {
|
||||
LOGD("Mat_to_vector_Mat() FAILED: mat.type() == CV_32SC2 && mat.cols == 1");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat)
|
||||
{
|
||||
int count = v_mat.size();
|
||||
mat.create(count, 1, CV_32SC2);
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
long long addr = (long long) new Mat(v_mat[i]);
|
||||
mat.at< Vec<int, 2> >(i, 0) = Vec<int, 2>(addr>>32, addr&0xffffffff);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
//vector_DMatch
|
||||
void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm)
|
||||
{
|
||||
v_dm.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0);
|
||||
DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]);
|
||||
v_dm.push_back(dm);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat)
|
||||
{
|
||||
int count = v_dm.size();
|
||||
mat.create(count, 1, CV_32FC4);
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
DMatch dm = v_dm[i];
|
||||
mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<Point> vpt;
|
||||
Mat_to_vector_Point(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<KeyPoint> vkp;
|
||||
Mat_to_vector_KeyPoint(vm[i], vkp);
|
||||
vv_kp.push_back(vkp);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_KeyPoint_to_Mat(vector< vector< KeyPoint > >& vv_kp, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_kp.size() );
|
||||
for(size_t i=0; i<vv_kp.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_KeyPoint_to_Mat(vv_kp[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_DMatch(Mat& mat, vector< vector< DMatch > >& vv_dm)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<DMatch> vdm;
|
||||
Mat_to_vector_DMatch(vm[i], vdm);
|
||||
vv_dm.push_back(vdm);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_DMatch_to_Mat(vector< vector< DMatch > >& vv_dm, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_dm.size() );
|
||||
for(size_t i=0; i<vv_dm.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_DMatch_to_Mat(vv_dm[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
#endif
|
||||
|
||||
void Mat_to_vector_vector_char(Mat& mat, vector< vector< char > >& vv_ch)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<char> vch;
|
||||
Mat_to_vector_char(vm[i], vch);
|
||||
vv_ch.push_back(vch);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_ch.size() );
|
||||
for(size_t i=0; i<vv_ch.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_char_to_Mat(vv_ch[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point2f_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_Vec4f_to_Mat(vector<Vec4f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
void vector_Vec6f_to_Mat(vector<Vec6f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
#include "converters.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#include <android/log.h>
|
||||
#define MODULE_LOG_TAG "OpenCV.converters"
|
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
|
||||
#else //DEBUG
|
||||
#define LOGD(...)
|
||||
#endif //DEBUG
|
||||
|
||||
using namespace cv;
|
||||
|
||||
#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
|
||||
|
||||
|
||||
// vector_int
|
||||
|
||||
void Mat_to_vector_int(Mat& mat, vector<int>& v_int)
|
||||
{
|
||||
v_int.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1);
|
||||
v_int = (vector<int>) mat;
|
||||
}
|
||||
|
||||
void vector_int_to_Mat(vector<int>& v_int, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_int, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_double
|
||||
|
||||
void Mat_to_vector_double(Mat& mat, vector<double>& v_double)
|
||||
{
|
||||
v_double.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1);
|
||||
v_double = (vector<double>) mat;
|
||||
}
|
||||
|
||||
void vector_double_to_Mat(vector<double>& v_double, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_double, true);
|
||||
}
|
||||
|
||||
|
||||
// vector_float
|
||||
|
||||
void Mat_to_vector_float(Mat& mat, vector<float>& v_float)
|
||||
{
|
||||
v_float.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1);
|
||||
v_float = (vector<float>) mat;
|
||||
}
|
||||
|
||||
void vector_float_to_Mat(vector<float>& v_float, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_float, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_uchar
|
||||
|
||||
void Mat_to_vector_uchar(Mat& mat, vector<uchar>& v_uchar)
|
||||
{
|
||||
v_uchar.clear();
|
||||
CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1);
|
||||
v_uchar = (vector<uchar>) mat;
|
||||
}
|
||||
|
||||
void vector_uchar_to_Mat(vector<uchar>& v_uchar, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_uchar, true);
|
||||
}
|
||||
|
||||
void Mat_to_vector_char(Mat& mat, vector<char>& v_char)
|
||||
{
|
||||
v_char.clear();
|
||||
CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1);
|
||||
v_char = (vector<char>) mat;
|
||||
}
|
||||
|
||||
void vector_char_to_Mat(vector<char>& v_char, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_char, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_Rect
|
||||
|
||||
void Mat_to_vector_Rect(Mat& mat, vector<Rect>& v_rect)
|
||||
{
|
||||
v_rect.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1);
|
||||
v_rect = (vector<Rect>) mat;
|
||||
}
|
||||
|
||||
void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_rect, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_Point
|
||||
void Mat_to_vector_Point(Mat& mat, vector<Point>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1);
|
||||
v_point = (vector<Point>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2f
|
||||
void Mat_to_vector_Point2f(Mat& mat, vector<Point2f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1);
|
||||
v_point = (vector<Point2f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2d
|
||||
void Mat_to_vector_Point2d(Mat& mat, vector<Point2d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1);
|
||||
v_point = (vector<Point2d>) mat;
|
||||
}
|
||||
|
||||
|
||||
//vector_Point3i
|
||||
void Mat_to_vector_Point3i(Mat& mat, vector<Point3i>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1);
|
||||
v_point = (vector<Point3i>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3f
|
||||
void Mat_to_vector_Point3f(Mat& mat, vector<Point3f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1);
|
||||
v_point = (vector<Point3f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3d
|
||||
void Mat_to_vector_Point3d(Mat& mat, vector<Point3d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1);
|
||||
v_point = (vector<Point3d>) mat;
|
||||
}
|
||||
|
||||
|
||||
void vector_Point_to_Mat(vector<Point>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2f_to_Mat(vector<Point2f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2d_to_Mat(vector<Point2d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3i_to_Mat(vector<Point3i>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3f_to_Mat(vector<Point3f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3d_to_Mat(vector<Point3d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
//vector_KeyPoint
|
||||
void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp)
|
||||
{
|
||||
v_kp.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0);
|
||||
KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]);
|
||||
v_kp.push_back(kp);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat)
|
||||
{
|
||||
int count = v_kp.size();
|
||||
mat.create(count, 1, CV_32FC(7));
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
KeyPoint kp = v_kp[i];
|
||||
mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
//vector_Mat
|
||||
void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat)
|
||||
{
|
||||
v_mat.clear();
|
||||
if(mat.type() == CV_32SC2 && mat.cols == 1)
|
||||
{
|
||||
v_mat.reserve(mat.rows);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<int, 2> a = mat.at< Vec<int, 2> >(i, 0);
|
||||
long long addr = (((long long)a[0])<<32) | a[1];
|
||||
Mat& m = *( (Mat*) addr );
|
||||
v_mat.push_back(m);
|
||||
}
|
||||
} else {
|
||||
LOGD("Mat_to_vector_Mat() FAILED: mat.type() == CV_32SC2 && mat.cols == 1");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat)
|
||||
{
|
||||
int count = v_mat.size();
|
||||
mat.create(count, 1, CV_32SC2);
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
long long addr = (long long) new Mat(v_mat[i]);
|
||||
mat.at< Vec<int, 2> >(i, 0) = Vec<int, 2>(addr>>32, addr&0xffffffff);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
//vector_DMatch
|
||||
void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm)
|
||||
{
|
||||
v_dm.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1);
|
||||
for(int i=0; i<mat.rows; i++)
|
||||
{
|
||||
Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0);
|
||||
DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]);
|
||||
v_dm.push_back(dm);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat)
|
||||
{
|
||||
int count = v_dm.size();
|
||||
mat.create(count, 1, CV_32FC4);
|
||||
for(int i=0; i<count; i++)
|
||||
{
|
||||
DMatch dm = v_dm[i];
|
||||
mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<Point> vpt;
|
||||
Mat_to_vector_Point(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_Point2f(Mat& mat, vector< vector< Point2f > >& vv_pt)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<Point2f> vpt;
|
||||
Mat_to_vector_Point2f(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_Point3f(Mat& mat, vector< vector< Point3f > >& vv_pt)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<Point3f> vpt;
|
||||
Mat_to_vector_Point3f(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<KeyPoint> vkp;
|
||||
Mat_to_vector_KeyPoint(vm[i], vkp);
|
||||
vv_kp.push_back(vkp);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_KeyPoint_to_Mat(vector< vector< KeyPoint > >& vv_kp, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_kp.size() );
|
||||
for(size_t i=0; i<vv_kp.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_KeyPoint_to_Mat(vv_kp[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_DMatch(Mat& mat, vector< vector< DMatch > >& vv_dm)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<DMatch> vdm;
|
||||
Mat_to_vector_DMatch(vm[i], vdm);
|
||||
vv_dm.push_back(vdm);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_DMatch_to_Mat(vector< vector< DMatch > >& vv_dm, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_dm.size() );
|
||||
for(size_t i=0; i<vv_dm.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_DMatch_to_Mat(vv_dm[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
#endif
|
||||
|
||||
void Mat_to_vector_vector_char(Mat& mat, vector< vector< char > >& vv_ch)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
vector<char> vch;
|
||||
Mat_to_vector_char(vm[i], vch);
|
||||
vv_ch.push_back(vch);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_ch.size() );
|
||||
for(size_t i=0; i<vv_ch.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_char_to_Mat(vv_ch[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point2f_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
|
||||
void vector_vector_Point3f_to_Mat(vector< vector< Point3f > >& vv_pt, Mat& mat)
|
||||
{
|
||||
vector<Mat> vm;
|
||||
vm.reserve( vv_pt.size() );
|
||||
for(size_t i=0; i<vv_pt.size(); i++)
|
||||
{
|
||||
Mat m;
|
||||
vector_Point3f_to_Mat(vv_pt[i], m);
|
||||
vm.push_back(m);
|
||||
}
|
||||
vector_Mat_to_Mat(vm, mat);
|
||||
}
|
||||
|
||||
void vector_Vec4i_to_Mat(vector<Vec4i>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
void vector_Vec4f_to_Mat(vector<Vec4f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
void vector_Vec6f_to_Mat(vector<Vec6f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
@@ -37,6 +37,7 @@ void vector_Point3i_to_Mat(std::vector<cv::Point3i>& v_point, cv::Mat& mat);
|
||||
void vector_Point3f_to_Mat(std::vector<cv::Point3f>& v_point, cv::Mat& mat);
|
||||
void vector_Point3d_to_Mat(std::vector<cv::Point3d>& v_point, cv::Mat& mat);
|
||||
|
||||
void vector_Vec4i_to_Mat(std::vector<cv::Vec4i>& v_vec, cv::Mat& mat);
|
||||
void vector_Vec4f_to_Mat(std::vector<cv::Vec4f>& v_vec, cv::Mat& mat);
|
||||
void vector_Vec6f_to_Mat(std::vector<cv::Vec6f>& v_vec, cv::Mat& mat);
|
||||
|
||||
@@ -63,6 +64,11 @@ void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >&
|
||||
void vector_vector_char_to_Mat(std::vector< std::vector< char > >& vv_ch, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_vector_Point(cv::Mat& mat, std::vector< std::vector< cv::Point > >& vv_pt);
|
||||
void vector_vector_Point_to_Mat(std::vector< std::vector< cv::Point > >& vv_pt, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_vector_Point2f(cv::Mat& mat, std::vector< std::vector< cv::Point2f > >& vv_pt);
|
||||
void vector_vector_Point2f_to_Mat(std::vector< std::vector< cv::Point2f > >& vv_pt, cv::Mat& mat);
|
||||
void vector_vector_Point_to_Mat(std::vector< std::vector< cv::Point > >& vv_pt, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_vector_Point3f(cv::Mat& mat, std::vector< std::vector< cv::Point3f > >& vv_pt);
|
||||
void vector_vector_Point3f_to_Mat(std::vector< std::vector< cv::Point3f > >& vv_pt, cv::Mat& mat);
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
#pragma once
|
||||
|
||||
#include "opencv2/core/core.hpp"
|
||||
|
||||
#if 0
|
||||
|
||||
namespace cv
|
||||
{
|
||||
CV_EXPORTS_W void add(InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1);
|
||||
|
||||
CV_EXPORTS_W void subtract(InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1);
|
||||
|
||||
CV_EXPORTS_W void multiply(InputArray src1, Scalar src2, OutputArray dst, double scale=1, int dtype=-1);
|
||||
|
||||
CV_EXPORTS_W void divide(InputArray src1, Scalar src2, OutputArray dst, double scale=1, int dtype=-1);
|
||||
|
||||
CV_EXPORTS_W void absdiff(InputArray src1, Scalar src2, OutputArray dst);
|
||||
|
||||
CV_EXPORTS_W void compare(InputArray src1, Scalar src2, OutputArray dst, int cmpop);
|
||||
|
||||
CV_EXPORTS_W void min(InputArray src1, Scalar src2, OutputArray dst);
|
||||
|
||||
CV_EXPORTS_W void max(InputArray src1, Scalar src2, OutputArray dst);
|
||||
|
||||
}
|
||||
#endif //0
|
||||
@@ -21,4 +21,16 @@ JNI_OnUnload(JavaVM *vm, void *reserved)
|
||||
//do nothing
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
} // extern "C"
|
||||
|
||||
#include "opencv2/opencv_modules.hpp"
|
||||
|
||||
#if HAVE_OPENCV_MODULES_NONFREE
|
||||
#include "opencv2/nonfree/nonfree.hpp"
|
||||
static bool makeUseOfNonfree = initModule_nonfree();
|
||||
#endif
|
||||
|
||||
#if HAVE_OPENCV_MODULES_FEATURES2D
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
static bool makeUseOfNonfree = initModule_features2d();
|
||||
#endif
|
||||
@@ -718,6 +718,19 @@ public class Mat {
|
||||
return retVal;
|
||||
}
|
||||
|
||||
//
|
||||
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
|
||||
//
|
||||
|
||||
// javadoc: Mat::setTo(value, mask)
|
||||
public Mat setTo(Scalar value, Mat mask)
|
||||
{
|
||||
|
||||
Mat retVal = new Mat(n_setTo(nativeObj, value.val[0], value.val[1], value.val[2], value.val[3], mask.nativeObj));
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
//
|
||||
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
|
||||
//
|
||||
@@ -1228,6 +1241,9 @@ public class Mat {
|
||||
// C++: Mat Mat::operator =(Scalar s)
|
||||
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
|
||||
|
||||
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
|
||||
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3, long mask_nativeObj);
|
||||
|
||||
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
|
||||
private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
|
||||
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
package org.opencv.core;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class MatOfFloat4 extends Mat {
|
||||
// 32FC4
|
||||
private static final int _depth = CvType.CV_32F;
|
||||
private static final int _channels = 4;
|
||||
|
||||
public MatOfFloat4() {
|
||||
super();
|
||||
}
|
||||
|
||||
protected MatOfFloat4(long addr) {
|
||||
super(addr);
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public static MatOfFloat4 fromNativeAddr(long addr) {
|
||||
return new MatOfFloat4(addr);
|
||||
}
|
||||
|
||||
public MatOfFloat4(Mat m) {
|
||||
super(m, Range.all());
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public MatOfFloat4(float...a) {
|
||||
super();
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public void alloc(int elemNumber) {
|
||||
if(elemNumber>0)
|
||||
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
|
||||
}
|
||||
|
||||
public void fromArray(float...a) {
|
||||
if(a==null || a.length==0)
|
||||
return;
|
||||
int num = a.length / _channels;
|
||||
alloc(num);
|
||||
put(0, 0, a); //TODO: check ret val!
|
||||
}
|
||||
|
||||
public float[] toArray() {
|
||||
int num = checkVector(_channels, _depth);
|
||||
if(num < 0)
|
||||
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
|
||||
float[] a = new float[num * _channels];
|
||||
if(num == 0)
|
||||
return a;
|
||||
get(0, 0, a); //TODO: check ret val!
|
||||
return a;
|
||||
}
|
||||
|
||||
public void fromList(List<Float> lb) {
|
||||
if(lb==null || lb.size()==0)
|
||||
return;
|
||||
Float ab[] = lb.toArray(new Float[0]);
|
||||
float a[] = new float[ab.length];
|
||||
for(int i=0; i<ab.length; i++)
|
||||
a[i] = ab[i];
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public List<Float> toList() {
|
||||
float[] a = toArray();
|
||||
Float ab[] = new Float[a.length];
|
||||
for(int i=0; i<a.length; i++)
|
||||
ab[i] = a[i];
|
||||
return Arrays.asList(ab);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package org.opencv.core;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class MatOfFloat6 extends Mat {
|
||||
// 32FC6
|
||||
private static final int _depth = CvType.CV_32F;
|
||||
private static final int _channels = 6;
|
||||
|
||||
public MatOfFloat6() {
|
||||
super();
|
||||
}
|
||||
|
||||
protected MatOfFloat6(long addr) {
|
||||
super(addr);
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public static MatOfFloat6 fromNativeAddr(long addr) {
|
||||
return new MatOfFloat6(addr);
|
||||
}
|
||||
|
||||
public MatOfFloat6(Mat m) {
|
||||
super(m, Range.all());
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public MatOfFloat6(float...a) {
|
||||
super();
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public void alloc(int elemNumber) {
|
||||
if(elemNumber>0)
|
||||
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
|
||||
}
|
||||
|
||||
public void fromArray(float...a) {
|
||||
if(a==null || a.length==0)
|
||||
return;
|
||||
int num = a.length / _channels;
|
||||
alloc(num);
|
||||
put(0, 0, a); //TODO: check ret val!
|
||||
}
|
||||
|
||||
public float[] toArray() {
|
||||
int num = checkVector(_channels, _depth);
|
||||
if(num < 0)
|
||||
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
|
||||
float[] a = new float[num * _channels];
|
||||
if(num == 0)
|
||||
return a;
|
||||
get(0, 0, a); //TODO: check ret val!
|
||||
return a;
|
||||
}
|
||||
|
||||
public void fromList(List<Float> lb) {
|
||||
if(lb==null || lb.size()==0)
|
||||
return;
|
||||
Float ab[] = lb.toArray(new Float[0]);
|
||||
float a[] = new float[ab.length];
|
||||
for(int i=0; i<ab.length; i++)
|
||||
a[i] = ab[i];
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public List<Float> toList() {
|
||||
float[] a = toArray();
|
||||
Float ab[] = new Float[a.length];
|
||||
for(int i=0; i<a.length; i++)
|
||||
ab[i] = a[i];
|
||||
return Arrays.asList(ab);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package org.opencv.core;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
|
||||
public class MatOfInt4 extends Mat {
|
||||
// 32SC4
|
||||
private static final int _depth = CvType.CV_32S;
|
||||
private static final int _channels = 4;
|
||||
|
||||
public MatOfInt4() {
|
||||
super();
|
||||
}
|
||||
|
||||
protected MatOfInt4(long addr) {
|
||||
super(addr);
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public static MatOfInt4 fromNativeAddr(long addr) {
|
||||
return new MatOfInt4(addr);
|
||||
}
|
||||
|
||||
public MatOfInt4(Mat m) {
|
||||
super(m, Range.all());
|
||||
if(checkVector(_channels, _depth) < 0 )
|
||||
throw new IllegalArgumentException("Incomatible Mat");
|
||||
//FIXME: do we need release() here?
|
||||
}
|
||||
|
||||
public MatOfInt4(int...a) {
|
||||
super();
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public void alloc(int elemNumber) {
|
||||
if(elemNumber>0)
|
||||
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
|
||||
}
|
||||
|
||||
public void fromArray(int...a) {
|
||||
if(a==null || a.length==0)
|
||||
return;
|
||||
int num = a.length / _channels;
|
||||
alloc(num);
|
||||
put(0, 0, a); //TODO: check ret val!
|
||||
}
|
||||
|
||||
public int[] toArray() {
|
||||
int num = checkVector(_channels, _depth);
|
||||
if(num < 0)
|
||||
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
|
||||
int[] a = new int[num * _channels];
|
||||
if(num == 0)
|
||||
return a;
|
||||
get(0, 0, a); //TODO: check ret val!
|
||||
return a;
|
||||
}
|
||||
|
||||
public void fromList(List<Integer> lb) {
|
||||
if(lb==null || lb.size()==0)
|
||||
return;
|
||||
Integer ab[] = lb.toArray(new Integer[0]);
|
||||
int a[] = new int[ab.length];
|
||||
for(int i=0; i<ab.length; i++)
|
||||
a[i] = ab[i];
|
||||
fromArray(a);
|
||||
}
|
||||
|
||||
public List<Integer> toList() {
|
||||
int[] a = toArray();
|
||||
Integer ab[] = new Integer[a.length];
|
||||
for(int i=0; i<a.length; i++)
|
||||
ab[i] = a[i];
|
||||
return Arrays.asList(ab);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ import org.opencv.core.MatOfDMatch;
|
||||
import org.opencv.core.MatOfKeyPoint;
|
||||
import org.opencv.core.MatOfPoint;
|
||||
import org.opencv.core.MatOfPoint2f;
|
||||
import org.opencv.core.MatOfPoint3f;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Point3;
|
||||
import org.opencv.core.Rect;
|
||||
@@ -519,6 +520,50 @@ public class Converters {
|
||||
}
|
||||
}
|
||||
|
||||
// vector_vector_Point2f
|
||||
public static Mat vector_vector_Point2f_to_Mat(List<MatOfPoint2f> pts, List<Mat> mats) {
|
||||
Mat res;
|
||||
int lCount = (pts != null) ? pts.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfPoint2f vpt : pts)
|
||||
mats.add(vpt);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
// vector_vector_Point3f
|
||||
public static void Mat_to_vector_vector_Point3f(Mat m, List<MatOfPoint3f> pts) {
|
||||
if (pts == null)
|
||||
throw new java.lang.IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new java.lang.IllegalArgumentException("Input Mat can't be null");
|
||||
|
||||
List<Mat> mats = new ArrayList<Mat>(m.rows());
|
||||
Mat_to_vector_Mat(m, mats);
|
||||
for (Mat mi : mats) {
|
||||
MatOfPoint3f pt = new MatOfPoint3f(mi);
|
||||
pts.add(pt);
|
||||
}
|
||||
}
|
||||
|
||||
// vector_vector_Point3f
|
||||
public static Mat vector_vector_Point3f_to_Mat(List<MatOfPoint3f> pts, List<Mat> mats) {
|
||||
Mat res;
|
||||
int lCount = (pts != null) ? pts.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfPoint3f vpt : pts)
|
||||
mats.add(vpt);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
// vector_vector_KeyPoint
|
||||
public static Mat vector_vector_KeyPoint_to_Mat(List<MatOfKeyPoint> kps, List<Mat> mats) {
|
||||
Mat res;
|
||||
|
||||
Reference in New Issue
Block a user