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
}
modules
java
misc
mbt
gen_dict.json
Generated by
1.9.8