Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
listconverters.cpp
1// This file is part of ViSP project.
2#define LOG_TAG "org.visp.utils.Converters"
3#include "common.h"
4
5jlongArray vector_vpColVector_to_List(JNIEnv *env, const std::vector<vpColVector> &V)
6{
7 jlongArray result = env->NewLongArray(V.size());
8 jlong *body = env->GetLongArrayElements(result, 0);
9
10 for (size_t i = 0; i < V.size(); i++) {
11 body[i] = (jlong) new vpColVector(V[i]);
12 }
13
14 env->ReleaseLongArrayElements(result, body, 0);
15 return result;
16}
17
18jlongArray vector_vpHomogeneousMatrix_to_List(JNIEnv *env, const std::vector<vpHomogeneousMatrix> &V)
19{
20 jlongArray result = env->NewLongArray(V.size());
21 jlong *body = env->GetLongArrayElements(result, 0);
22
23 for (size_t i = 0; i < V.size(); i++) {
24 body[i] = (jlong) new vpHomogeneousMatrix(V[i]);
25 }
26
27 env->ReleaseLongArrayElements(result, body, 0);
28 return result;
29}
30
31std::vector<vpHomogeneousMatrix> List_to_vector_vpHomogeneousMatrix(JNIEnv *env, jlongArray arr)
32{
33 jlong *body = env->GetLongArrayElements(arr, 0);
34 int len = env->GetArrayLength(arr);
35
36 std::vector<vpHomogeneousMatrix> V(len);
37 for (int i = 0; i < len; i++) {
39 V[i] = *temp;
40 }
41
42 env->ReleaseLongArrayElements(arr, body, 0);
43 return V;
44}
45
46std::vector<vpCameraParameters> List_to_vector_vpCameraParameters(JNIEnv *env, jlongArray arr)
47{
48 jlong *body = env->GetLongArrayElements(arr, 0);
49 int len = env->GetArrayLength(arr);
50
51 std::vector<vpCameraParameters> V(len);
52 for (int i = 0; i < len; i++) {
53 vpCameraParameters *temp = (vpCameraParameters *)body[i];
54 V[i] = *temp;
55 }
56
57 env->ReleaseLongArrayElements(arr, body, 0);
58 return V;
59}
60
61std::vector<int> List_to_vector_int(JNIEnv *env, jintArray arr)
62{
63 jint *body = env->GetIntArrayElements(arr, 0);
64 int len = env->GetArrayLength(arr);
65
66 std::vector<int> V(len);
67 for (int i = 0; i < len; i++) {
68 V[i] = body[i];
69 }
70
71 env->ReleaseIntArrayElements(arr, body, 0);
72 return V;
73}
74
75std::vector<float> List_to_vector_float(JNIEnv *env, jfloatArray arr)
76{
77 jfloat *body = env->GetFloatArrayElements(arr, 0);
78 int len = env->GetArrayLength(arr);
79
80 std::vector<float> V(len);
81 for (int i = 0; i < len; i++) {
82 V[i] = body[i];
83 }
84
85 env->ReleaseFloatArrayElements(arr, body, 0);
86 return V;
87}
88
89std::vector<double> List_to_vector_double(JNIEnv *env, jdoubleArray arr)
90{
91 jdouble *body = env->GetDoubleArrayElements(arr, 0);
92 int len = env->GetArrayLength(arr);
93
94 std::vector<double> V(len);
95 for (int i = 0; i < len; i++) {
96 V[i] = body[i];
97 }
98
99 env->ReleaseDoubleArrayElements(arr, body, 0);
100 return V;
101}
102
103jobjectArray vector_vector_vpImagePoint_to_List(JNIEnv *env, const std::vector<std::vector<vpImagePoint> > &V)
104{
105 if (V.empty()) {
106 return NULL;
107 }
108
109 size_t outerSize = V.size();
110 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
111
112 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
113 size_t innerSize = V[i].size();
114 jlongArray longArray = env->NewLongArray(innerSize);
115 jlong *longArrayElements = env->GetLongArrayElements(longArray, 0);
116
117 for (int j = 0; j < env->GetArrayLength(longArray); j++) {
118 longArrayElements[j] = (jlong) new vpImagePoint(V[i][j]);
119 }
120
121 env->ReleaseLongArrayElements(longArray, longArrayElements, 0);
122 env->SetObjectArrayElement(outerArray, i, longArray);
123 }
124
125 return outerArray;
126}
127
128jobjectArray vector_vector_double_to_List(JNIEnv *env, const std::vector<std::vector<double> > &V)
129{
130 if (V.empty()) {
131 return NULL;
132 }
133
134 size_t outerSize = V.size();
135 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
136
137 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
138 size_t innerSize = V[i].size();
139 jdoubleArray doubleArray = env->NewDoubleArray(innerSize);
140 jdouble *doubleArrayElements = env->GetDoubleArrayElements(doubleArray, 0);
141
142 for (int j = 0; j < env->GetArrayLength(doubleArray); j++) {
143 doubleArrayElements[j] = (jdouble)V[i][j];
144 }
145
146 env->ReleaseDoubleArrayElements(doubleArray, doubleArrayElements, 0);
147 env->SetObjectArrayElement(outerArray, i, doubleArray);
148 }
149
150 return outerArray;
151}
152
153std::string convertTo(JNIEnv *env, jstring jstr)
154{
155 const char *rawString = env->GetStringUTFChars(jstr, 0);
156 std::string cppString(rawString ? rawString : "");
157 env->ReleaseStringUTFChars(jstr, rawString);
158
159 return cppString;
160}
161
162jstring convertTo(JNIEnv *env, const std::string &str) { return env->NewStringUTF(str.c_str()); }
163
164jobjectArray
165map_string_vector_vector_double_to_array_native(JNIEnv *env,
166 const std::map<std::string, std::vector<std::vector<double> > > &map)
167{
168 if (map.empty()) {
169 return NULL;
170 }
171
172 size_t mapSize = map.size();
173 jobjectArray mapArray = env->NewObjectArray(mapSize, env->FindClass("java/lang/Object"), NULL);
174
175 int idx = 0;
176 for (std::map<std::string, std::vector<std::vector<double> > >::const_iterator it = map.begin(); it != map.end();
177 ++it, idx++) {
178 size_t outerSize = it->second.size();
179 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
180
181 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
182 size_t innerSize = it->second[i].size();
183 jdoubleArray doubleArray = env->NewDoubleArray(innerSize);
184 jdouble *doubleArrayElements = env->GetDoubleArrayElements(doubleArray, 0);
185
186 for (int j = 0; j < env->GetArrayLength(doubleArray); j++) {
187 doubleArrayElements[j] = (jdouble)it->second[i][j];
188 }
189
190 env->ReleaseDoubleArrayElements(doubleArray, doubleArrayElements, 0);
191 env->SetObjectArrayElement(outerArray, i, doubleArray);
192 }
193
194 env->SetObjectArrayElement(mapArray, idx, outerArray);
195 }
196
197 return mapArray;
198}
199
200jobjectArray vector_string_to_array_native(JNIEnv *env, const std::vector<std::string> &V)
201{
202 if (V.empty()) {
203 return NULL;
204 }
205
206 size_t vecSize = V.size();
207 jobjectArray vec = env->NewObjectArray(vecSize, env->FindClass("java/lang/String"), env->NewStringUTF(""));
208 for (size_t i = 0; i < V.size(); i++) {
209 env->SetObjectArrayElement(vec, i, env->NewStringUTF(V[i].c_str()));
210 }
211
212 return vec;
213}
214
215std::vector<std::string> array_string_to_vector(JNIEnv *env, jobjectArray arr)
216{
217 int size = env->GetArrayLength(arr);
218
219 std::vector<std::string> vec(size);
220 for (int i = 0; i < size; i++) {
221 vec[i] = convertTo(env, (jstring)env->GetObjectArrayElement(arr, i));
222 }
223
224 return vec;
225}
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Implementation of an homogeneous matrix and operations on such kind of matrices.
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...