mirror of
https://gitcode.com/gh_mirrors/es/esp32-opencv.git
synced 2025-08-15 11:10:24 +08:00
initial commit
This commit is contained in:
Joachim
2767
modules/java/generator/src/cpp/Mat.cpp
Normal file
2767
modules/java/generator/src/cpp/Mat.cpp
Normal file
File diff suppressed because it is too large
Load Diff
42
modules/java/generator/src/cpp/common.h
Normal file
42
modules/java/generator/src/cpp/common.h
Normal file
@ -0,0 +1,42 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#ifndef __OPENCV_JAVA_COMMON_H__
|
||||
#define __OPENCV_JAVA_COMMON_H__
|
||||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
extern "C" {
|
||||
|
||||
#if !defined(__ppc__)
|
||||
// to suppress warning from jni.h on OS X
|
||||
# define TARGET_RT_MAC_CFM 0
|
||||
#endif
|
||||
#include <jni.h>
|
||||
|
||||
// make -fvisibility=hidden work with java 1.7
|
||||
#if defined(__linux__) && !defined(__ANDROID__) && !defined (JNI_VERSION_1_8)
|
||||
// adapted from jdk1.8/jni.h
|
||||
#if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility)
|
||||
#undef JNIEXPORT
|
||||
#define JNIEXPORT __attribute__((visibility("default")))
|
||||
#undef JNIIMPORT
|
||||
#define JNIIMPORT __attribute__((visibility("default")))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
} // extern "C"
|
||||
|
||||
#include "opencv_java.hpp"
|
||||
#include "opencv2/core/utility.hpp"
|
||||
|
||||
#include "converters.h"
|
||||
#include "listconverters.hpp"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(disable:4800 4244)
|
||||
#endif
|
||||
|
||||
#endif //__OPENCV_JAVA_COMMON_H__
|
||||
352
modules/java/generator/src/cpp/converters.cpp
Normal file
352
modules/java/generator/src/cpp/converters.cpp
Normal file
@ -0,0 +1,352 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#define LOG_TAG "org.opencv.utils.Converters"
|
||||
#include "common.h"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
// vector_int
|
||||
|
||||
void Mat_to_vector_int(Mat& mat, std::vector<int>& v_int)
|
||||
{
|
||||
v_int.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1);
|
||||
v_int = (std::vector<int>) mat;
|
||||
}
|
||||
|
||||
void vector_int_to_Mat(std::vector<int>& v_int, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_int, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_double
|
||||
|
||||
void Mat_to_vector_double(Mat& mat, std::vector<double>& v_double)
|
||||
{
|
||||
v_double.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1);
|
||||
v_double = (std::vector<double>) mat;
|
||||
}
|
||||
|
||||
void vector_double_to_Mat(std::vector<double>& v_double, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_double, true);
|
||||
}
|
||||
|
||||
|
||||
// vector_float
|
||||
|
||||
void Mat_to_vector_float(Mat& mat, std::vector<float>& v_float)
|
||||
{
|
||||
v_float.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1);
|
||||
v_float = (std::vector<float>) mat;
|
||||
}
|
||||
|
||||
void vector_float_to_Mat(std::vector<float>& v_float, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_float, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_uchar
|
||||
|
||||
void Mat_to_vector_uchar(Mat& mat, std::vector<uchar>& v_uchar)
|
||||
{
|
||||
v_uchar.clear();
|
||||
CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1);
|
||||
v_uchar = (std::vector<uchar>) mat;
|
||||
}
|
||||
|
||||
void vector_uchar_to_Mat(std::vector<uchar>& v_uchar, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_uchar, true);
|
||||
}
|
||||
|
||||
void Mat_to_vector_char(Mat& mat, std::vector<char>& v_char)
|
||||
{
|
||||
v_char.clear();
|
||||
CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1);
|
||||
v_char = (std::vector<char>) mat;
|
||||
}
|
||||
|
||||
void vector_char_to_Mat(std::vector<char>& v_char, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_char, true);
|
||||
}
|
||||
|
||||
|
||||
//vector_Rect
|
||||
|
||||
void Mat_to_vector_Rect(Mat& mat, std::vector<Rect>& v_rect)
|
||||
{
|
||||
v_rect.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1);
|
||||
v_rect = (std::vector<Rect>) mat;
|
||||
}
|
||||
|
||||
void vector_Rect_to_Mat(std::vector<Rect>& v_rect, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_rect, true);
|
||||
}
|
||||
|
||||
//vector_Rect2d
|
||||
|
||||
void Mat_to_vector_Rect2d(Mat& mat, std::vector<Rect2d>& v_rect)
|
||||
{
|
||||
v_rect.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC4 && mat.cols==1);
|
||||
v_rect = (std::vector<Rect2d>) mat;
|
||||
}
|
||||
|
||||
void vector_Rect2d_to_Mat(std::vector<Rect2d>& v_rect, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_rect, true);
|
||||
}
|
||||
|
||||
//vector_RotatedRect
|
||||
|
||||
void Mat_to_vector_RotatedRect(Mat& mat, std::vector<RotatedRect>& v_rect)
|
||||
{
|
||||
v_rect.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC(5) && mat.cols==1);
|
||||
v_rect = (std::vector<RotatedRect>) mat;
|
||||
}
|
||||
|
||||
void vector_RotatedRect_to_Mat(std::vector<RotatedRect>& v_rect, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_rect, true);
|
||||
}
|
||||
|
||||
//vector_Point
|
||||
void Mat_to_vector_Point(Mat& mat, std::vector<Point>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1);
|
||||
v_point = (std::vector<Point>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2f
|
||||
void Mat_to_vector_Point2f(Mat& mat, std::vector<Point2f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1);
|
||||
v_point = (std::vector<Point2f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point2d
|
||||
void Mat_to_vector_Point2d(Mat& mat, std::vector<Point2d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1);
|
||||
v_point = (std::vector<Point2d>) mat;
|
||||
}
|
||||
|
||||
|
||||
//vector_Point3i
|
||||
void Mat_to_vector_Point3i(Mat& mat, std::vector<Point3i>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1);
|
||||
v_point = (std::vector<Point3i>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3f
|
||||
void Mat_to_vector_Point3f(Mat& mat, std::vector<Point3f>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1);
|
||||
v_point = (std::vector<Point3f>) mat;
|
||||
}
|
||||
|
||||
//vector_Point3d
|
||||
void Mat_to_vector_Point3d(Mat& mat, std::vector<Point3d>& v_point)
|
||||
{
|
||||
v_point.clear();
|
||||
CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1);
|
||||
v_point = (std::vector<Point3d>) mat;
|
||||
}
|
||||
|
||||
|
||||
void vector_Point_to_Mat(std::vector<Point>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2f_to_Mat(std::vector<Point2f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point2d_to_Mat(std::vector<Point2d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3i_to_Mat(std::vector<Point3i>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3f_to_Mat(std::vector<Point3f>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
void vector_Point3d_to_Mat(std::vector<Point3d>& v_point, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_point, true);
|
||||
}
|
||||
|
||||
//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]&0xffffffff);
|
||||
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 = (int)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);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_Point(Mat& mat, std::vector< std::vector< Point > >& vv_pt)
|
||||
{
|
||||
std::vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
std::vector<Point> vpt;
|
||||
Mat_to_vector_Point(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_Point2f(Mat& mat, std::vector< std::vector< Point2f > >& vv_pt)
|
||||
{
|
||||
std::vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
std::vector<Point2f> vpt;
|
||||
Mat_to_vector_Point2f(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_Point3f(Mat& mat, std::vector< std::vector< Point3f > >& vv_pt)
|
||||
{
|
||||
std::vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
std::vector<Point3f> vpt;
|
||||
Mat_to_vector_Point3f(vm[i], vpt);
|
||||
vv_pt.push_back(vpt);
|
||||
}
|
||||
}
|
||||
|
||||
void Mat_to_vector_vector_char(Mat& mat, std::vector< std::vector< char > >& vv_ch)
|
||||
{
|
||||
std::vector<Mat> vm;
|
||||
vm.reserve( mat.rows );
|
||||
Mat_to_vector_Mat(mat, vm);
|
||||
for(size_t i=0; i<vm.size(); i++)
|
||||
{
|
||||
std::vector<char> vch;
|
||||
Mat_to_vector_char(vm[i], vch);
|
||||
vv_ch.push_back(vch);
|
||||
}
|
||||
}
|
||||
|
||||
void vector_vector_char_to_Mat(std::vector< std::vector< char > >& vv_ch, Mat& mat)
|
||||
{
|
||||
std::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(std::vector< std::vector< Point > >& vv_pt, Mat& mat)
|
||||
{
|
||||
std::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(std::vector< std::vector< Point2f > >& vv_pt, Mat& mat)
|
||||
{
|
||||
std::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_Point3f_to_Mat(std::vector< std::vector< Point3f > >& vv_pt, Mat& mat)
|
||||
{
|
||||
std::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(std::vector<Vec4i>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
void vector_Vec4f_to_Mat(std::vector<Vec4f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
|
||||
void vector_Vec6f_to_Mat(std::vector<Vec6f>& v_vec, Mat& mat)
|
||||
{
|
||||
mat = Mat(v_vec, true);
|
||||
}
|
||||
63
modules/java/generator/src/cpp/converters.h
Normal file
63
modules/java/generator/src/cpp/converters.h
Normal file
@ -0,0 +1,63 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#include "opencv2/opencv_modules.hpp"
|
||||
#include "opencv2/core.hpp"
|
||||
|
||||
void Mat_to_vector_int(cv::Mat& mat, std::vector<int>& v_int);
|
||||
void vector_int_to_Mat(std::vector<int>& v_int, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_double(cv::Mat& mat, std::vector<double>& v_double);
|
||||
void vector_double_to_Mat(std::vector<double>& v_double, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_float(cv::Mat& mat, std::vector<float>& v_float);
|
||||
void vector_float_to_Mat(std::vector<float>& v_float, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_uchar(cv::Mat& mat, std::vector<uchar>& v_uchar);
|
||||
void vector_uchar_to_Mat(std::vector<uchar>& v_uchar, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_char(cv::Mat& mat, std::vector<char>& v_char);
|
||||
void vector_char_to_Mat(std::vector<char>& v_char, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_Rect(cv::Mat& mat, std::vector<cv::Rect>& v_rect);
|
||||
void vector_Rect_to_Mat(std::vector<cv::Rect>& v_rect, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_Rect2d(cv::Mat& mat, std::vector<cv::Rect2d>& v_rect);
|
||||
void vector_Rect2d_to_Mat(std::vector<cv::Rect2d>& v_rect, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_RotatedRect(cv::Mat& mat, std::vector<cv::RotatedRect>& v_rect);
|
||||
void vector_RotatedRect_to_Mat(std::vector<cv::RotatedRect>& v_rect, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_Point(cv::Mat& mat, std::vector<cv::Point>& v_point);
|
||||
void Mat_to_vector_Point2f(cv::Mat& mat, std::vector<cv::Point2f>& v_point);
|
||||
void Mat_to_vector_Point2d(cv::Mat& mat, std::vector<cv::Point2d>& v_point);
|
||||
void Mat_to_vector_Point3i(cv::Mat& mat, std::vector<cv::Point3i>& v_point);
|
||||
void Mat_to_vector_Point3f(cv::Mat& mat, std::vector<cv::Point3f>& v_point);
|
||||
void Mat_to_vector_Point3d(cv::Mat& mat, std::vector<cv::Point3d>& v_point);
|
||||
|
||||
void vector_Point_to_Mat(std::vector<cv::Point>& v_point, cv::Mat& mat);
|
||||
void vector_Point2f_to_Mat(std::vector<cv::Point2f>& v_point, cv::Mat& mat);
|
||||
void vector_Point2d_to_Mat(std::vector<cv::Point2d>& v_point, cv::Mat& mat);
|
||||
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);
|
||||
|
||||
void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat);
|
||||
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat);
|
||||
|
||||
void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >& vv_ch);
|
||||
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 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);
|
||||
42
modules/java/generator/src/cpp/jni_part.cpp
Normal file
42
modules/java/generator/src/cpp/jni_part.cpp
Normal file
@ -0,0 +1,42 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#include "opencv2/opencv_modules.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D
|
||||
# include "opencv2/features2d.hpp"
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
# include "opencv2/video.hpp"
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_OPENCV_CONTRIB
|
||||
# include "opencv2/contrib.hpp"
|
||||
#endif
|
||||
|
||||
extern "C" {
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JNI_OnLoad(JavaVM* vm, void* )
|
||||
{
|
||||
JNIEnv* env;
|
||||
if (vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK)
|
||||
return -1;
|
||||
|
||||
/* get class with (*env)->FindClass */
|
||||
/* register methods with (*env)->RegisterNatives */
|
||||
|
||||
return JNI_VERSION_1_6;
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JNI_OnUnload(JavaVM*, void*)
|
||||
{
|
||||
//do nothing
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
110
modules/java/generator/src/cpp/listconverters.cpp
Normal file
110
modules/java/generator/src/cpp/listconverters.cpp
Normal file
@ -0,0 +1,110 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
// Author: abratchik
|
||||
|
||||
#define LOG_TAG "org.opencv.utils.Converters"
|
||||
#include "common.h"
|
||||
|
||||
|
||||
jobject vector_String_to_List(JNIEnv* env, std::vector<cv::String>& vs) {
|
||||
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
|
||||
jmethodID m_add = LIST_ADD(env, juArrayList);
|
||||
|
||||
jobject result = env->NewObject(juArrayList, m_create, vs.size());
|
||||
for (std::vector<cv::String>::iterator it = vs.begin(); it != vs.end(); ++it) {
|
||||
jstring element = env->NewStringUTF((*it).c_str());
|
||||
env->CallBooleanMethod(result, m_add, element);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<cv::String> List_to_vector_String(JNIEnv* env, jobject list)
|
||||
{
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
jmethodID m_size = LIST_SIZE(env,juArrayList);
|
||||
jmethodID m_get = LIST_GET(env, juArrayList);
|
||||
|
||||
jint len = env->CallIntMethod(list, m_size);
|
||||
std::vector<cv::String> result;
|
||||
result.reserve(len);
|
||||
for (jint i=0; i<len; i++)
|
||||
{
|
||||
jstring element = static_cast<jstring>(env->CallObjectMethod(list, m_get, i));
|
||||
const char* pchars = env->GetStringUTFChars(element, NULL);
|
||||
result.push_back(pchars);
|
||||
env->ReleaseStringUTFChars(element, pchars);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void Copy_vector_String_to_List(JNIEnv* env, std::vector<cv::String>& vs, jobject list)
|
||||
{
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
jmethodID m_clear = LIST_CLEAR(env, juArrayList);
|
||||
jmethodID m_add = LIST_ADD(env, juArrayList);
|
||||
|
||||
env->CallVoidMethod(list, m_clear);
|
||||
for (std::vector<cv::String>::iterator it = vs.begin(); it != vs.end(); ++it)
|
||||
{
|
||||
jstring element = env->NewStringUTF((*it).c_str());
|
||||
env->CallBooleanMethod(list, m_add, element);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
jobject vector_string_to_List(JNIEnv* env, std::vector<std::string>& vs) {
|
||||
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
|
||||
jmethodID m_add = LIST_ADD(env, juArrayList);
|
||||
|
||||
jobject result = env->NewObject(juArrayList, m_create, vs.size());
|
||||
for (std::vector<std::string>::iterator it = vs.begin(); it != vs.end(); ++it) {
|
||||
jstring element = env->NewStringUTF((*it).c_str());
|
||||
env->CallBooleanMethod(result, m_add, element);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::string> List_to_vector_string(JNIEnv* env, jobject list)
|
||||
{
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
jmethodID m_size = LIST_SIZE(env,juArrayList);
|
||||
jmethodID m_get = LIST_GET(env, juArrayList);
|
||||
|
||||
jint len = env->CallIntMethod(list, m_size);
|
||||
std::vector<std::string> result;
|
||||
result.reserve(len);
|
||||
for (jint i=0; i<len; i++)
|
||||
{
|
||||
jstring element = static_cast<jstring>(env->CallObjectMethod(list, m_get, i));
|
||||
const char* pchars = env->GetStringUTFChars(element, NULL);
|
||||
result.push_back(pchars);
|
||||
env->ReleaseStringUTFChars(element, pchars);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void Copy_vector_string_to_List(JNIEnv* env, std::vector<std::string>& vs, jobject list)
|
||||
{
|
||||
static jclass juArrayList = ARRAYLIST(env);
|
||||
jmethodID m_clear = LIST_CLEAR(env, juArrayList);
|
||||
jmethodID m_add = LIST_ADD(env, juArrayList);
|
||||
|
||||
env->CallVoidMethod(list, m_clear);
|
||||
for (std::vector<std::string>::iterator it = vs.begin(); it != vs.end(); ++it)
|
||||
{
|
||||
jstring element = env->NewStringUTF((*it).c_str());
|
||||
env->CallBooleanMethod(list, m_add, element);
|
||||
env->DeleteLocalRef(element);
|
||||
}
|
||||
}
|
||||
26
modules/java/generator/src/cpp/listconverters.hpp
Normal file
26
modules/java/generator/src/cpp/listconverters.hpp
Normal file
@ -0,0 +1,26 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
// Author: abratchik
|
||||
|
||||
#ifndef LISTCONVERTERS_HPP
|
||||
#define LISTCONVERTERS_HPP
|
||||
|
||||
#include "opencv2/opencv_modules.hpp"
|
||||
#include "opencv2/core.hpp"
|
||||
|
||||
jobject vector_String_to_List(JNIEnv* env, std::vector<cv::String>& vs);
|
||||
|
||||
std::vector<cv::String> List_to_vector_String(JNIEnv* env, jobject list);
|
||||
|
||||
void Copy_vector_String_to_List(JNIEnv* env, std::vector<cv::String>& vs, jobject list);
|
||||
|
||||
|
||||
jobject vector_string_to_List(JNIEnv* env, std::vector<std::string>& vs);
|
||||
|
||||
std::vector<std::string> List_to_vector_string(JNIEnv* env, jobject list);
|
||||
|
||||
void Copy_vector_string_to_List(JNIEnv* env, std::vector<std::string>& vs, jobject list);
|
||||
|
||||
#endif /* LISTCONVERTERS_HPP */
|
||||
8
modules/java/generator/src/cpp/opencv_java.cpp
Normal file
8
modules/java/generator/src/cpp/opencv_java.cpp
Normal file
@ -0,0 +1,8 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#include "common.h"
|
||||
|
||||
// Include all generated JNI code
|
||||
#include "opencv_jni.hpp"
|
||||
38
modules/java/generator/src/cpp/opencv_java.hpp
Normal file
38
modules/java/generator/src/cpp/opencv_java.hpp
Normal file
@ -0,0 +1,38 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
// Author: abratchik
|
||||
|
||||
#undef LOGE
|
||||
#undef LOGD
|
||||
#ifdef __ANDROID__
|
||||
# include <android/log.h>
|
||||
# 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
|
||||
# define LOGD(...)
|
||||
# endif
|
||||
#else
|
||||
# define LOGE(...)
|
||||
# define LOGD(...)
|
||||
#endif
|
||||
|
||||
#ifndef OPENCV_JAVA_HPP
|
||||
#define OPENCV_JAVA_HPP
|
||||
|
||||
#define MATOFINT(ENV) static_cast<jclass>(ENV->NewGlobalRef(ENV->FindClass("org/opencv/core/MatOfInt")))
|
||||
#define GETNATIVEOBJ(ENV, CLS, MAT) ENV->GetLongField(MAT, ENV->GetFieldID(CLS, "nativeObj", "J"))
|
||||
|
||||
#define CONSTRUCTOR(ENV, CLS) ENV->GetMethodID(CLS, "<init>", "(I)V")
|
||||
|
||||
#define ARRAYLIST(ENV) static_cast<jclass>(ENV->NewGlobalRef(ENV->FindClass("java/util/ArrayList")))
|
||||
#define LIST_ADD(ENV, LIST) ENV->GetMethodID(LIST, "add", "(Ljava/lang/Object;)Z")
|
||||
#define LIST_GET(ENV, LIST) ENV->GetMethodID(LIST, "get", "(I)Ljava/lang/Object;")
|
||||
#define LIST_SIZE(ENV, LIST) ENV->GetMethodID(LIST, "size", "()I")
|
||||
#define LIST_CLEAR(ENV, LIST) ENV->GetMethodID(LIST, "clear", "()V")
|
||||
|
||||
#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
|
||||
|
||||
#endif // OPENCV_JAVA_HPP
|
||||
165
modules/java/generator/src/cpp/utils.cpp
Normal file
165
modules/java/generator/src/cpp/utils.cpp
Normal file
@ -0,0 +1,165 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#include "opencv2/core.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
|
||||
#ifdef __ANDROID__
|
||||
#include <android/bitmap.h>
|
||||
|
||||
#define LOG_TAG "org.opencv.android.Utils"
|
||||
#include "common.h"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
extern "C" {
|
||||
|
||||
/*
|
||||
* Class: org_opencv_android_Utils
|
||||
* Method: void nBitmapToMat2(Bitmap b, long m_addr, boolean unPremultiplyAlpha)
|
||||
*/
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nBitmapToMat2
|
||||
(JNIEnv * env, jclass, jobject bitmap, jlong m_addr, jboolean needUnPremultiplyAlpha);
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nBitmapToMat2
|
||||
(JNIEnv * env, jclass, jobject bitmap, jlong m_addr, jboolean needUnPremultiplyAlpha)
|
||||
{
|
||||
AndroidBitmapInfo info;
|
||||
void* pixels = 0;
|
||||
Mat& dst = *((Mat*)m_addr);
|
||||
|
||||
try {
|
||||
LOGD("nBitmapToMat");
|
||||
CV_Assert( AndroidBitmap_getInfo(env, bitmap, &info) >= 0 );
|
||||
CV_Assert( info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 ||
|
||||
info.format == ANDROID_BITMAP_FORMAT_RGB_565 );
|
||||
CV_Assert( AndroidBitmap_lockPixels(env, bitmap, &pixels) >= 0 );
|
||||
CV_Assert( pixels );
|
||||
dst.create(info.height, info.width, CV_8UC4);
|
||||
if( info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 )
|
||||
{
|
||||
LOGD("nBitmapToMat: RGBA_8888 -> CV_8UC4");
|
||||
Mat tmp(info.height, info.width, CV_8UC4, pixels);
|
||||
if(needUnPremultiplyAlpha) cvtColor(tmp, dst, COLOR_mRGBA2RGBA);
|
||||
else tmp.copyTo(dst);
|
||||
} else {
|
||||
// info.format == ANDROID_BITMAP_FORMAT_RGB_565
|
||||
LOGD("nBitmapToMat: RGB_565 -> CV_8UC4");
|
||||
Mat tmp(info.height, info.width, CV_8UC2, pixels);
|
||||
cvtColor(tmp, dst, COLOR_BGR5652RGBA);
|
||||
}
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
return;
|
||||
} catch(const cv::Exception& e) {
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
LOGE("nBitmapToMat caught 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;
|
||||
} catch (...) {
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
LOGE("nBitmapToMat caught unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {nBitmapToMat}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// old signature is left for binary compatibility with 2.4.0 & 2.4.1, to removed in 2.5
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nBitmapToMat
|
||||
(JNIEnv * env, jclass, jobject bitmap, jlong m_addr);
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nBitmapToMat
|
||||
(JNIEnv * env, jclass, jobject bitmap, jlong m_addr)
|
||||
{
|
||||
Java_org_opencv_android_Utils_nBitmapToMat2(env, 0, bitmap, m_addr, false);
|
||||
}
|
||||
|
||||
/*
|
||||
* Class: org_opencv_android_Utils
|
||||
* Method: void nMatToBitmap2(long m_addr, Bitmap b, boolean premultiplyAlpha)
|
||||
*/
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nMatToBitmap2
|
||||
(JNIEnv * env, jclass, jlong m_addr, jobject bitmap, jboolean needPremultiplyAlpha);
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nMatToBitmap2
|
||||
(JNIEnv * env, jclass, jlong m_addr, jobject bitmap, jboolean needPremultiplyAlpha)
|
||||
{
|
||||
AndroidBitmapInfo info;
|
||||
void* pixels = 0;
|
||||
Mat& src = *((Mat*)m_addr);
|
||||
|
||||
try {
|
||||
LOGD("nMatToBitmap");
|
||||
CV_Assert( AndroidBitmap_getInfo(env, bitmap, &info) >= 0 );
|
||||
CV_Assert( info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 ||
|
||||
info.format == ANDROID_BITMAP_FORMAT_RGB_565 );
|
||||
CV_Assert( src.dims == 2 && info.height == (uint32_t)src.rows && info.width == (uint32_t)src.cols );
|
||||
CV_Assert( src.type() == CV_8UC1 || src.type() == CV_8UC3 || src.type() == CV_8UC4 );
|
||||
CV_Assert( AndroidBitmap_lockPixels(env, bitmap, &pixels) >= 0 );
|
||||
CV_Assert( pixels );
|
||||
if( info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 )
|
||||
{
|
||||
Mat tmp(info.height, info.width, CV_8UC4, pixels);
|
||||
if(src.type() == CV_8UC1)
|
||||
{
|
||||
LOGD("nMatToBitmap: CV_8UC1 -> RGBA_8888");
|
||||
cvtColor(src, tmp, COLOR_GRAY2RGBA);
|
||||
} else if(src.type() == CV_8UC3){
|
||||
LOGD("nMatToBitmap: CV_8UC3 -> RGBA_8888");
|
||||
cvtColor(src, tmp, COLOR_RGB2RGBA);
|
||||
} else if(src.type() == CV_8UC4){
|
||||
LOGD("nMatToBitmap: CV_8UC4 -> RGBA_8888");
|
||||
if(needPremultiplyAlpha) cvtColor(src, tmp, COLOR_RGBA2mRGBA);
|
||||
else src.copyTo(tmp);
|
||||
}
|
||||
} else {
|
||||
// info.format == ANDROID_BITMAP_FORMAT_RGB_565
|
||||
Mat tmp(info.height, info.width, CV_8UC2, pixels);
|
||||
if(src.type() == CV_8UC1)
|
||||
{
|
||||
LOGD("nMatToBitmap: CV_8UC1 -> RGB_565");
|
||||
cvtColor(src, tmp, COLOR_GRAY2BGR565);
|
||||
} else if(src.type() == CV_8UC3){
|
||||
LOGD("nMatToBitmap: CV_8UC3 -> RGB_565");
|
||||
cvtColor(src, tmp, COLOR_RGB2BGR565);
|
||||
} else if(src.type() == CV_8UC4){
|
||||
LOGD("nMatToBitmap: CV_8UC4 -> RGB_565");
|
||||
cvtColor(src, tmp, COLOR_RGBA2BGR565);
|
||||
}
|
||||
}
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
return;
|
||||
} catch(const cv::Exception& e) {
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
LOGE("nMatToBitmap caught 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;
|
||||
} catch (...) {
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
LOGE("nMatToBitmap caught unknown exception (...)");
|
||||
jclass je = env->FindClass("java/lang/Exception");
|
||||
env->ThrowNew(je, "Unknown exception in JNI code {nMatToBitmap}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// old signature is left for binary compatibility with 2.4.0 & 2.4.1, to removed in 2.5
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nMatToBitmap
|
||||
(JNIEnv * env, jclass, jlong m_addr, jobject bitmap);
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nMatToBitmap
|
||||
(JNIEnv * env, jclass, jlong m_addr, jobject bitmap)
|
||||
{
|
||||
Java_org_opencv_android_Utils_nMatToBitmap2(env, 0, m_addr, bitmap, false);
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
|
||||
#endif //__ANDROID__
|
||||
@ -0,0 +1,8 @@
|
||||
package org.opencv.osgi;
|
||||
|
||||
/**
|
||||
* Dummy interface to allow some integration testing within OSGi implementation.
|
||||
*/
|
||||
public interface OpenCVInterface
|
||||
{
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
package org.opencv.osgi;
|
||||
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* This class is intended to provide a convenient way to load OpenCV's native
|
||||
* library from the Java bundle. If Blueprint is enabled in the OSGi container
|
||||
* this class will be instantiated automatically and the init() method called
|
||||
* loading the native library.
|
||||
*/
|
||||
public class OpenCVNativeLoader implements OpenCVInterface {
|
||||
|
||||
public void init() {
|
||||
System.loadLibrary("opencv_java@OPENCV_JAVA_LIB_NAME_SUFFIX@");
|
||||
Logger.getLogger("org.opencv.osgi").log(Level.INFO, "Successfully loaded OpenCV native library.");
|
||||
}
|
||||
}
|
||||
812
modules/java/generator/src/java/org/opencv/utils/Converters.java
Normal file
812
modules/java/generator/src/java/org/opencv/utils/Converters.java
Normal file
@ -0,0 +1,812 @@
|
||||
package org.opencv.utils;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfByte;
|
||||
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.Size;
|
||||
import org.opencv.core.Rect;
|
||||
import org.opencv.core.RotatedRect;
|
||||
import org.opencv.core.Rect2d;
|
||||
import org.opencv.core.DMatch;
|
||||
import org.opencv.core.KeyPoint;
|
||||
|
||||
public class Converters {
|
||||
|
||||
public static Mat vector_Point_to_Mat(List<Point> pts) {
|
||||
return vector_Point_to_Mat(pts, CvType.CV_32S);
|
||||
}
|
||||
|
||||
public static Mat vector_Point2f_to_Mat(List<Point> pts) {
|
||||
return vector_Point_to_Mat(pts, CvType.CV_32F);
|
||||
}
|
||||
|
||||
public static Mat vector_Point2d_to_Mat(List<Point> pts) {
|
||||
return vector_Point_to_Mat(pts, CvType.CV_64F);
|
||||
}
|
||||
|
||||
public static Mat vector_Point_to_Mat(List<Point> pts, int typeDepth) {
|
||||
Mat res;
|
||||
int count = (pts != null) ? pts.size() : 0;
|
||||
if (count > 0) {
|
||||
switch (typeDepth) {
|
||||
case CvType.CV_32S: {
|
||||
res = new Mat(count, 1, CvType.CV_32SC2);
|
||||
int[] buff = new int[count * 2];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point p = pts.get(i);
|
||||
buff[i * 2] = (int) p.x;
|
||||
buff[i * 2 + 1] = (int) p.y;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
case CvType.CV_32F: {
|
||||
res = new Mat(count, 1, CvType.CV_32FC2);
|
||||
float[] buff = new float[count * 2];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point p = pts.get(i);
|
||||
buff[i * 2] = (float) p.x;
|
||||
buff[i * 2 + 1] = (float) p.y;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
case CvType.CV_64F: {
|
||||
res = new Mat(count, 1, CvType.CV_64FC2);
|
||||
double[] buff = new double[count * 2];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point p = pts.get(i);
|
||||
buff[i * 2] = p.x;
|
||||
buff[i * 2 + 1] = p.y;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
|
||||
}
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static Mat vector_Point3i_to_Mat(List<Point3> pts) {
|
||||
return vector_Point3_to_Mat(pts, CvType.CV_32S);
|
||||
}
|
||||
|
||||
public static Mat vector_Point3f_to_Mat(List<Point3> pts) {
|
||||
return vector_Point3_to_Mat(pts, CvType.CV_32F);
|
||||
}
|
||||
|
||||
public static Mat vector_Point3d_to_Mat(List<Point3> pts) {
|
||||
return vector_Point3_to_Mat(pts, CvType.CV_64F);
|
||||
}
|
||||
|
||||
public static Mat vector_Point3_to_Mat(List<Point3> pts, int typeDepth) {
|
||||
Mat res;
|
||||
int count = (pts != null) ? pts.size() : 0;
|
||||
if (count > 0) {
|
||||
switch (typeDepth) {
|
||||
case CvType.CV_32S: {
|
||||
res = new Mat(count, 1, CvType.CV_32SC3);
|
||||
int[] buff = new int[count * 3];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point3 p = pts.get(i);
|
||||
buff[i * 3] = (int) p.x;
|
||||
buff[i * 3 + 1] = (int) p.y;
|
||||
buff[i * 3 + 2] = (int) p.z;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
case CvType.CV_32F: {
|
||||
res = new Mat(count, 1, CvType.CV_32FC3);
|
||||
float[] buff = new float[count * 3];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point3 p = pts.get(i);
|
||||
buff[i * 3] = (float) p.x;
|
||||
buff[i * 3 + 1] = (float) p.y;
|
||||
buff[i * 3 + 2] = (float) p.z;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
case CvType.CV_64F: {
|
||||
res = new Mat(count, 1, CvType.CV_64FC3);
|
||||
double[] buff = new double[count * 3];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Point3 p = pts.get(i);
|
||||
buff[i * 3] = p.x;
|
||||
buff[i * 3 + 1] = p.y;
|
||||
buff[i * 3 + 2] = p.z;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
|
||||
}
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point2f(Mat m, List<Point> pts) {
|
||||
Mat_to_vector_Point(m, pts);
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) {
|
||||
Mat_to_vector_Point(m, pts);
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point(Mat m, List<Point> pts) {
|
||||
if (pts == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
int type = m.type();
|
||||
if (m.cols() != 1)
|
||||
throw new IllegalArgumentException("Input Mat should have one column\n" + m);
|
||||
|
||||
pts.clear();
|
||||
if (type == CvType.CV_32SC2) {
|
||||
int[] buff = new int[2 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
|
||||
}
|
||||
} else if (type == CvType.CV_32FC2) {
|
||||
float[] buff = new float[2 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
|
||||
}
|
||||
} else if (type == CvType.CV_64FC2) {
|
||||
double[] buff = new double[2 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
|
||||
}
|
||||
} else {
|
||||
throw new IllegalArgumentException(
|
||||
"Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) {
|
||||
Mat_to_vector_Point3(m, pts);
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) {
|
||||
Mat_to_vector_Point3(m, pts);
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) {
|
||||
Mat_to_vector_Point3(m, pts);
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) {
|
||||
if (pts == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
int type = m.type();
|
||||
if (m.cols() != 1)
|
||||
throw new IllegalArgumentException("Input Mat should have one column\n" + m);
|
||||
|
||||
pts.clear();
|
||||
if (type == CvType.CV_32SC3) {
|
||||
int[] buff = new int[3 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
|
||||
}
|
||||
} else if (type == CvType.CV_32FC3) {
|
||||
float[] buff = new float[3 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
|
||||
}
|
||||
} else if (type == CvType.CV_64FC3) {
|
||||
double[] buff = new double[3 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
|
||||
}
|
||||
} else {
|
||||
throw new IllegalArgumentException(
|
||||
"Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m);
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_Mat_to_Mat(List<Mat> mats) {
|
||||
Mat res;
|
||||
int count = (mats != null) ? mats.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_32SC2);
|
||||
int[] buff = new int[count * 2];
|
||||
for (int i = 0; i < count; i++) {
|
||||
long addr = mats.get(i).nativeObj;
|
||||
buff[i * 2] = (int) (addr >> 32);
|
||||
buff[i * 2 + 1] = (int) (addr & 0xffffffff);
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Mat(Mat m, List<Mat> mats) {
|
||||
if (mats == null)
|
||||
throw new IllegalArgumentException("mats == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_32SC2 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_32SC2 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
mats.clear();
|
||||
int[] buff = new int[count * 2];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
long addr = (((long) buff[i * 2]) << 32) | (((long) buff[i * 2 + 1]) & 0xffffffffL);
|
||||
mats.add(new Mat(addr));
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_float_to_Mat(List<Float> fs) {
|
||||
Mat res;
|
||||
int count = (fs != null) ? fs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_32FC1);
|
||||
float[] buff = new float[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
float f = fs.get(i);
|
||||
buff[i] = f;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_float(Mat m, List<Float> fs) {
|
||||
if (fs == null)
|
||||
throw new IllegalArgumentException("fs == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_32FC1 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_32FC1 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
fs.clear();
|
||||
float[] buff = new float[count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
fs.add(buff[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_uchar_to_Mat(List<Byte> bs) {
|
||||
Mat res;
|
||||
int count = (bs != null) ? bs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_8UC1);
|
||||
byte[] buff = new byte[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
byte b = bs.get(i);
|
||||
buff[i] = b;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_uchar(Mat m, List<Byte> us) {
|
||||
if (us == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_8UC1 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_8UC1 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
us.clear();
|
||||
byte[] buff = new byte[count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
us.add(buff[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_char_to_Mat(List<Byte> bs) {
|
||||
Mat res;
|
||||
int count = (bs != null) ? bs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_8SC1);
|
||||
byte[] buff = new byte[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
byte b = bs.get(i);
|
||||
buff[i] = b;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static Mat vector_int_to_Mat(List<Integer> is) {
|
||||
Mat res;
|
||||
int count = (is != null) ? is.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_32SC1);
|
||||
int[] buff = new int[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
int v = is.get(i);
|
||||
buff[i] = v;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_int(Mat m, List<Integer> is) {
|
||||
if (is == null)
|
||||
throw new IllegalArgumentException("is == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_32SC1 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_32SC1 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
is.clear();
|
||||
int[] buff = new int[count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
is.add(buff[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_char(Mat m, List<Byte> bs) {
|
||||
if (bs == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_8SC1 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_8SC1 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
bs.clear();
|
||||
byte[] buff = new byte[count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
bs.add(buff[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_Rect_to_Mat(List<Rect> rs) {
|
||||
Mat res;
|
||||
int count = (rs != null) ? rs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_32SC4);
|
||||
int[] buff = new int[4 * count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Rect r = rs.get(i);
|
||||
buff[4 * i] = r.x;
|
||||
buff[4 * i + 1] = r.y;
|
||||
buff[4 * i + 2] = r.width;
|
||||
buff[4 * i + 3] = r.height;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Rect(Mat m, List<Rect> rs) {
|
||||
if (rs == null)
|
||||
throw new IllegalArgumentException("rs == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_32SC4 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_32SC4 != m.type() || m.rows()!=1\n" + m);
|
||||
|
||||
rs.clear();
|
||||
int[] buff = new int[4 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3]));
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_Rect2d_to_Mat(List<Rect2d> rs) {
|
||||
Mat res;
|
||||
int count = (rs != null) ? rs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_64FC4);
|
||||
double[] buff = new double[4 * count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
Rect2d r = rs.get(i);
|
||||
buff[4 * i] = r.x;
|
||||
buff[4 * i + 1] = r.y;
|
||||
buff[4 * i + 2] = r.width;
|
||||
buff[4 * i + 3] = r.height;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_Rect2d(Mat m, List<Rect2d> rs) {
|
||||
if (rs == null)
|
||||
throw new IllegalArgumentException("rs == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_64FC4 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_64FC4 != m.type() || m.rows()!=1\n" + m);
|
||||
|
||||
rs.clear();
|
||||
double[] buff = new double[4 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
rs.add(new Rect2d(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3]));
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_KeyPoint_to_Mat(List<KeyPoint> kps) {
|
||||
Mat res;
|
||||
int count = (kps != null) ? kps.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_64FC(7));
|
||||
double[] buff = new double[count * 7];
|
||||
for (int i = 0; i < count; i++) {
|
||||
KeyPoint kp = kps.get(i);
|
||||
buff[7 * i] = kp.pt.x;
|
||||
buff[7 * i + 1] = kp.pt.y;
|
||||
buff[7 * i + 2] = kp.size;
|
||||
buff[7 * i + 3] = kp.angle;
|
||||
buff[7 * i + 4] = kp.response;
|
||||
buff[7 * i + 5] = kp.octave;
|
||||
buff[7 * i + 6] = kp.class_id;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_KeyPoint(Mat m, List<KeyPoint> kps) {
|
||||
if (kps == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_64FC(7) != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_64FC(7) != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
kps.clear();
|
||||
double[] buff = new double[7 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3],
|
||||
(float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6]));
|
||||
}
|
||||
}
|
||||
|
||||
// vector_vector_Point
|
||||
public static Mat vector_vector_Point_to_Mat(List<MatOfPoint> pts, List<Mat> mats) {
|
||||
Mat res;
|
||||
int lCount = (pts != null) ? pts.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfPoint vpt : pts)
|
||||
mats.add(vpt);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_vector_Point(Mat m, List<MatOfPoint> pts) {
|
||||
if (pts == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new 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) {
|
||||
MatOfPoint pt = new MatOfPoint(mi);
|
||||
pts.add(pt);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
// vector_vector_Point2f
|
||||
public static void Mat_to_vector_vector_Point2f(Mat m, List<MatOfPoint2f> pts) {
|
||||
if (pts == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new 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) {
|
||||
MatOfPoint2f pt = new MatOfPoint2f(mi);
|
||||
pts.add(pt);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
// 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 IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new 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);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
// 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;
|
||||
int lCount = (kps != null) ? kps.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfKeyPoint vkp : kps)
|
||||
mats.add(vkp);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_vector_KeyPoint(Mat m, List<MatOfKeyPoint> kps) {
|
||||
if (kps == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new 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) {
|
||||
MatOfKeyPoint vkp = new MatOfKeyPoint(mi);
|
||||
kps.add(vkp);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
public static Mat vector_double_to_Mat(List<Double> ds) {
|
||||
Mat res;
|
||||
int count = (ds != null) ? ds.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_64FC1);
|
||||
double[] buff = new double[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
double v = ds.get(i);
|
||||
buff[i] = v;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_double(Mat m, List<Double> ds) {
|
||||
if (ds == null)
|
||||
throw new IllegalArgumentException("ds == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_64FC1 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_64FC1 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
ds.clear();
|
||||
double[] buff = new double[count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
ds.add(buff[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static Mat vector_DMatch_to_Mat(List<DMatch> matches) {
|
||||
Mat res;
|
||||
int count = (matches != null) ? matches.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_64FC4);
|
||||
double[] buff = new double[count * 4];
|
||||
for (int i = 0; i < count; i++) {
|
||||
DMatch m = matches.get(i);
|
||||
buff[4 * i] = m.queryIdx;
|
||||
buff[4 * i + 1] = m.trainIdx;
|
||||
buff[4 * i + 2] = m.imgIdx;
|
||||
buff[4 * i + 3] = m.distance;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_DMatch(Mat m, List<DMatch> matches) {
|
||||
if (matches == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_64FC4 != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_64FC4 != m.type() || m.cols()!=1\n" + m);
|
||||
|
||||
matches.clear();
|
||||
double[] buff = new double[4 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3]));
|
||||
}
|
||||
}
|
||||
|
||||
// vector_vector_DMatch
|
||||
public static Mat vector_vector_DMatch_to_Mat(List<MatOfDMatch> lvdm, List<Mat> mats) {
|
||||
Mat res;
|
||||
int lCount = (lvdm != null) ? lvdm.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfDMatch vdm : lvdm)
|
||||
mats.add(vdm);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_vector_DMatch(Mat m, List<MatOfDMatch> lvdm) {
|
||||
if (lvdm == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new IllegalArgumentException("Input Mat can't be null");
|
||||
|
||||
List<Mat> mats = new ArrayList<Mat>(m.rows());
|
||||
Mat_to_vector_Mat(m, mats);
|
||||
lvdm.clear();
|
||||
for (Mat mi : mats) {
|
||||
MatOfDMatch vdm = new MatOfDMatch(mi);
|
||||
lvdm.add(vdm);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
// vector_vector_char
|
||||
public static Mat vector_vector_char_to_Mat(List<MatOfByte> lvb, List<Mat> mats) {
|
||||
Mat res;
|
||||
int lCount = (lvb != null) ? lvb.size() : 0;
|
||||
if (lCount > 0) {
|
||||
for (MatOfByte vb : lvb)
|
||||
mats.add(vb);
|
||||
res = vector_Mat_to_Mat(mats);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) {
|
||||
if (llb == null)
|
||||
throw new IllegalArgumentException("Output List can't be null");
|
||||
|
||||
if (m == null)
|
||||
throw new 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) {
|
||||
List<Byte> lb = new ArrayList<Byte>();
|
||||
Mat_to_vector_char(mi, lb);
|
||||
llb.add(lb);
|
||||
mi.release();
|
||||
}
|
||||
mats.clear();
|
||||
}
|
||||
|
||||
public static Mat vector_RotatedRect_to_Mat(List<RotatedRect> rs) {
|
||||
Mat res;
|
||||
int count = (rs != null) ? rs.size() : 0;
|
||||
if (count > 0) {
|
||||
res = new Mat(count, 1, CvType.CV_32FC(5));
|
||||
float[] buff = new float[5 * count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
RotatedRect r = rs.get(i);
|
||||
buff[5 * i] = (float)r.center.x;
|
||||
buff[5 * i + 1] = (float)r.center.y;
|
||||
buff[5 * i + 2] = (float)r.size.width;
|
||||
buff[5 * i + 3] = (float)r.size.height;
|
||||
buff[5 * i + 4] = (float)r.angle;
|
||||
}
|
||||
res.put(0, 0, buff);
|
||||
} else {
|
||||
res = new Mat();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void Mat_to_vector_RotatedRect(Mat m, List<RotatedRect> rs) {
|
||||
if (rs == null)
|
||||
throw new IllegalArgumentException("rs == null");
|
||||
int count = m.rows();
|
||||
if (CvType.CV_32FC(5) != m.type() || m.cols() != 1)
|
||||
throw new IllegalArgumentException(
|
||||
"CvType.CV_32FC5 != m.type() || m.rows()!=1\n" + m);
|
||||
|
||||
rs.clear();
|
||||
float[] buff = new float[5 * count];
|
||||
m.get(0, 0, buff);
|
||||
for (int i = 0; i < count; i++) {
|
||||
rs.add(new RotatedRect(new Point(buff[5 * i], buff[5 * i + 1]), new Size(buff[5 * i + 2], buff[5 * i + 3]), buff[5 * i + 4]));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user