Visual Servoing Platform version 3.5.0
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 if (V.empty()) {
105 return NULL;
106 }
107
108 size_t outerSize = V.size();
109 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
110
111 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
112 size_t innerSize = V[i].size();
113 jlongArray longArray = env->NewLongArray(innerSize);
114 jlong *longArrayElements = env->GetLongArrayElements(longArray, 0);
115
116 for (int j = 0; j < env->GetArrayLength(longArray); j++) {
117 longArrayElements[j] = (jlong) new vpImagePoint(V[i][j]);
118 }
119
120 env->ReleaseLongArrayElements(longArray, longArrayElements, 0);
121 env->SetObjectArrayElement(outerArray, i, longArray);
122 }
123
124 return outerArray;
125}
126
127jobjectArray vector_vector_double_to_List(JNIEnv *env, const std::vector<std::vector<double> >& V) {
128 if (V.empty()) {
129 return NULL;
130 }
131
132 size_t outerSize = V.size();
133 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
134
135 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
136 size_t innerSize = V[i].size();
137 jdoubleArray doubleArray = env->NewDoubleArray(innerSize);
138 jdouble *doubleArrayElements = env->GetDoubleArrayElements(doubleArray, 0);
139
140 for (int j = 0; j < env->GetArrayLength(doubleArray); j++) {
141 doubleArrayElements[j] = (jdouble) V[i][j];
142 }
143
144 env->ReleaseDoubleArrayElements(doubleArray, doubleArrayElements, 0);
145 env->SetObjectArrayElement(outerArray, i, doubleArray);
146 }
147
148 return outerArray;
149}
150
151std::string convertTo(JNIEnv *env, jstring jstr) {
152 const char *rawString = env->GetStringUTFChars(jstr, 0);
153 std::string cppString(rawString ? rawString : "");
154 env->ReleaseStringUTFChars(jstr, rawString);
155
156 return cppString;
157}
158
159jstring convertTo(JNIEnv *env, const std::string& str) {
160 return env->NewStringUTF(str.c_str());
161}
162
163jobjectArray map_string_vector_vector_double_to_array_native(JNIEnv *env, const std::map<std::string, std::vector<std::vector<double> > > &map) {
164 if (map.empty()) {
165 return NULL;
166 }
167
168 size_t mapSize = map.size();
169 jobjectArray mapArray = env->NewObjectArray(mapSize, env->FindClass("java/lang/Object"), NULL);
170
171 int idx = 0;
172 for (std::map<std::string, std::vector<std::vector<double> > >::const_iterator it = map.begin(); it != map.end(); ++it, idx++) {
173 size_t outerSize = it->second.size();
174 jobjectArray outerArray = env->NewObjectArray(outerSize, env->FindClass("java/lang/Object"), NULL);
175
176 for (int i = 0; i < env->GetArrayLength(outerArray); i++) {
177 size_t innerSize = it->second[i].size();
178 jdoubleArray doubleArray = env->NewDoubleArray(innerSize);
179 jdouble *doubleArrayElements = env->GetDoubleArrayElements(doubleArray, 0);
180
181 for (int j = 0; j < env->GetArrayLength(doubleArray); j++) {
182 doubleArrayElements[j] = (jdouble) it->second[i][j];
183 }
184
185 env->ReleaseDoubleArrayElements(doubleArray, doubleArrayElements, 0);
186 env->SetObjectArrayElement(outerArray, i, doubleArray);
187 }
188
189 env->SetObjectArrayElement(mapArray, idx, outerArray);
190 }
191
192 return mapArray;
193}
194
195jobjectArray vector_string_to_array_native(JNIEnv *env, const std::vector<std::string>& V) {
196 if (V.empty()) {
197 return NULL;
198 }
199
200 size_t vecSize = V.size();
201 jobjectArray vec = env->NewObjectArray(vecSize, env->FindClass("java/lang/String"), env->NewStringUTF(""));
202 for (size_t i = 0; i < V.size(); i++) {
203 env->SetObjectArrayElement(vec, i, env->NewStringUTF(V[i].c_str()));
204 }
205
206 return vec;
207}
208
209std::vector<std::string> array_string_to_vector(JNIEnv *env, jobjectArray arr) {
210 int size = env->GetArrayLength(arr);
211
212 std::vector<std::string> vec(size);
213 for (int i = 0; i < size; i++) {
214 vec[i] = convertTo(env, (jstring)env->GetObjectArrayElement(arr, i));
215 }
216
217 return vec;
218}
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
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 ...
Definition: vpImagePoint.h:88