Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
gen_dict.json
1{
2 "module_imports": [
3 "java.lang.String"
4 ],
5 "class_ignore_list": [
6 "vpMbDepthNormalTracker",
7 "vpMbKltTracker",
8 "vpMbScanLine",
9 "vpMbTracker",
10 "vpMbtDistanceCylinder",
11 "vpMbtMeEllipse"
12 ],
13 "ManualFuncs": {
14 "VpMbGenericTracker": {
15 "VpMbGenericTracker" : {
16 "j_code" : [
17 "//",
18 "// manual port",
19 "// C++: vpMbGenericTracker()",
20 "//\n",
21 "//javadoc: VpMbGenericTracker::VpMbGenericTracker()\n",
22 "public VpMbGenericTracker()",
23 "{\n",
24 " nativeObj = VpMbGenericTracker_0();\n",
25 " return;",
26 "}\n\n",
27 "//",
28 "// manual port",
29 "// C++: vpMbGenericTracker(unsigned int nbCameras, int trackerType = EDGE_TRACKER)",
30 "//\n",
31 "//javadoc: VpMbGenericTracker::VpMbGenericTracker()\n",
32 "public VpMbGenericTracker(int nbCameras, int trackerType)",
33 "{\n",
34 " nativeObj = VpMbGenericTracker_1(nbCameras, trackerType);\n",
35 " return;",
36 "}\n\n",
37 "//",
38 "// manual port",
39 "// C++: vpMbGenericTracker(const std::vector<int> &trackerTypes)",
40 "//\n",
41 "//javadoc: VpMbGenericTracker::VpMbGenericTracker()\n",
42 "public VpMbGenericTracker(int[] trackerTypes)",
43 "{\n",
44 " nativeObj = VpMbGenericTracker_2(trackerTypes);\n",
45 " return;",
46 "}\n\n",
47 "//",
48 "// manual port",
49 "// C++: vpMbGenericTracker(const std::vector<std::string> &cameraNames, const std::vector<int> &trackerTypes)",
50 "//\n",
51 "//javadoc: VpMbGenericTracker::VpMbGenericTracker()\n",
52 "public VpMbGenericTracker(String[] cameraNames, int[] trackerTypes)",
53 "{\n",
54 " nativeObj = VpMbGenericTracker_3(cameraNames, trackerTypes);\n",
55 " return;",
56 "}"
57 ],
58 "cpp_code" : [
59 "//",
60 "// manual port",
61 "// vpMbGenericTracker()",
62 "//\n\n",
63 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_10 (JNIEnv*, jclass);\n",
64 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_10",
65 " (JNIEnv* env, jclass )",
66 "{",
67 " static const char method_name[] = \"mbt::VpMbGenericTracker_10()\";",
68 " try {",
69 " LOGD(\"%s\", method_name);\n",
70 " vpMbGenericTracker *_retval_ = new vpMbGenericTracker();",
71 " return (jlong) _retval_;",
72 " } catch(const std::exception &e) {",
73 " throwJavaException(env, &e, method_name);",
74 " } catch (...) {",
75 " throwJavaException(env, 0, method_name);",
76 " }",
77 " return 0;",
78 "}\n\n",
79 "//",
80 "// manual port",
81 "// vpMbGenericTracker(unsigned int nbCameras, int trackerType = EDGE_TRACKER)",
82 "//\n\n",
83 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_11 (JNIEnv*, jclass, jint, jint);\n",
84 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_11",
85 " (JNIEnv* env, jclass , jint nbCameras, jint trackerType)",
86 "{",
87 " static const char method_name[] = \"mbt::VpMbGenericTracker_11()\";",
88 " try {",
89 " LOGD(\"%s\", method_name);",
90 " vpMbGenericTracker* _retval_ = new vpMbGenericTracker( (int)nbCameras, (int)trackerType );",
91 " return (jlong) _retval_;",
92 " } catch(const std::exception &e) {",
93 " throwJavaException(env, &e, method_name);",
94 " } catch (...) {",
95 " throwJavaException(env, 0, method_name);",
96 " }",
97 " return 0;",
98 "}\n\n",
99 "//",
100 "// manual port",
101 "// vpMbGenericTracker(const std::vector<int> &trackerTypes)",
102 "//\n\n",
103 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_12 (JNIEnv*, jclass, jintArray);\n",
104 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_12",
105 " (JNIEnv* env, jclass , jintArray trackerTypes)",
106 "{",
107 " static const char method_name[] = \"mbt::VpMbGenericTracker_12()\";",
108 " try {",
109 " LOGD(\"%s\", method_name);\n",
110 " vpMbGenericTracker *_retval_ = new vpMbGenericTracker(List_to_vector_int(env, trackerTypes));",
111 " return (jlong) _retval_;",
112 " } catch(const std::exception &e) {",
113 " throwJavaException(env, &e, method_name);",
114 " } catch (...) {",
115 " throwJavaException(env, 0, method_name);",
116 " }",
117 " return 0;",
118 "}\n\n",
119 "//",
120 "// manual port",
121 "// vpMbGenericTracker(const std::vector<std::string> &cameraNames, const std::vector<int> &trackerTypes)",
122 "//\n\n",
123 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_13 (JNIEnv*, jclass, jobjectArray, jintArray);\n",
124 "JNIEXPORT jlong JNICALL Java_org_visp_mbt_VpMbGenericTracker_VpMbGenericTracker_13",
125 " (JNIEnv* env, jclass , jobjectArray cameraNames, jintArray trackerTypes)",
126 "{",
127 " static const char method_name[] = \"mbt::VpMbGenericTracker_13()\";",
128 " try {",
129 " LOGD(\"%s\", method_name);\n",
130 " vpMbGenericTracker *_retval_ = new vpMbGenericTracker(array_string_to_vector(env, cameraNames), List_to_vector_int(env, trackerTypes));",
131 " return (jlong) _retval_;",
132 " } catch(const std::exception &e) {",
133 " throwJavaException(env, &e, method_name);",
134 " } catch (...) {",
135 " throwJavaException(env, 0, method_name);",
136 " }",
137 " return 0;",
138 "}"
139 ],
140 "jn_code" : [
141 "// C++: void vpMbGenericTracker()",
142 "private static native long VpMbGenericTracker_0();\n",
143 "// C++: void vpMbGenericTracker(unsigned int nbCameras, int trackerType = EDGE_TRACKER)",
144 "private static native long VpMbGenericTracker_1(int nbCameras, int trackerType);\n",
145 "// C++: void vpMbGenericTracker(const std::vector<int> &trackerTypes)",
146 "private static native long VpMbGenericTracker_2(int[] trackerTypes);\n",
147 "// C++: void vpMbGenericTracker(const std::vector<std::string> &cameraNames, const std::vector<int> &trackerTypes)",
148 "private static native long VpMbGenericTracker_3(String[] cameraNames, int[] trackerTypes);"
149 ]
150 },
151 "getCameraParameters": {
152 "j_code": [
153 "//",
154 "// manual port",
155 "// C++: void getCameraParameters(vpCameraParameters camera)",
156 "//",
157 "//javadoc: VpMbGenericTracker::getCameraParameters()\n",
158 "public void getCameraParameters(org.visp.core.VpCameraParameters camera)",
159 "{",
160 " getCameraParameters_0(nativeObj, camera.nativeObj);",
161 "}\n\n",
162 "//",
163 "// manual port",
164 "// C++: void getCameraParameters(vpCameraParameters cam1, vpCameraParameters cam2)",
165 "//",
166 "//javadoc: VpMbGenericTracker::getCameraParameters()\n",
167 "public void getCameraParameters(org.visp.core.VpCameraParameters cam1, org.visp.core.VpCameraParameters cam2)",
168 "{",
169 " getCameraParameters_1(nativeObj, cam1.nativeObj, cam2.nativeObj);",
170 "}\n\n",
171 "//",
172 "// manual port",
173 "// C++: void getCameraParameters(mapOfCameraParameters)",
174 "//",
175 "//javadoc: VpMbGenericTracker::getCameraParameters()\n",
176 "public void getCameraParameters(String[] cameraNames, org.visp.core.VpCameraParameters[] cameras)",
177 "{",
178 " getCameraParameters_2(nativeObj, cameraNames, org.visp.utils.Converters.array_vpCameraParameters_to_array_native(cameras));",
179 "}"
180 ],
181 "cpp_code": [
182 "//",
183 "// manual port",
184 "// void getCameraParameters()",
185 "//\n",
186 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_10 (JNIEnv*, jclass, jlong, jlong);\n",
187 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_10",
188 " (JNIEnv* env, jclass , jlong self, jlong camera_nativeObj)",
189 "{",
190 " static const char method_name[] = \"vpMbGenericTracker::getCameraParameters_10()\";",
191 " try {",
192 " LOGD(\"%s\", method_name);",
193 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
194 " vpCameraParameters& camera = *((vpCameraParameters*)camera_nativeObj);",
195 " me->getCameraParameters( camera );",
196 " } catch(const std::exception &e) {",
197 " throwJavaException(env, &e, method_name);",
198 " } catch (...) {",
199 " throwJavaException(env, 0, method_name);",
200 " }",
201 "}\n\n",
202 "//",
203 "// manual port",
204 "// void getCameraParameters()",
205 "//\n",
206 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_11 (JNIEnv*, jclass, jlong, jlong, jlong);\n",
207 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_11",
208 " (JNIEnv* env, jclass , jlong self, jlong cam1_nativeObj, jlong cam2_nativeObj)",
209 "{",
210 " static const char method_name[] = \"vpMbGenericTracker::getCameraParameters_11()\";",
211 " try {",
212 " LOGD(\"%s\", method_name);",
213 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
214 " vpCameraParameters& cam1 = *((vpCameraParameters*)cam1_nativeObj);",
215 " vpCameraParameters& cam2 = *((vpCameraParameters*)cam2_nativeObj);",
216 " me->getCameraParameters( cam1, cam2 );",
217 " } catch(const std::exception &e) {",
218 " throwJavaException(env, &e, method_name);",
219 " } catch (...) {",
220 " throwJavaException(env, 0, method_name);",
221 " }",
222 "}\n\n",
223 "//",
224 "// manual port",
225 "// void getCameraParameters()",
226 "//\n",
227 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_12 (JNIEnv*, jclass, jlong, jobjectArray, jlongArray);\n",
228 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraParameters_12",
229 " (JNIEnv* env, jclass , jlong self, jobjectArray cameraNames, jlongArray cameras)",
230 "{",
231 " static const char method_name[] = \"vpMbGenericTracker::getCameraParameters_12()\";",
232 " try {",
233 " LOGD(\"%s\", method_name);",
234 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
235 " int cameraCount = env->GetArrayLength(cameraNames);",
236 " std::map<std::string, vpCameraParameters> mapOfCameraParameters;",
237 " jlong *jcameras = env->GetLongArrayElements(cameras, 0);",
238 " for (int i = 0; i < cameraCount; i++) {",
239 " jstring key = (jstring) (env->GetObjectArrayElement(cameraNames, i));",
240 " vpCameraParameters& camera = (*(vpCameraParameters*)jcameras[i]);",
241 " mapOfCameraParameters[convertTo(env, key)] = camera;",
242 " }",
243 " me->getCameraParameters(mapOfCameraParameters);",
244 " } catch(const std::exception &e) {",
245 " throwJavaException(env, &e, method_name);",
246 " } catch (...) {",
247 " throwJavaException(env, 0, method_name);",
248 " }",
249 "}"
250 ],
251 "jn_code": [
252 "// C++: void getCameraParameters(vpCameraParameters camera)",
253 "private static native void getCameraParameters_0(long address, long camera_nativeObj);\n",
254 "// C++: void getCameraParameters(vpCameraParameters cam1, vpCameraParameters cam2)",
255 "private static native void getCameraParameters_1(long address, long cam1_nativeObj, long cam2_nativeObj);\n",
256 "// C++: void getCameraParameters(mapOfCameraParameters)",
257 "private static native void getCameraParameters_2(long address, String[] cameraNames, long[] cameras);"
258 ]
259 },
260 "getPose": {
261 "j_code": [
262 "//",
263 "// manual port",
264 "// C++: void getPose(vpHomogeneousMatrix cMo)",
265 "//",
266 "//javadoc: VpMbGenericTracker::getPose()\n",
267 "public void getPose(org.visp.core.VpHomogeneousMatrix cMo)",
268 "{",
269 " getPose_0(nativeObj, cMo.nativeObj);",
270 "}\n\n",
271 "//",
272 "// manual port",
273 "// C++: void getPose(vpHomogeneousMatrix c1Mo, vpHomogeneousMatrix c2Mo)",
274 "//",
275 "//javadoc: VpMbGenericTracker::getPose()\n",
276 "public void getPose(org.visp.core.VpHomogeneousMatrix c1Mo, org.visp.core.VpHomogeneousMatrix c2Mo)",
277 "{",
278 " getPose_1(nativeObj, c1Mo.nativeObj, c2Mo.nativeObj);",
279 "}\n\n",
280 "//",
281 "// manual port",
282 "// C++: void getPose(mapOfCameraPoses)",
283 "//",
284 "//javadoc: VpMbGenericTracker::getPose()\n",
285 "public void getPose(String[] cameraNames, org.visp.core.VpHomogeneousMatrix[] poses)",
286 "{",
287 " getPose_2(nativeObj, cameraNames, org.visp.utils.Converters.array_vpHomogeneousMatrix_to_array_native(poses));",
288 "}"
289 ],
290 "cpp_code": [
291 "//",
292 "// manual port",
293 "// void getPose()",
294 "//\n",
295 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_10 (JNIEnv*, jclass, jlong, jlong);\n",
296 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_10",
297 " (JNIEnv* env, jclass , jlong self, jlong cMo_nativeObj)",
298 "{",
299 " static const char method_name[] = \"vpMbGenericTracker::getPose_10()\";",
300 " try {",
301 " LOGD(\"%s\", method_name);",
302 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
303 " vpHomogeneousMatrix& cMo = *((vpHomogeneousMatrix*)cMo_nativeObj);",
304 " me->getPose( cMo );",
305 " } catch(const std::exception &e) {",
306 " throwJavaException(env, &e, method_name);",
307 " } catch (...) {",
308 " throwJavaException(env, 0, method_name);",
309 " }",
310 "}\n\n",
311 "//",
312 "// manual port",
313 "// void getPose()",
314 "//\n",
315 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_11 (JNIEnv*, jclass, jlong, jlong, jlong);\n",
316 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_11",
317 " (JNIEnv* env, jclass , jlong self, jlong c1Mo_nativeObj, jlong c2Mo_nativeObj)",
318 "{",
319 " static const char method_name[] = \"vpMbGenericTracker::getPose_11()\";",
320 " try {",
321 " LOGD(\"%s\", method_name);",
322 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
323 " vpHomogeneousMatrix& c1Mo = *((vpHomogeneousMatrix*)c1Mo_nativeObj);",
324 " vpHomogeneousMatrix& c2Mo = *((vpHomogeneousMatrix*)c2Mo_nativeObj);",
325 " me->getPose( c1Mo, c2Mo );",
326 " } catch(const std::exception &e) {",
327 " throwJavaException(env, &e, method_name);",
328 " } catch (...) {",
329 " throwJavaException(env, 0, method_name);",
330 " }",
331 "}\n\n",
332 "//",
333 "// manual port",
334 "// void getPose()",
335 "//\n",
336 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_12 (JNIEnv*, jclass, jlong, jobjectArray, jlongArray);\n",
337 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_getPose_12",
338 " (JNIEnv* env, jclass , jlong self, jobjectArray cameraNames, jlongArray poses)",
339 "{",
340 " static const char method_name[] = \"vpMbGenericTracker::getPose_12()\";",
341 " try {",
342 " LOGD(\"%s\", method_name);",
343 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
344 " int cameraCount = env->GetArrayLength(cameraNames);",
345 " std::map<std::string, vpHomogeneousMatrix> mapOfCameraPoses;",
346 " jlong *jposes = env->GetLongArrayElements(poses, 0);",
347 " for (int i = 0; i < cameraCount; i++) {",
348 " jstring key = (jstring) (env->GetObjectArrayElement(cameraNames, i));",
349 " vpHomogeneousMatrix& cMo = (*(vpHomogeneousMatrix*)jposes[i]);",
350 " mapOfCameraPoses[convertTo(env, key)] = cMo;",
351 " }",
352 " me->getPose(mapOfCameraPoses);",
353 " } catch(const std::exception &e) {",
354 " throwJavaException(env, &e, method_name);",
355 " } catch (...) {",
356 " throwJavaException(env, 0, method_name);",
357 " }",
358 "}"
359 ],
360 "jn_code": [
361 "// C++: void getPose(vpHomogeneousMatrix cMo)",
362 "private static native void getPose_0(long address, long cMo_nativeObj);\n",
363 "// C++: void getPose(vpHomogeneousMatrix c1Mo, vpHomogeneousMatrix c2Mo)",
364 "private static native void getPose_1(long address, long c1Mo_nativeObj, long c2Mo_nativeObj);\n",
365 "// C++: void getPose(mapOfCameraPoses)",
366 "private static native void getPose_2(long address, String[] cameraNames, long[] poses);"
367 ]
368 },
369 "initFromPose": {
370 "j_code": [
371 "//",
372 "// manual port",
373 "// C++: void initFromPose(vpImage_char I, vpHomogeneousMatrix cMo)",
374 "//",
375 "//javadoc: VpMbGenericTracker::initFromPose()\n",
376 "public void initFromPose(org.visp.core.VpImageUChar I, org.visp.core.VpHomogeneousMatrix cMo)",
377 "{",
378 " initFromPose_0(nativeObj, I.nativeObj, cMo.nativeObj);",
379 "}\n\n",
380 "//",
381 "// manual port",
382 "// C++: void initFromPose(vpImage_char I1, vpImage_char I2, vpHomogeneousMatrix c1Mo, vpHomogeneousMatrix c2Mo)",
383 "//",
384 "//javadoc: VpMbGenericTracker::initFromPose()\n",
385 "public void initFromPose(org.visp.core.VpImageUChar I1, org.visp.core.VpImageUChar I2, org.visp.core.VpHomogeneousMatrix cMo1, org.visp.core.VpHomogeneousMatrix cMo2)",
386 "{",
387 " initFromPose_1(nativeObj, I1.nativeObj, I2.nativeObj, cMo1.nativeObj, cMo2.nativeObj);",
388 "}\n\n",
389 "//",
390 "// manual port",
391 "// C++: void initFromPose(mapOfImages, mapOfCameraPoses)",
392 "//",
393 "//javadoc: VpMbGenericTracker::initFromPose()\n",
394 "public void initFromPose(String[] cameraNames, org.visp.core.VpImageUChar[] I, org.visp.core.VpHomogeneousMatrix[] cMo)",
395 "{",
396 " initFromPose_2(nativeObj, cameraNames, org.visp.utils.Converters.array_vpImageUChar_to_array_native(I), org.visp.utils.Converters.array_vpHomogeneousMatrix_to_array_native(cMo));",
397 "}"
398 ],
399 "cpp_code": [
400 "//",
401 "// manual port",
402 "// void initFromPose()",
403 "//\n",
404 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_10 (JNIEnv*, jclass, jlong, jlong, jlong);\n",
405 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_10",
406 " (JNIEnv* env, jclass , jlong self, jlong I_nativeObj, jlong cMo_nativeObj)",
407 "{",
408 " static const char method_name[] = \"vpMbGenericTracker::initFromPose_10()\";",
409 " try {",
410 " LOGD(\"%s\", method_name);",
411 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
412 " vpImage<unsigned char>& I = *((vpImage<unsigned char>*)I_nativeObj);",
413 " vpHomogeneousMatrix& cMo = *((vpHomogeneousMatrix*)cMo_nativeObj);",
414 " me->initFromPose( I, cMo );",
415 " } catch(const std::exception &e) {",
416 " throwJavaException(env, &e, method_name);",
417 " } catch (...) {",
418 " throwJavaException(env, 0, method_name);",
419 " }",
420 "}\n\n",
421 "//",
422 "// manual port",
423 "// void initFromPose()",
424 "//\n",
425 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong);\n",
426 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_11",
427 " (JNIEnv* env, jclass , jlong self, jlong I1_nativeObj, jlong I2_nativeObj, jlong c1Mo_nativeObj, jlong c2Mo_nativeObj)",
428 "{",
429 " static const char method_name[] = \"vpMbGenericTracker::initFromPose_11()\";",
430 " try {",
431 " LOGD(\"%s\", method_name);",
432 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
433 " vpImage<unsigned char>& I1 = *((vpImage<unsigned char>*)I1_nativeObj);",
434 " vpImage<unsigned char>& I2 = *((vpImage<unsigned char>*)I2_nativeObj);",
435 " vpHomogeneousMatrix& c1Mo = *((vpHomogeneousMatrix*)c1Mo_nativeObj);",
436 " vpHomogeneousMatrix& c2Mo = *((vpHomogeneousMatrix*)c2Mo_nativeObj);",
437 " me->initFromPose( I1, I2, c1Mo, c2Mo );",
438 " } catch(const std::exception &e) {",
439 " throwJavaException(env, &e, method_name);",
440 " } catch (...) {",
441 " throwJavaException(env, 0, method_name);",
442 " }",
443 "}\n\n",
444 "//",
445 "// manual port",
446 "// void initFromPose()",
447 "//\n",
448 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_12 (JNIEnv*, jclass, jlong, jobjectArray, jlongArray, jlongArray);\n",
449 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_initFromPose_12",
450 " (JNIEnv* env, jclass , jlong address, jobjectArray cameraNames, jlongArray images, jlongArray poses)",
451 "{",
452 " static const char method_name[] = \"vpMbGenericTracker::initFromPose_12()\";",
453 " try {",
454 " LOGD(\"%s\", method_name);",
455 " vpMbGenericTracker* tracker = (vpMbGenericTracker*) address; //TODO: check for NULL",
456 " int stringCount = env->GetArrayLength(cameraNames);",
457 " std::map<std::string, const vpImage<unsigned char> *> mapOfImages;",
458 " std::map<std::string, vpHomogeneousMatrix> mapOfCameraPoses;",
459 " jlong *jimages = env->GetLongArrayElements(images, 0);",
460 " jlong *jposes = env->GetLongArrayElements(poses, 0);",
461 " for (int i = 0; i < stringCount; i++) {",
462 " jstring key = (jstring) (env->GetObjectArrayElement(cameraNames, i));",
463 " std::string cameraName = convertTo(env, key);",
464 " const vpImage<unsigned char>* I = (vpImage<unsigned char>*)jimages[i];",
465 " mapOfImages[cameraName] = I;",
466 " vpHomogeneousMatrix& cMo = (*(vpHomogeneousMatrix*)jposes[i]);",
467 " mapOfCameraPoses[cameraName] = cMo;",
468 " }",
469 " tracker->initFromPose(mapOfImages, mapOfCameraPoses);",
470 " } catch(const std::exception &e) {",
471 " throwJavaException(env, &e, method_name);",
472 " } catch (...) {",
473 " throwJavaException(env, 0, method_name);",
474 " }",
475 "}"
476 ],
477 "jn_code": [
478 "// C++: void initFromPose(vpImage_char I, vpHomogeneousMatrix cMo)",
479 "private static native void initFromPose_0(long address, long I_nativeObj, long cMo_nativeObj);\n",
480 "// C++: void initFromPose(vpImage_char I1, vpImage_char I2, vpHomogeneousMatrix c1Mo, vpHomogeneousMatrix c2Mo)",
481 "private static native void initFromPose_1(long address, long I1_nativeObj, long I2_nativeObj, long cMo1_nativeObj, long cMo2_nativeObj);\n",
482 "// C++: void initFromPose(mapOfImages, mapOfCameraPoses)",
483 "private static native void initFromPose_2(long address, String[] cameraNames, long[] images, long[] poses);"
484 ]
485 },
486 "loadConfigFile": {
487 "j_code": [
488 "//",
489 "// manual port",
490 "// C++: void loadConfigFile(string configFile)",
491 "//",
492 "//javadoc: VpMbGenericTracker::loadConfigFile()\n",
493 "public void loadConfigFile(String configFile)",
494 "{",
495 " loadConfigFile_0(nativeObj, configFile);",
496 "}\n\n",
497 "//",
498 "// manual port",
499 "// C++: void loadConfigFile(string configFile1, string configFile2)",
500 "//",
501 "//javadoc: VpMbGenericTracker::loadConfigFile()\n",
502 "public void loadConfigFile(String configFile1, String configFile2)",
503 "{",
504 " loadConfigFile_1(nativeObj, configFile1, configFile2);",
505 "}\n\n",
506 "//",
507 "// manual port",
508 "// C++: void loadConfigFile(const std::map<std::string, std::string>& map)",
509 "//",
510 "//javadoc: VpMbGenericTracker::loadConfigFile()\n",
511 "public void loadConfigFile(String[] cameraNames, String[] configFiles)",
512 "{",
513 " loadConfigFile_2(nativeObj, cameraNames, configFiles);",
514 "}"
515 ],
516 "cpp_code": [
517 "//",
518 "// manual port",
519 "// void loadConfigFile()",
520 "//\n",
521 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_10 (JNIEnv*, jclass, jlong, jstring);\n",
522 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_10",
523 " (JNIEnv* env, jclass , jlong self, jstring configFile)",
524 "{",
525 " static const char method_name[] = \"mbt::loadConfigFile_11()\";",
526 " try {",
527 " LOGD(\"%s\", method_name);",
528 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
529 " const char* utf_configFile = env->GetStringUTFChars(configFile, 0);",
530 " string n_configFile( utf_configFile ? utf_configFile : \"\" );",
531 " env->ReleaseStringUTFChars(configFile, utf_configFile);",
532 " me->loadConfigFile( n_configFile );",
533 " } catch(const std::exception &e) {",
534 " throwJavaException(env, &e, method_name);",
535 " } catch (...) {",
536 " throwJavaException(env, 0, method_name);",
537 " }",
538 "}\n\n",
539 "//",
540 "// manual port",
541 "// void loadConfigFile()",
542 "//\n",
543 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_11 (JNIEnv*, jclass, jlong, jstring, jstring);\n",
544 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_11",
545 " (JNIEnv* env, jclass , jlong self, jstring configFile1, jstring configFile2)",
546 "{",
547 " static const char method_name[] = \"mbt::loadConfigFile_10()\";",
548 " try {",
549 " LOGD(\"%s\", method_name);",
550 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
551 " const char* utf_configFile1 = env->GetStringUTFChars(configFile1, 0);",
552 " string n_configFile1( utf_configFile1 ? utf_configFile1 : \"\" );",
553 " env->ReleaseStringUTFChars(configFile1, utf_configFile1);",
554 " const char* utf_configFile2 = env->GetStringUTFChars(configFile2, 0);",
555 " string n_configFile2( utf_configFile2 ? utf_configFile2 : \"\" );",
556 " env->ReleaseStringUTFChars(configFile2, utf_configFile2);",
557 " me->loadConfigFile( n_configFile1, n_configFile2 );",
558 " } catch(const std::exception &e) {",
559 " throwJavaException(env, &e, method_name);",
560 " } catch (...) {",
561 " throwJavaException(env, 0, method_name);",
562 " }",
563 "}\n\n",
564 "//",
565 "// manual port",
566 "// void loadConfigFile()",
567 "//\n",
568 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_12 (JNIEnv*, jclass, jlong, jobjectArray, jobjectArray);\n",
569 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadConfigFile_12",
570 " (JNIEnv* env, jclass , jlong address, jobjectArray stringKeys, jobjectArray stringValues)",
571 "{",
572 " static const char method_name[] = \"vpMbGenericTracker::loadConfigFile()\";",
573 " try {",
574 " LOGD(\"%s\", method_name);",
575 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
576 " int stringCount = env->GetArrayLength(stringKeys);",
577 " std::map<std::string, std::string> map;",
578 " for (int i = 0; i < stringCount; i++) {",
579 " jstring key = (jstring) (env->GetObjectArrayElement(stringKeys, i));",
580 " jstring value = (jstring) (env->GetObjectArrayElement(stringValues, i));",
581 " map[convertTo(env, key)] = convertTo(env, value);",
582 " }",
583 " tracker->loadConfigFile(map);",
584 " } catch(const std::exception &e) {",
585 " throwJavaException(env, &e, method_name);",
586 " } catch (...) {",
587 " throwJavaException(env, 0, method_name);",
588 " }",
589 "}"
590 ],
591 "jn_code": [
592 "// C++: void loadConfigFile(string configFile)",
593 "private static native void loadConfigFile_0(long address, String configFile);\n",
594 "// C++: void loadConfigFile(string configFile1, string configFile2)",
595 "private static native void loadConfigFile_1(long address, String configFile1, String configFile2);\n",
596 "// C++: void loadConfigFile(const std::map<std::string, std::string>& map)",
597 "private static native void loadConfigFile_2(long address, String[] cameraNames, String[] configFiles);"
598 ]
599 },
600 "loadModel": {
601 "j_code": [
602 "//",
603 "// manual port",
604 "// C++: void loadModel(string modelFile, bool verbose = false, vpHomogeneousMatrix T = vpHomogeneousMatrix())",
605 "//",
606 "//javadoc: VpMbGenericTracker::loadModel()\n",
607 "public void loadModel(String modelFile, boolean verbose, org.visp.core.VpHomogeneousMatrix T)",
608 "{",
609 " loadModel_0(nativeObj, modelFile, verbose, T.nativeObj);",
610 "}\n\n",
611 "//",
612 "// manual port",
613 "// C++: void loadModel(string modelFile)",
614 "//",
615 "//javadoc: VpMbGenericTracker::loadModel()\n",
616 "public void loadModel(String modelFile)",
617 "{",
618 " loadModel_1(nativeObj, modelFile);",
619 "}\n\n",
620 "//",
621 "// manual port",
622 "// C++: void loadModel(string modelFile1, string modelFile2, bool verbose = false, vpHomogeneousMatrix T1 = vpHomogeneousMatrix(), vpHomogeneousMatrix T2 = vpHomogeneousMatrix())",
623 "//",
624 "//javadoc: VpMbGenericTracker::loadModel()\n",
625 "public void loadModel(String modelFile1, String modelFile2, boolean verbose, org.visp.core.VpHomogeneousMatrix T1, org.visp.core.VpHomogeneousMatrix T2)",
626 "{",
627 " loadModel_2(nativeObj, modelFile1, modelFile2, verbose, T1.nativeObj, T2.nativeObj);",
628 "}\n\n",
629 "//",
630 "// manual port",
631 "// C++: void loadModel(string modelFile1, string modelFile2)",
632 "//",
633 "//javadoc: VpMbGenericTracker::loadModel()\n",
634 "public void loadModel(String modelFile1, String modelFile2)",
635 "{",
636 " loadModel_3(nativeObj, modelFile1, modelFile2);",
637 "}\n\n",
638 "//",
639 "// manual port",
640 "// C++: void loadModel(const std::map<std::string, std::string>& map, bool verbose, const std::map<std::string, vpHomogeneousMatrix> &mapOfT)",
641 "//",
642 "//javadoc: VpMbGenericTracker::loadModel()\n",
643 "public void loadModel(String[] cameraNames, String[] modelFiles, boolean verbose, org.visp.core.VpHomogeneousMatrix[] Ts)",
644 "{",
645 " loadModel_4(nativeObj, cameraNames, modelFiles, verbose, org.visp.utils.Converters.array_vpHomogeneousMatrix_to_array_native(Ts));",
646 "}\n\n",
647 "//",
648 "// manual port",
649 "// C++: void loadModel(const std::map<std::string, std::string>& map)",
650 "//",
651 "//javadoc: VpMbGenericTracker::loadModel()\n",
652 "public void loadModel(String[] cameraNames, String[] modelFiles)",
653 "{",
654 " loadModel_5(nativeObj, cameraNames, modelFiles);",
655 "}"
656 ],
657 "cpp_code": [
658 "//",
659 "// manual port",
660 "// void loadModel()",
661 "//\n",
662 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_10 (JNIEnv*, jclass, jlong, jstring, jboolean, jlong);\n",
663 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_10",
664 " (JNIEnv* env, jclass , jlong self, jstring modelFile, jboolean verbose, jlong T_nativeObj)",
665 "{",
666 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
667 " try {",
668 " LOGD(\"%s\", method_name);",
669 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
670 " const char* utf_modelFile = env->GetStringUTFChars(modelFile, 0);",
671 " string n_modelFile( utf_modelFile ? utf_modelFile : \"\" );",
672 " env->ReleaseStringUTFChars(modelFile, utf_modelFile);",
673 " vpHomogeneousMatrix& T = *((vpHomogeneousMatrix*)T_nativeObj);",
674 " me->loadModel( n_modelFile, (bool)verbose, T );",
675 " } catch(const std::exception &e) {",
676 " throwJavaException(env, &e, method_name);",
677 " } catch (...) {",
678 " throwJavaException(env, 0, method_name);",
679 " }",
680 "}\n\n",
681 "//",
682 "// manual port",
683 "// void loadModel()",
684 "//\n",
685 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_11 (JNIEnv*, jclass, jlong, jstring);\n",
686 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_11",
687 " (JNIEnv* env, jclass , jlong self, jstring modelFile)",
688 "{",
689 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
690 " try {",
691 " LOGD(\"%s\", method_name);",
692 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
693 " const char* utf_modelFile = env->GetStringUTFChars(modelFile, 0);",
694 " string n_modelFile( utf_modelFile ? utf_modelFile : \"\" );",
695 " env->ReleaseStringUTFChars(modelFile, utf_modelFile);",
696 " me->loadModel( n_modelFile );",
697 " } catch(const std::exception &e) {",
698 " throwJavaException(env, &e, method_name);",
699 " } catch (...) {",
700 " throwJavaException(env, 0, method_name);",
701 " }",
702 "}\n\n",
703 "//",
704 "// manual port",
705 "// void loadModel()",
706 "//\n",
707 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_12 (JNIEnv*, jclass, jlong, jstring, jstring, jboolean, jlong, jlong);\n",
708 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_12",
709 " (JNIEnv* env, jclass , jlong self, jstring modelFile1, jstring modelFile2, jboolean verbose, jlong T1_nativeObj, jlong T2_nativeObj)",
710 "{",
711 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
712 " try {",
713 " LOGD(\"%s\", method_name);",
714 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
715 " const char* utf_modelFile1 = env->GetStringUTFChars(modelFile1, 0);",
716 " string n_modelFile1( utf_modelFile1 ? utf_modelFile1 : \"\" );",
717 " env->ReleaseStringUTFChars(modelFile1, utf_modelFile1);",
718 " const char* utf_modelFile2 = env->GetStringUTFChars(modelFile2, 0);",
719 " string n_modelFile2( utf_modelFile2 ? utf_modelFile2 : \"\" );",
720 " env->ReleaseStringUTFChars(modelFile2, utf_modelFile2);",
721 " vpHomogeneousMatrix& T1 = *((vpHomogeneousMatrix*)T1_nativeObj);",
722 " vpHomogeneousMatrix& T2 = *((vpHomogeneousMatrix*)T2_nativeObj);",
723 " me->loadModel( n_modelFile1, n_modelFile2, (bool)verbose, T1, T2 );",
724 " } catch(const std::exception &e) {",
725 " throwJavaException(env, &e, method_name);",
726 " } catch (...) {",
727 " throwJavaException(env, 0, method_name);",
728 " }",
729 "}\n\n",
730 "//",
731 "// manual port",
732 "// void loadModel()",
733 "//\n",
734 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_13 (JNIEnv*, jclass, jlong, jstring, jstring);\n",
735 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_13",
736 " (JNIEnv* env, jclass , jlong self, jstring modelFile1, jstring modelFile2)",
737 "{",
738 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
739 " try {",
740 " LOGD(\"%s\", method_name);",
741 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
742 " const char* utf_modelFile1 = env->GetStringUTFChars(modelFile1, 0);",
743 " string n_modelFile1( utf_modelFile1 ? utf_modelFile1 : \"\" );",
744 " env->ReleaseStringUTFChars(modelFile1, utf_modelFile1);",
745 " const char* utf_modelFile2 = env->GetStringUTFChars(modelFile2, 0);",
746 " string n_modelFile2( utf_modelFile2 ? utf_modelFile2 : \"\" );",
747 " env->ReleaseStringUTFChars(modelFile2, utf_modelFile2);",
748 " me->loadModel( n_modelFile1, n_modelFile2 );",
749 " } catch(const std::exception &e) {",
750 " throwJavaException(env, &e, method_name);",
751 " } catch (...) {",
752 " throwJavaException(env, 0, method_name);",
753 " }",
754 "}\n\n",
755 "//",
756 "// manual port",
757 "// void loadModel()",
758 "//\n",
759 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_14 (JNIEnv*, jclass, jlong, jobjectArray, jobjectArray, jboolean, jlongArray);\n",
760 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_14",
761 " (JNIEnv* env, jclass , jlong address, jobjectArray stringKeys, jobjectArray stringValues, jboolean verbose, jlongArray Ts)",
762 "{",
763 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
764 " try {",
765 " LOGD(\"%s\", method_name);",
766 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
767 " int stringCount = env->GetArrayLength(stringKeys);",
768 " int sizeT = env->GetArrayLength(Ts);",
769 " jlong *jTs = sizeT > 0 ? env->GetLongArrayElements(Ts, 0) : NULL;",
770 " std::map<std::string, std::string> map;",
771 " std::map<std::string, vpHomogeneousMatrix> mapOfT;",
772 " for (int i = 0; i < stringCount; i++) {",
773 " jstring key = (jstring) (env->GetObjectArrayElement(stringKeys, i));",
774 " jstring value = (jstring) (env->GetObjectArrayElement(stringValues, i));",
775 " map[convertTo(env, key)] = convertTo(env, value);",
776 " if (jTs != NULL) {",
777 " vpHomogeneousMatrix& T = *((vpHomogeneousMatrix*)jTs[i]);",
778 " mapOfT[convertTo(env, key)] = T;",
779 " }",
780 " }",
781 " tracker->loadModel(map, verbose, mapOfT);",
782 " } catch(const std::exception &e) {",
783 " throwJavaException(env, &e, method_name);",
784 " } catch (...) {",
785 " throwJavaException(env, 0, method_name);",
786 " }",
787 "}\n\n",
788 "//",
789 "// manual port",
790 "// void loadModel()",
791 "//\n",
792 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_15 (JNIEnv*, jclass, jlong, jobjectArray, jobjectArray);\n",
793 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_loadModel_15",
794 " (JNIEnv* env, jclass , jlong address, jobjectArray stringKeys, jobjectArray stringValues)",
795 "{",
796 " static const char method_name[] = \"vpMbGenericTracker::loadModel()\";",
797 " try {",
798 " LOGD(\"%s\", method_name);",
799 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
800 " int stringCount = env->GetArrayLength(stringKeys);",
801 " std::map<std::string, std::string> map;",
802 " for (int i = 0; i < stringCount; i++) {",
803 " jstring key = (jstring) (env->GetObjectArrayElement(stringKeys, i));",
804 " jstring value = (jstring) (env->GetObjectArrayElement(stringValues, i));",
805 " map[convertTo(env, key)] = convertTo(env, value);",
806 " }",
807 " tracker->loadModel(map);",
808 " } catch(const std::exception &e) {",
809 " throwJavaException(env, &e, method_name);",
810 " } catch (...) {",
811 " throwJavaException(env, 0, method_name);",
812 " }",
813 "}"
814 ],
815 "jn_code": [
816 "// C++: void loadModel(string modelFile, bool verbose = false, vpHomogeneousMatrix T = vpHomogeneousMatrix())",
817 "private static native void loadModel_0(long address, String modelFile, boolean verbose, long T_nativeObj);\n",
818 "// C++: void loadModel(string modelFile)",
819 "private static native void loadModel_1(long address, String modelFile);\n",
820 "// C++: void loadModel(string modelFile1, string modelFile2, bool verbose = false, vpHomogeneousMatrix T1 = vpHomogeneousMatrix(), vpHomogeneousMatrix T2 = vpHomogeneousMatrix())",
821 "private static native void loadModel_2(long address, String modelFile1, String modelFile2, boolean verbose, long T1_nativeObj, long T2_nativeObj);\n",
822 "// C++: void loadModel(string modelFile1, string modelFile2)",
823 "private static native void loadModel_3(long address, String modelFile1, String modelFile2);\n",
824 "// C++: void loadModel(const std::map<std::string, std::string>& map, bool verbose, const std::map<std::string, vpHomogeneousMatrix> &mapOfT)",
825 "private static native void loadModel_4(long address, String[] cameraNames, String[] modelFiles, boolean verbose, long[] Ts);\n",
826 "// C++: void loadModel(const std::map<std::string, std::string>& map, bool verbose, const std::map<std::string, vpHomogeneousMatrix> &mapOfT)",
827 "private static native void loadModel_5(long address, String[] cameraNames, String[] modelFiles);"
828 ]
829 },
830 "track": {
831 "j_code": [
832 "//",
833 "// manual port",
834 "// C++: void track(vpImage_char I)",
835 "//",
836 "//javadoc: VpMbGenericTracker::track()\n",
837 "public void track(org.visp.core.VpImageUChar I)",
838 "{",
839 " track_0(nativeObj, I.nativeObj);",
840 "}\n\n",
841 "//",
842 "// manual port",
843 "// C++: void track(vpImage_char I1, vpImage_char I2)",
844 "//",
845 "//javadoc: VpMbGenericTracker::track()\n",
846 "public void track(org.visp.core.VpImageUChar I1, org.visp.core.VpImageUChar I2)",
847 "{",
848 " track_1(nativeObj, I1.nativeObj, I2.nativeObj);",
849 "}\n\n",
850 "//",
851 "// manual port",
852 "// C++: void track(mapOfImages, mapOfPointClouds, mapOfPointCloudWidths, mapOfPointCloudHeights)",
853 "//",
854 "//javadoc: VpMbGenericTracker::track()\n",
855 "public void track(String[] cameraNames, org.visp.core.VpImageUChar[] images, String[] depthNames, org.visp.core.VpColVector[][] pointclouds, int[] pointcloudWidths, int[] pointcloudHeights)",
856 "{",
857 " track_2(nativeObj, cameraNames, org.visp.utils.Converters.array_vpImageUChar_to_array_native(images), depthNames, org.visp.utils.Converters.matrix_vpColVector_to_matrix_native(pointclouds), pointcloudWidths, pointcloudHeights);",
858 "}\n\n"
859 ],
860 "cpp_code": [
861 "//",
862 "// manual port",
863 "// void track()",
864 "//\n",
865 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_10 (JNIEnv*, jclass, jlong, jlong);\n",
866 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_10",
867 " (JNIEnv* env, jclass , jlong self, jlong I_nativeObj)",
868 "{",
869 " static const char method_name[] = \"vpMbGenericTracker::track_10()\";",
870 " try {",
871 " LOGD(\"%s\", method_name);",
872 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
873 " vpImage<unsigned char>& I = *((vpImage<unsigned char>*)I_nativeObj);",
874 " me->track( I );",
875 " return;",
876 " } catch(const std::exception &e) {",
877 " throwJavaException(env, &e, method_name);",
878 " } catch (...) {",
879 " throwJavaException(env, 0, method_name);",
880 " }",
881 "}\n\n",
882 "//",
883 "// manual port",
884 "// void track()",
885 "//\n",
886 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_11 (JNIEnv*, jclass, jlong, jlong, jlong);\n",
887 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_11",
888 " (JNIEnv* env, jclass , jlong self, jlong I1_nativeObj, jlong I2_nativeObj)",
889 "{",
890 " static const char method_name[] = \"vpMbGenericTracker::track_11()\";",
891 " try {",
892 " LOGD(\"%s\", method_name);",
893 " vpMbGenericTracker* me = (vpMbGenericTracker*) self; //TODO: check for NULL",
894 " vpImage<unsigned char>& I1 = *((vpImage<unsigned char>*)I1_nativeObj);",
895 " vpImage<unsigned char>& I2 = *((vpImage<unsigned char>*)I2_nativeObj);",
896 " me->track( I1, I2 );",
897 " return;",
898 " } catch(const std::exception &e) {",
899 " throwJavaException(env, &e, method_name);",
900 " } catch (...) {",
901 " throwJavaException(env, 0, method_name);",
902 " }",
903 "}\n\n",
904 "//",
905 "// manual port",
906 "// void track()",
907 "//\n",
908 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_12 (JNIEnv*, jclass, jlong, jobjectArray, jlongArray, jobjectArray, jobjectArray, jintArray, jintArray);\n",
909 "JNIEXPORT void JNICALL Java_org_visp_mbt_VpMbGenericTracker_track_12",
910 " (JNIEnv* env, jclass , jlong self, jobjectArray cameraNames, jlongArray images, jobjectArray depthNames, jobjectArray pointclouds, jintArray pointcloudWidths, jintArray pointcloudHeights)",
911 "{",
912 " static const char method_name[] = \"vpMbGenericTracker::track_12()\";",
913 " try {",
914 " LOGD(\"%s\", method_name);",
915 " vpMbGenericTracker* tracker = (vpMbGenericTracker*) self; //TODO: check for NULL",
916 " int cameraNamesCount = env->GetArrayLength(cameraNames);",
917 " jlong *jlong_images = env->GetLongArrayElements(images, 0);",
918 " std::map<std::string, const vpImage<unsigned char> *> mapOfImages;",
919 " for (int i = 0; i < cameraNamesCount; i++) {",
920 " jstring key = (jstring) (env->GetObjectArrayElement(cameraNames, i));",
921 " const vpImage<unsigned char> *I = ((vpImage<unsigned char>*)jlong_images[i]);",
922 " mapOfImages[convertTo(env, key)] = I;",
923 " }",
924 " env->ReleaseLongArrayElements(images, jlong_images, JNI_ABORT);",
925 " int depthNamesCount = env->GetArrayLength(depthNames);",
926 " std::map<std::string, const std::vector<vpColVector> *> mapOfPointclouds;",
927 " std::map<std::string, std::vector<vpColVector> > mapOfPointclouds_noConst;",
928 " std::map<std::string, unsigned int> mapOfWidths, mapOfHeights;",
929 " jint* widths = env->GetIntArrayElements(pointcloudWidths, 0);",
930 " jint* heights = env->GetIntArrayElements(pointcloudHeights, 0);",
931 " for (int i = 0; i < depthNamesCount; i++) {",
932 " jstring key = (jstring) (env->GetObjectArrayElement(depthNames, i));",
933 " jlongArray values = (jlongArray) (env->GetObjectArrayElement(pointclouds, i));",
934 " int depthCount = env->GetArrayLength(values);",
935 " jboolean isCopy;",
936 " jlong* values_arr = (jlong*)env->GetPrimitiveArrayCritical(values, &isCopy);",
937 " env->ReleasePrimitiveArrayCritical(values, values_arr, JNI_ABORT);",
938 " std::string depthName = convertTo(env, key);",
939 " mapOfWidths[depthName] = (unsigned int)widths[i];",
940 " mapOfHeights[depthName] = (unsigned int)heights[i];",
941 " mapOfPointclouds_noConst[depthName].reserve(depthCount);",
942 " for (int j = 0; j < depthCount; j++) {",
943 " const vpColVector& ref = *((vpColVector*)values_arr[j]);",
944 " mapOfPointclouds_noConst[depthName].push_back(ref);",
945 " }",
946 " mapOfPointclouds[depthName] = &mapOfPointclouds_noConst[depthName];",
947 " }",
948 " env->ReleaseIntArrayElements(pointcloudWidths, widths, JNI_ABORT);",
949 " env->ReleaseIntArrayElements(pointcloudHeights, heights, JNI_ABORT);",
950 " tracker->track(mapOfImages, mapOfPointclouds, mapOfWidths, mapOfHeights);",
951 " } catch(const std::exception &e) {",
952 " throwJavaException(env, &e, method_name);",
953 " } catch (...) {",
954 " throwJavaException(env, 0, method_name);",
955 " }",
956 "}"
957 ],
958 "jn_code": [
959 "// C++: void track(vpImage_char I)",
960 "private static native void track_0(long address, long I_nativeObj);\n",
961 "// C++: void track(vpImage_char I1, vpImage_char I2",
962 "private static native void track_1(long address, long I1_nativeObj, long I2_nativeObj);\n",
963 "// C++: void track(mapOfImages, mapOfPointClouds, mapOfPointCloudWidths, mapOfPointCloudHeights)",
964 "private static native void track_2(long address, String[] cameraNames, long[] images, String[] depthNames, long[][] pointclouds, int[] pointcloudWidths, int[] pointcloudHeights);"
965 ]
966 },
967 "getError": {
968 "j_code": [
969 ""
970 ],
971 "cpp_code": [
972 ""
973 ],
974 "jn_code": [
975 ""
976 ]
977 },
978 "getRobustWeights": {
979 "j_code": [
980 ""
981 ],
982 "cpp_code": [
983 ""
984 ],
985 "jn_code": [
986 ""
987 ]
988 },
989 "getClipping": {
990 "j_code": [
991 ""
992 ],
993 "cpp_code": [
994 ""
995 ],
996 "jn_code": [
997 ""
998 ]
999 },
1000 "setNbRayCastingAttemptsForVisibility": {
1001 "j_code": [
1002 ""
1003 ],
1004 "cpp_code": [
1005 ""
1006 ],
1007 "jn_code": [
1008 ""
1009 ]
1010 },
1011 "setGoodNbRayCastingAttemptsRatio": {
1012 "j_code": [
1013 ""
1014 ],
1015 "cpp_code": [
1016 ""
1017 ],
1018 "jn_code": [
1019 ""
1020 ]
1021 },
1022 "getKltNbPoints": {
1023 "j_code": [
1024 ""
1025 ],
1026 "cpp_code": [
1027 ""
1028 ],
1029 "jn_code": [
1030 ""
1031 ]
1032 },
1033 "getKltMaskBorder": {
1034 "j_code": [
1035 ""
1036 ],
1037 "cpp_code": [
1038 ""
1039 ],
1040 "jn_code": [
1041 ""
1042 ]
1043 },
1044 "setKltMaskBorder": {
1045 "j_code": [
1046 ""
1047 ],
1048 "cpp_code": [
1049 ""
1050 ],
1051 "jn_code": [
1052 ""
1053 ]
1054 },
1055 "getKltThresholdAcceptation": {
1056 "j_code": [
1057 ""
1058 ],
1059 "cpp_code": [
1060 ""
1061 ],
1062 "jn_code": [
1063 ""
1064 ]
1065 },
1066 "setKltThresholdAcceptation": {
1067 "j_code": [
1068 ""
1069 ],
1070 "cpp_code": [
1071 ""
1072 ],
1073 "jn_code": [
1074 ""
1075 ]
1076 },
1077 "setUseKltTracking": {
1078 "j_code": [
1079 ""
1080 ],
1081 "cpp_code": [
1082 ""
1083 ],
1084 "jn_code": [
1085 ""
1086 ]
1087 },
1088 "getModelForDisplay" : {
1089 "j_code" : [
1090 "//",
1091 "// manual port",
1092 "// C++: void getModelForDisplay(mapOfModels, mapOfwidths, mapOfheights, mapOfcMos, mapOfCams, boolean displayFullModel)",
1093 "//",
1094 "//javadoc: VpMbGenericTracker::getModelForDisplay()\n",
1095 "public double[][][] getModelForDisplay(String[] cameraNames, int[] widths, int[] heights, org.visp.core.VpHomogeneousMatrix[] cMos, org.visp.core.VpCameraParameters[] cams, boolean displayFullModel)",
1096 "{",
1097 " return getModelForDisplay(nativeObj, cameraNames, widths, heights, org.visp.utils.Converters.array_vpHomogeneousMatrix_to_array_native(cMos), org.visp.utils.Converters.array_vpCameraParameters_to_array_native(cams), displayFullModel);",
1098 "}"
1099 ],
1100 "cpp_code" : [
1101 "//",
1102 "// manual port",
1103 "// void getModelForDisplay(mapOfModels, mapOfwidths, mapOfheights, mapOfcMos, mapOfCams, boolean displayFullModel)",
1104 "//\n",
1105 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getModelForDisplay (JNIEnv*, jclass, jlong, jobjectArray, jintArray, jintArray, jlongArray, jlongArray, jboolean);\n",
1106 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getModelForDisplay",
1107 " (JNIEnv* env, jclass , jlong address, jobjectArray cameraNames, jintArray widths, jintArray heights, jlongArray cMos, jlongArray cams, jboolean displayFullModel)",
1108 "{",
1109 " static const char method_name[] = \"vpMbGenericTracker::getModelForDisplay()\";",
1110 " try {",
1111 " LOGD(\"%s\", method_name);",
1112 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
1113 " std::map<std::string, unsigned int> mapOfwidths;",
1114 " std::map<std::string, unsigned int> mapOfheights;",
1115 " std::map<std::string, vpHomogeneousMatrix> mapOfcMos;",
1116 " std::map<std::string, vpCameraParameters> mapOfCams;",
1117 " std::vector<std::string> keys = array_string_to_vector(env, cameraNames);",
1118 " std::vector<int> widths_vec = List_to_vector_int(env, widths);",
1119 " std::vector<int> heights_vec = List_to_vector_int(env, heights);",
1120 " std::vector<vpHomogeneousMatrix> poses_vec = List_to_vector_vpHomogeneousMatrix(env, cMos);",
1121 " std::vector<vpCameraParameters> cams_vec = List_to_vector_vpCameraParameters(env, cams);",
1122 " for (size_t i = 0; i < keys.size(); i++) {",
1123 " const std::string& key = keys[i];",
1124 " mapOfwidths[key] = widths_vec[i];",
1125 " mapOfheights[key] = heights_vec[i];",
1126 " mapOfcMos[key] = poses_vec[i];",
1127 " mapOfCams[key] = cams_vec[i];",
1128 " }",
1129 " std::map<std::string, std::vector<std::vector<double> > > mapOfModels;",
1130 " tracker->getModelForDisplay(mapOfModels, mapOfwidths, mapOfheights, mapOfcMos, mapOfCams, (bool) displayFullModel);",
1131 " return map_string_vector_vector_double_to_array_native(env, mapOfModels);",
1132 " } catch(const std::exception &e) {",
1133 " throwJavaException(env, &e, method_name);",
1134 " } catch (...) {",
1135 " throwJavaException(env, 0, method_name);",
1136 " }",
1137 " return 0;",
1138 "}"
1139 ],
1140 "jn_code" : [
1141 "// C++: void getModelForDisplay(mapOfModels, mapOfwidths, mapOfheights, mapOfcMos, mapOfCams, boolean displayFullModel)",
1142 "private static native double[][][] getModelForDisplay(long address, String[] cameraNames, int[] widths, int[] heights, long[] cMos, long[] cams, boolean displayFullModel);"
1143 ]
1144 },
1145 "getFeaturesForDisplay" : {
1146 "j_code" : [
1147 "//",
1148 "// manual port",
1149 "// C++: void getFeaturesForDisplay(std::map<std::string, std::vector<std::vector<double> > > &mapOfFeatures)",
1150 "//",
1151 "//javadoc: VpMbGenericTracker::getFeaturesForDisplay()\n",
1152 "public double[][][] getFeaturesForDisplay()",
1153 "{",
1154 " return getFeaturesForDisplay(nativeObj);",
1155 "}"
1156 ],
1157 "cpp_code" : [
1158 "//",
1159 "// manual port",
1160 "// void getFeaturesForDisplay(std::map<std::string, std::vector<std::vector<double> > > &mapOfFeatures)",
1161 "//\n",
1162 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getFeaturesForDisplay (JNIEnv*, jclass, jlong);\n",
1163 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getFeaturesForDisplay",
1164 " (JNIEnv* env, jclass , jlong address)",
1165 "{",
1166 " static const char method_name[] = \"vpMbGenericTracker::getFeaturesForDisplay()\";",
1167 " try {",
1168 " LOGD(\"%s\", method_name);",
1169 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
1170 " std::map<std::string, std::vector<std::vector<double> > > mapOfFeatures;",
1171 " tracker->getFeaturesForDisplay(mapOfFeatures);",
1172 " return map_string_vector_vector_double_to_array_native(env, mapOfFeatures);",
1173 " } catch(const std::exception &e) {",
1174 " throwJavaException(env, &e, method_name);",
1175 " } catch (...) {",
1176 " throwJavaException(env, 0, method_name);",
1177 " }",
1178 " return 0;",
1179 "}"
1180 ],
1181 "jn_code" : [
1182 "// C++: void getFeaturesForDisplay(std::map<std::string, std::vector<std::vector<double> > > &mapOfFeatures)",
1183 "private static native double[][][] getFeaturesForDisplay(long address);"
1184 ]
1185 },
1186 "getCameraNames" : {
1187 "j_code" : [
1188 "//",
1189 "// manual port",
1190 "// C++: void getCameraNames()",
1191 "//",
1192 "//javadoc: VpMbGenericTracker::getCameraNames()\n",
1193 "public String[] getCameraNames()",
1194 "{",
1195 " return getCameraNames(nativeObj);",
1196 "}"
1197 ],
1198 "cpp_code" : [
1199 "//",
1200 "// manual port",
1201 "// void getCameraNames()",
1202 "//\n",
1203 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraNames (JNIEnv*, jclass, jlong);\n",
1204 "JNIEXPORT jobjectArray JNICALL Java_org_visp_mbt_VpMbGenericTracker_getCameraNames",
1205 " (JNIEnv* env, jclass , jlong address)",
1206 "{",
1207 " static const char method_name[] = \"vpMbGenericTracker::getCameraNames()\";",
1208 " try {",
1209 " LOGD(\"%s\", method_name);",
1210 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
1211 " std::vector<std::string> cameraNames = tracker->getCameraNames();",
1212 " return vector_string_to_array_native(env, cameraNames);",
1213 " } catch(const std::exception &e) {",
1214 " throwJavaException(env, &e, method_name);",
1215 " } catch (...) {",
1216 " throwJavaException(env, 0, method_name);",
1217 " }",
1218 " return 0;",
1219 "}"
1220 ],
1221 "jn_code" : [
1222 "// C++: void getCameraNames()",
1223 "private static native String[] getCameraNames(long address);"
1224 ]
1225 },
1226 "getReferenceCameraName" : {
1227 "j_code" : [
1228 "//",
1229 "// manual port",
1230 "// C++: std::string getReferenceCameraName()",
1231 "//",
1232 "//javadoc: VpMbGenericTracker::getReferenceCameraName()\n",
1233 "public String getReferenceCameraName()",
1234 "{",
1235 " return getReferenceCameraName(nativeObj);",
1236 "}"
1237 ],
1238 "cpp_code" : [
1239 "//",
1240 "// manual port",
1241 "// std::string getReferenceCameraName()",
1242 "//\n",
1243 "JNIEXPORT jstring JNICALL Java_org_visp_mbt_VpMbGenericTracker_getReferenceCameraName (JNIEnv*, jclass, jlong);\n",
1244 "JNIEXPORT jstring JNICALL Java_org_visp_mbt_VpMbGenericTracker_getReferenceCameraName",
1245 " (JNIEnv* env, jclass , jlong address)",
1246 "{",
1247 " static const char method_name[] = \"vpMbGenericTracker::getReferenceCameraName()\";",
1248 " try {",
1249 " LOGD(\"%s\", method_name);",
1250 " vpMbGenericTracker *tracker = (vpMbGenericTracker*) address;",
1251 " return convertTo(env, tracker->getReferenceCameraName());",
1252 " } catch(const std::exception &e) {",
1253 " throwJavaException(env, &e, method_name);",
1254 " } catch (...) {",
1255 " throwJavaException(env, 0, method_name);",
1256 " }",
1257 " return 0;",
1258 "}"
1259 ],
1260 "jn_code" : [
1261 "// C++: std::string getReferenceCameraName()",
1262 "private static native String getReferenceCameraName(long address);"
1263 ]
1264 }
1265 }
1266 }
1267}