1 /****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * Load XML Parameter for Model Based Tracker.
33 *
34 *****************************************************************************/
35 #include <visp3/core/vpConfig.h>
36
37 #include <iostream>
38 #include <map>
39 #include <clocale>
40
41 #include <visp3/mbt/vpMbtXmlGenericParser.h>
42
43 #include <pugixml.hpp>
44
45 #ifndef DOXYGEN_SHOULD_SKIP_THIS
46 class vpMbtXmlGenericParser::Impl
47 {
48 public:
Impl(int type=EDGE_PARSER)49 Impl(int type = EDGE_PARSER) :
50 m_parserType(type),
51 //<camera>
52 m_cam(),
53 //<face>
54 m_angleAppear(70), m_angleDisappear(80), m_hasNearClipping(false), m_nearClipping(false), m_hasFarClipping(false),
55 m_farClipping(false), m_fovClipping(false),
56 //<lod>
57 m_useLod(false), m_minLineLengthThreshold(50.0), m_minPolygonAreaThreshold(2500.0),
58 //<ecm>
59 m_ecm(),
60 //<klt>
61 m_kltMaskBorder(0), m_kltMaxFeatures(0), m_kltWinSize(0), m_kltQualityValue(0.), m_kltMinDist(0.),
62 m_kltHarrisParam(0.), m_kltBlockSize(0), m_kltPyramidLevels(0),
63 //<depth_normal>
64 m_depthNormalFeatureEstimationMethod(vpMbtFaceDepthNormal::ROBUST_FEATURE_ESTIMATION),
65 m_depthNormalPclPlaneEstimationMethod(2), m_depthNormalPclPlaneEstimationRansacMaxIter(200),
66 m_depthNormalPclPlaneEstimationRansacThreshold(0.001), m_depthNormalSamplingStepX(2), m_depthNormalSamplingStepY(2),
67 //<depth_dense>
68 m_depthDenseSamplingStepX(2), m_depthDenseSamplingStepY(2),
69 //<projection_error>
70 m_projectionErrorMe(), m_projectionErrorKernelSize(2), //5x5
71 m_nodeMap(),
72 m_verbose(true)
73 {
74 init();
75 }
76
parse(const std::string & filename)77 void parse(const std::string &filename)
78 {
79 pugi::xml_document doc;
80 if (!doc.load_file(filename.c_str())) {
81 throw vpException(vpException::ioError, "Cannot open file: %s", filename.c_str());
82 }
83
84 bool camera_node = false;
85 bool face_node = false;
86 bool ecm_node = false;
87 bool klt_node = false;
88 bool lod_node = false;
89 bool depth_normal_node = false;
90 bool depth_dense_node = false;
91 bool projection_error_node = false;
92
93 pugi::xml_node root_node = doc.document_element();
94 for (pugi::xml_node dataNode = root_node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
95 if (dataNode.type() == pugi::node_element) {
96 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
97 if (iter_data != m_nodeMap.end()) {
98 switch (iter_data->second) {
99 case camera:
100 if (m_parserType != PROJECTION_ERROR_PARSER) {
101 read_camera(dataNode);
102 camera_node = true;
103 }
104 break;
105
106 case face:
107 if (m_parserType != PROJECTION_ERROR_PARSER) {
108 read_face(dataNode);
109 face_node = true;
110 }
111 break;
112
113 case lod:
114 if (m_parserType != PROJECTION_ERROR_PARSER) {
115 read_lod(dataNode);
116 lod_node = true;
117 }
118 break;
119
120 case ecm:
121 if (m_parserType & EDGE_PARSER) {
122 read_ecm(dataNode);
123 ecm_node = true;
124 }
125 break;
126
127 case sample:
128 if (m_parserType & EDGE_PARSER)
129 read_sample_deprecated(dataNode);
130 break;
131
132 case klt:
133 if (m_parserType & KLT_PARSER) {
134 read_klt(dataNode);
135 klt_node = true;
136 }
137 break;
138
139 case depth_normal:
140 if (m_parserType & DEPTH_NORMAL_PARSER) {
141 read_depth_normal(dataNode);
142 depth_normal_node = true;
143 }
144 break;
145
146 case depth_dense:
147 if (m_parserType & DEPTH_DENSE_PARSER) {
148 read_depth_dense(dataNode);
149 depth_dense_node = true;
150 }
151 break;
152
153 case projection_error:
154 if (m_parserType == PROJECTION_ERROR_PARSER) {
155 read_projection_error(dataNode);
156 projection_error_node = true;
157 }
158 break;
159
160 default:
161 break;
162 }
163 }
164 }
165 }
166
167 if (m_verbose) {
168 if (m_parserType == PROJECTION_ERROR_PARSER) {
169 if (!projection_error_node) {
170 std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << " (default)" << std::endl;
171 std::cout << "projection_error : kernel_size : " << m_projectionErrorKernelSize*2+1 << "x"
172 << m_projectionErrorKernelSize*2+1 << " (default)" << std::endl;
173 }
174 } else {
175 if (!camera_node) {
176 std::cout << "camera : u0 : " << m_cam.get_u0() << " (default)" << std::endl;
177 std::cout << "camera : v0 : " << m_cam.get_v0() << " (default)" << std::endl;
178 std::cout << "camera : px : " << m_cam.get_px() << " (default)" << std::endl;
179 std::cout << "camera : py : " << m_cam.get_py() << " (default)" << std::endl;
180 }
181
182 if (!face_node) {
183 std::cout << "face : Angle Appear : " << m_angleAppear << " (default)" << std::endl;
184 std::cout << "face : Angle Disappear : " << m_angleDisappear << " (default)" << std::endl;
185 }
186
187 if (!lod_node) {
188 std::cout << "lod : use lod : " << m_useLod << " (default)" << std::endl;
189 std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << " (default)" << std::endl;
190 std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << " (default)" << std::endl;
191 }
192
193 if (!ecm_node && (m_parserType & EDGE_PARSER)) {
194 std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
195 std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
196 std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
197 std::cout << "ecm : contrast : threshold : " << m_ecm.getThreshold() << " (default)" << std::endl;
198 std::cout << "ecm : contrast : mu1 : " << m_ecm.getMu1() << " (default)" << std::endl;
199 std::cout << "ecm : contrast : mu2 : " << m_ecm.getMu2() << " (default)" << std::endl;
200 std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
201 }
202
203 if (!klt_node && (m_parserType & KLT_PARSER)) {
204 std::cout << "klt : Mask Border : " << m_kltMaskBorder << " (default)" << std::endl;
205 std::cout << "klt : Max Features : " << m_kltMaxFeatures << " (default)" << std::endl;
206 std::cout << "klt : Windows Size : " << m_kltWinSize << " (default)" << std::endl;
207 std::cout << "klt : Quality : " << m_kltQualityValue << " (default)" << std::endl;
208 std::cout << "klt : Min Distance : " << m_kltMinDist << " (default)" << std::endl;
209 std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << " (default)" << std::endl;
210 std::cout << "klt : Block Size : " << m_kltBlockSize << " (default)" << std::endl;
211 std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << " (default)" << std::endl;
212 }
213
214 if (!depth_normal_node && (m_parserType & DEPTH_NORMAL_PARSER)) {
215 std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << " (default)"
216 << std::endl;
217 std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
218 << " (default)" << std::endl;
219 std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
220 << " (default)" << std::endl;
221 std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
222 << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
223 std::cout << "depth normal : sampling_step : step_X " << m_depthNormalSamplingStepX << " (default)" << std::endl;
224 std::cout << "depth normal : sampling_step : step_Y " << m_depthNormalSamplingStepY << " (default)" << std::endl;
225 }
226
227 if (!depth_dense_node && (m_parserType & DEPTH_DENSE_PARSER)) {
228 std::cout << "depth dense : sampling_step : step_X " << m_depthDenseSamplingStepX << " (default)" << std::endl;
229 std::cout << "depth dense : sampling_step : step_Y " << m_depthDenseSamplingStepY << " (default)" << std::endl;
230 }
231 }
232 }
233 }
234
235 /*!
236 Read camera information.
237
238 \param node : Pointer to the node of the camera information.
239 */
read_camera(const pugi::xml_node & node)240 void read_camera(const pugi::xml_node &node)
241 {
242 bool u0_node = false;
243 bool v0_node = false;
244 bool px_node = false;
245 bool py_node = false;
246
247 // current data values.
248 double d_u0 = m_cam.get_u0();
249 double d_v0 = m_cam.get_v0();
250 double d_px = m_cam.get_px();
251 double d_py = m_cam.get_py();
252
253 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
254 if (dataNode.type() == pugi::node_element) {
255 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
256 if (iter_data != m_nodeMap.end()) {
257 switch (iter_data->second) {
258 case u0:
259 d_u0 = dataNode.text().as_double();
260 u0_node = true;
261 break;
262
263 case v0:
264 d_v0 = dataNode.text().as_double();
265 v0_node = true;
266 break;
267
268 case px:
269 d_px = dataNode.text().as_double();
270 px_node = true;
271 break;
272
273 case py:
274 d_py = dataNode.text().as_double();
275 py_node = true;
276 break;
277
278 default:
279 break;
280 }
281 }
282 }
283 }
284
285 m_cam.initPersProjWithoutDistortion(d_px, d_py, d_u0, d_v0);
286
287 if (m_verbose) {
288 if (!u0_node)
289 std::cout << "camera : u0 : " << m_cam.get_u0() << " (default)" << std::endl;
290 else
291 std::cout << "camera : u0 : " << m_cam.get_u0() << std::endl;
292
293 if (!v0_node)
294 std::cout << "camera : v0 : " << m_cam.get_v0() << " (default)" << std::endl;
295 else
296 std::cout << "camera : v0 : " << m_cam.get_v0() << std::endl;
297
298 if (!px_node)
299 std::cout << "camera : px : " << m_cam.get_px() << " (default)" << std::endl;
300 else
301 std::cout << "camera : px : " << m_cam.get_px() << std::endl;
302
303 if (!py_node)
304 std::cout << "camera : py : " << m_cam.get_py() << " (default)" << std::endl;
305 else
306 std::cout << "camera : py : " << m_cam.get_py() << std::endl;
307 }
308 }
309
310 /*!
311 Read depth normal information.
312
313 \param node : Pointer to the node information.
314 */
read_depth_normal(const pugi::xml_node & node)315 void read_depth_normal(const pugi::xml_node &node)
316 {
317 bool feature_estimation_method_node = false;
318 bool PCL_plane_estimation_node = false;
319 bool sampling_step_node = false;
320
321 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
322 if (dataNode.type() == pugi::node_element) {
323 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
324 if (iter_data != m_nodeMap.end()) {
325 switch (iter_data->second) {
326 case feature_estimation_method:
327 m_depthNormalFeatureEstimationMethod =
328 (vpMbtFaceDepthNormal::vpFeatureEstimationType)dataNode.text().as_int();
329 feature_estimation_method_node = true;
330 break;
331
332 case PCL_plane_estimation:
333 read_depth_normal_PCL(dataNode);
334 PCL_plane_estimation_node = true;
335 break;
336
337 case depth_sampling_step:
338 read_depth_normal_sampling_step(dataNode);
339 sampling_step_node = true;
340 break;
341
342 default:
343 break;
344 }
345 }
346 }
347 }
348
349 if (m_verbose) {
350 if (!feature_estimation_method_node)
351 std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << " (default)"
352 << std::endl;
353 else
354 std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << std::endl;
355
356 if (!PCL_plane_estimation_node) {
357 std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
358 << " (default)" << std::endl;
359 std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
360 << " (default)" << std::endl;
361 std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
362 << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
363 }
364
365 if (!sampling_step_node) {
366 std::cout << "depth normal : sampling_step : step_X " << m_depthNormalSamplingStepX << " (default)" << std::endl;
367 std::cout << "depth normal : sampling_step : step_Y " << m_depthNormalSamplingStepY << " (default)" << std::endl;
368 }
369 }
370 }
371
372 /*!
373 Read depth normal PCL properties.
374
375 \param node : Pointer to the node information.
376 */
read_depth_normal_PCL(const pugi::xml_node & node)377 void read_depth_normal_PCL(const pugi::xml_node &node)
378 {
379 bool PCL_plane_estimation_method_node = false;
380 bool PCL_plane_estimation_ransac_max_iter_node = false;
381 bool PCL_plane_estimation_ransac_threshold_node = false;
382
383 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
384 if (dataNode.type() == pugi::node_element) {
385 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
386 if (iter_data != m_nodeMap.end()) {
387 switch (iter_data->second) {
388 case PCL_plane_estimation_method:
389 m_depthNormalPclPlaneEstimationMethod = dataNode.text().as_int();
390 PCL_plane_estimation_method_node = true;
391 break;
392
393 case PCL_plane_estimation_ransac_max_iter:
394 m_depthNormalPclPlaneEstimationRansacMaxIter = dataNode.text().as_int();
395 PCL_plane_estimation_ransac_max_iter_node = true;
396 break;
397
398 case PCL_plane_estimation_ransac_threshold:
399 m_depthNormalPclPlaneEstimationRansacThreshold = dataNode.text().as_double();
400 PCL_plane_estimation_ransac_threshold_node = true;
401 break;
402
403 default:
404 break;
405 }
406 }
407 }
408 }
409
410 if (m_verbose) {
411 if (!PCL_plane_estimation_method_node)
412 std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
413 << " (default)" << std::endl;
414 else
415 std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
416 << std::endl;
417
418 if (!PCL_plane_estimation_ransac_max_iter_node)
419 std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
420 << " (default)" << std::endl;
421 else
422 std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
423 << std::endl;
424
425 if (!PCL_plane_estimation_ransac_threshold_node)
426 std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
427 << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
428 else
429 std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
430 << m_depthNormalPclPlaneEstimationRansacThreshold << std::endl;
431 }
432 }
433
434 /*!
435 Read depth normal sampling step.
436
437 \param node : Pointer to the node information.
438 */
read_depth_normal_sampling_step(const pugi::xml_node & node)439 void read_depth_normal_sampling_step(const pugi::xml_node &node)
440 {
441 bool sampling_step_X_node = false;
442 bool sampling_step_Y_node = false;
443
444 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
445 if (dataNode.type() == pugi::node_element) {
446 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
447 if (iter_data != m_nodeMap.end()) {
448 switch (iter_data->second) {
449 case depth_sampling_step_X:
450 m_depthNormalSamplingStepX = dataNode.text().as_uint();
451 sampling_step_X_node = true;
452 break;
453
454 case depth_sampling_step_Y:
455 m_depthNormalSamplingStepY = dataNode.text().as_uint();
456 sampling_step_Y_node = true;
457 break;
458
459 default:
460 break;
461 }
462 }
463 }
464 }
465
466 if (m_verbose) {
467 if (!sampling_step_X_node)
468 std::cout << "depth normal : sampling_step : step_X : " << m_depthNormalSamplingStepX << " (default)" << std::endl;
469 else
470 std::cout << "depth normal : sampling_step : step_X : " << m_depthNormalSamplingStepX << std::endl;
471
472 if (!sampling_step_Y_node)
473 std::cout << "depth normal : sampling_step : step_Y : " << m_depthNormalSamplingStepY << " (default)" << std::endl;
474 else
475 std::cout << "depth normal : sampling_step : step_Y : " << m_depthNormalSamplingStepY << std::endl;
476 }
477 }
478
479 /*!
480 Read depth dense information.
481
482 \param node : Pointer to the node of the ecm information.
483 */
read_depth_dense(const pugi::xml_node & node)484 void read_depth_dense(const pugi::xml_node &node)
485 {
486 bool sampling_step_node = false;
487
488 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
489 if (dataNode.type() == pugi::node_element) {
490 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
491 if (iter_data != m_nodeMap.end()) {
492 switch (iter_data->second) {
493 case depth_dense_sampling_step:
494 read_depth_dense_sampling_step(dataNode);
495 sampling_step_node = true;
496 break;
497
498 default:
499 break;
500 }
501 }
502 }
503 }
504
505 if (!sampling_step_node && m_verbose) {
506 std::cout << "depth dense : sampling_step : step_X " << m_depthDenseSamplingStepX << " (default)" << std::endl;
507 std::cout << "depth dense : sampling_step : step_Y " << m_depthDenseSamplingStepY << " (default)" << std::endl;
508 }
509 }
510
511 /*!
512 Read depth dense sampling step.
513
514 \param node : Pointer to the node of the range information.
515 */
read_depth_dense_sampling_step(const pugi::xml_node & node)516 void read_depth_dense_sampling_step(const pugi::xml_node &node)
517 {
518 bool sampling_step_X_node = false;
519 bool sampling_step_Y_node = false;
520
521 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
522 if (dataNode.type() == pugi::node_element) {
523 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
524 if (iter_data != m_nodeMap.end()) {
525 switch (iter_data->second) {
526 case depth_dense_sampling_step_X:
527 m_depthDenseSamplingStepX = dataNode.text().as_uint();
528 sampling_step_X_node = true;
529 break;
530
531 case depth_dense_sampling_step_Y:
532 m_depthDenseSamplingStepY = dataNode.text().as_uint();
533 sampling_step_Y_node = true;
534 break;
535
536 default:
537 break;
538 }
539 }
540 }
541 }
542
543 if (m_verbose) {
544 if (!sampling_step_X_node)
545 std::cout << "depth dense : sampling_step : step_X : " << m_depthDenseSamplingStepX << " (default)" << std::endl;
546 else
547 std::cout << "depth dense : sampling_step : step_X : " << m_depthDenseSamplingStepX << std::endl;
548
549 if (!sampling_step_Y_node)
550 std::cout << "depth dense : sampling_step : step_Y : " << m_depthDenseSamplingStepY << " (default)" << std::endl;
551 else
552 std::cout << "depth dense : sampling_step : step_Y : " << m_depthDenseSamplingStepY << std::endl;
553 }
554 }
555
556 /*!
557 Read ecm information.
558
559 \param node : Pointer to the node of the ecm information.
560 */
read_ecm(const pugi::xml_node & node)561 void read_ecm(const pugi::xml_node &node)
562 {
563 bool mask_node = false;
564 bool range_node = false;
565 bool contrast_node = false;
566 bool sample_node = false;
567
568 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
569 if (dataNode.type() == pugi::node_element) {
570 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
571 if (iter_data != m_nodeMap.end()) {
572 switch (iter_data->second) {
573 case mask:
574 read_ecm_mask(dataNode);
575 mask_node = true;
576 break;
577
578 case range:
579 read_ecm_range(dataNode);
580 range_node = true;
581 break;
582
583 case contrast:
584 read_ecm_contrast(dataNode);
585 contrast_node = true;
586 break;
587
588 case sample:
589 read_ecm_sample(dataNode);
590 sample_node = true;
591 break;
592
593 default:
594 break;
595 }
596 }
597 }
598 }
599
600 if (m_verbose) {
601 if (!mask_node) {
602 std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
603 std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
604 }
605
606 if (!range_node) {
607 std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
608 }
609
610 if (!contrast_node) {
611 std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << " (default)" << std::endl;
612 std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << " (default)" << std::endl;
613 std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << " (default)" << std::endl;
614 }
615
616 if (!sample_node) {
617 std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
618 }
619 }
620 }
621
622 /*!
623 Read the contrast information from the xml file.
624
625 \param node : Pointer to the node of the contrast information.
626 */
read_ecm_contrast(const pugi::xml_node & node)627 void read_ecm_contrast(const pugi::xml_node &node)
628 {
629 bool edge_threshold_node = false;
630 bool mu1_node = false;
631 bool mu2_node = false;
632
633 // current data values.
634 double d_edge_threshold = m_ecm.getThreshold();
635 double d_mu1 = m_ecm.getMu1();
636 double d_mu2 = m_ecm.getMu2();
637
638 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
639 if (dataNode.type() == pugi::node_element) {
640 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
641 if (iter_data != m_nodeMap.end()) {
642 switch (iter_data->second) {
643 case edge_threshold:
644 d_edge_threshold = dataNode.text().as_double();
645 edge_threshold_node = true;
646 break;
647
648 case mu1:
649 d_mu1 = dataNode.text().as_double();
650 mu1_node = true;
651 break;
652
653 case mu2:
654 d_mu2 = dataNode.text().as_double();
655 mu2_node = true;
656 break;
657
658 default:
659 break;
660 }
661 }
662 }
663 }
664
665 m_ecm.setMu1(d_mu1);
666 m_ecm.setMu2(d_mu2);
667 m_ecm.setThreshold(d_edge_threshold);
668
669 if (m_verbose) {
670 if (!edge_threshold_node)
671 std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << " (default)" << std::endl;
672 else
673 std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << std::endl;
674
675 if (!mu1_node)
676 std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << " (default)" << std::endl;
677 else
678 std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << std::endl;
679
680 if (!mu2_node)
681 std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << " (default)" << std::endl;
682 else
683 std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << std::endl;
684 }
685 }
686
687 /*!
688 Read mask information for the vpMeSite.
689
690 \param node : Pointer to the node of the mask information.
691 */
read_ecm_mask(const pugi::xml_node & node)692 void read_ecm_mask(const pugi::xml_node &node)
693 {
694 bool size_node = false;
695 bool nb_mask_node = false;
696
697 // current data values.
698 unsigned int d_size = m_ecm.getMaskSize();
699 unsigned int d_nb_mask = m_ecm.getMaskNumber();
700
701 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
702 if (dataNode.type() == pugi::node_element) {
703 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
704 if (iter_data != m_nodeMap.end()) {
705 switch (iter_data->second) {
706 case size:
707 d_size = dataNode.text().as_uint();
708 size_node = true;
709 break;
710
711 case nb_mask:
712 d_nb_mask = dataNode.text().as_uint();
713 nb_mask_node = true;
714 break;
715
716 default:
717 break;
718 }
719 }
720 }
721 }
722
723 m_ecm.setMaskSize(d_size);
724
725 // Check to ensure that d_nb_mask > 0
726 if (d_nb_mask == 0)
727 throw(vpException(vpException::badValue, "Model-based tracker mask size "
728 "parameter should be different "
729 "from zero in xml file"));
730 m_ecm.setMaskNumber(d_nb_mask);
731
732 if (m_verbose) {
733 if (!size_node)
734 std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
735 else
736 std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << std::endl;
737
738 if (!nb_mask_node)
739 std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
740 else
741 std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << std::endl;
742 }
743 }
744
745 /*!
746 Read range information for the vpMeSite.
747
748 \param node : Pointer to the node of the range information.
749 */
read_ecm_range(const pugi::xml_node & node)750 void read_ecm_range(const pugi::xml_node &node)
751 {
752 bool tracking_node = false;
753
754 // current data values.
755 unsigned int m_range_tracking = m_ecm.getRange();
756
757 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
758 if (dataNode.type() == pugi::node_element) {
759 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
760 if (iter_data != m_nodeMap.end()) {
761 switch (iter_data->second) {
762 case tracking:
763 m_range_tracking = dataNode.text().as_uint();
764 tracking_node = true;
765 break;
766
767 default:
768 break;
769 }
770 }
771 }
772 }
773
774 m_ecm.setRange(m_range_tracking);
775
776 if (m_verbose) {
777 if (!tracking_node)
778 std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
779 else
780 std::cout << "ecm : range : tracking : " << m_ecm.getRange() << std::endl;
781 }
782 }
783
784 /*!
785 Read sample information.
786
787 \param node : Pointer to the node of the sample information.
788 */
read_ecm_sample(const pugi::xml_node & node)789 void read_ecm_sample(const pugi::xml_node &node)
790 {
791 bool step_node = false;
792
793 // current data values.
794 double d_stp = m_ecm.getSampleStep();
795
796 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
797 if (dataNode.type() == pugi::node_element) {
798 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
799 if (iter_data != m_nodeMap.end()) {
800 switch (iter_data->second) {
801 case step:
802 d_stp = dataNode.text().as_int();
803 step_node = true;
804 break;
805
806 default:
807 break;
808 }
809 }
810 }
811 }
812
813 m_ecm.setSampleStep(d_stp);
814
815 if (m_verbose) {
816 if (!step_node)
817 std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
818 else
819 std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << std::endl;
820 }
821 }
822
823 /*!
824 Read face information.
825
826 \param node : Pointer to the node of the camera information.
827 */
read_face(const pugi::xml_node & node)828 void read_face(const pugi::xml_node &node)
829 {
830 bool angle_appear_node = false;
831 bool angle_disappear_node = false;
832 bool near_clipping_node = false;
833 bool far_clipping_node = false;
834 bool fov_clipping_node = false;
835 m_hasNearClipping = false;
836 m_hasFarClipping = false;
837
838 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
839 if (dataNode.type() == pugi::node_element) {
840 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
841 if (iter_data != m_nodeMap.end()) {
842 switch (iter_data->second) {
843 case angle_appear:
844 m_angleAppear = dataNode.text().as_double();
845 angle_appear_node = true;
846 break;
847
848 case angle_disappear:
849 m_angleDisappear = dataNode.text().as_double();
850 angle_disappear_node = true;
851 break;
852
853 case near_clipping:
854 m_nearClipping = dataNode.text().as_double();
855 m_hasNearClipping = true;
856 near_clipping_node = true;
857 break;
858
859 case far_clipping:
860 m_farClipping = dataNode.text().as_double();
861 m_hasFarClipping = true;
862 far_clipping_node = true;
863 break;
864
865 case fov_clipping:
866 if (dataNode.text().as_int())
867 m_fovClipping = true;
868 else
869 m_fovClipping = false;
870 fov_clipping_node = true;
871 break;
872
873 default:
874 break;
875 }
876 }
877 }
878 }
879
880 if (m_verbose) {
881 if (!angle_appear_node)
882 std::cout << "face : Angle Appear : " << m_angleAppear << " (default)" << std::endl;
883 else
884 std::cout << "face : Angle Appear : " << m_angleAppear << std::endl;
885
886 if (!angle_disappear_node)
887 std::cout << "face : Angle Disappear : " << m_angleDisappear << " (default)" << std::endl;
888 else
889 std::cout << "face : Angle Disappear : " << m_angleDisappear << std::endl;
890
891 if (near_clipping_node)
892 std::cout << "face : Near Clipping : " << m_nearClipping << std::endl;
893
894 if (far_clipping_node)
895 std::cout << "face : Far Clipping : " << m_farClipping << std::endl;
896
897 if (fov_clipping_node) {
898 if (m_fovClipping)
899 std::cout << "face : Fov Clipping : True" << std::endl;
900 else
901 std::cout << "face : Fov Clipping : False" << std::endl;
902 }
903 }
904 }
905
906 /*!
907 Read klt information.
908
909 \param node : Pointer to the node of the camera information.
910 */
read_klt(const pugi::xml_node & node)911 void read_klt(const pugi::xml_node &node)
912 {
913 bool mask_border_node = false;
914 bool max_features_node = false;
915 bool window_size_node = false;
916 bool quality_node = false;
917 bool min_distance_node = false;
918 bool harris_node = false;
919 bool size_block_node = false;
920 bool pyramid_lvl_node = false;
921
922 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
923 if (dataNode.type() == pugi::node_element) {
924 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
925 if (iter_data != m_nodeMap.end()) {
926 switch (iter_data->second) {
927 case mask_border:
928 m_kltMaskBorder = dataNode.text().as_uint();
929 mask_border_node = true;
930 break;
931
932 case max_features:
933 m_kltMaxFeatures = dataNode.text().as_uint();
934 max_features_node = true;
935 break;
936
937 case window_size:
938 m_kltWinSize = dataNode.text().as_uint();
939 window_size_node = true;
940 break;
941
942 case quality:
943 m_kltQualityValue = dataNode.text().as_double();
944 quality_node = true;
945 break;
946
947 case min_distance:
948 m_kltMinDist = dataNode.text().as_double();
949 min_distance_node = true;
950 break;
951
952 case harris:
953 m_kltHarrisParam = dataNode.text().as_double();
954 harris_node = true;
955 break;
956
957 case size_block:
958 m_kltBlockSize = dataNode.text().as_uint();
959 size_block_node = true;
960 break;
961
962 case pyramid_lvl:
963 m_kltPyramidLevels = dataNode.text().as_uint();
964 pyramid_lvl_node = true;
965 break;
966
967 default:
968 break;
969 }
970 }
971 }
972 }
973
974 if (m_verbose) {
975 if (!mask_border_node)
976 std::cout << "klt : Mask Border : " << m_kltMaskBorder << " (default)" << std::endl;
977 else
978 std::cout << "klt : Mask Border : " << m_kltMaskBorder << std::endl;
979
980 if (!max_features_node)
981 std::cout << "klt : Max Features : " << m_kltMaxFeatures << " (default)" << std::endl;
982 else
983 std::cout << "klt : Max Features : " << m_kltMaxFeatures << std::endl;
984
985 if (!window_size_node)
986 std::cout << "klt : Windows Size : " << m_kltWinSize << " (default)" << std::endl;
987 else
988 std::cout << "klt : Windows Size : " << m_kltWinSize << std::endl;
989
990 if (!quality_node)
991 std::cout << "klt : Quality : " << m_kltQualityValue << " (default)" << std::endl;
992 else
993 std::cout << "klt : Quality : " << m_kltQualityValue << std::endl;
994
995 if (!min_distance_node)
996 std::cout << "klt : Min Distance : " << m_kltMinDist << " (default)" << std::endl;
997 else
998 std::cout << "klt : Min Distance : " << m_kltMinDist << std::endl;
999
1000 if (!harris_node)
1001 std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << " (default)" << std::endl;
1002 else
1003 std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << std::endl;
1004
1005 if (!size_block_node)
1006 std::cout << "klt : Block Size : " << m_kltBlockSize << " (default)" << std::endl;
1007 else
1008 std::cout << "klt : Block Size : " << m_kltBlockSize << std::endl;
1009
1010 if (!pyramid_lvl_node)
1011 std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << " (default)" << std::endl;
1012 else
1013 std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << std::endl;
1014 }
1015 }
1016
read_lod(const pugi::xml_node & node)1017 void read_lod(const pugi::xml_node &node)
1018 {
1019 bool use_lod_node = false;
1020 bool min_line_length_threshold_node = false;
1021 bool min_polygon_area_threshold_node = false;
1022
1023 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
1024 if (dataNode.type() == pugi::node_element) {
1025 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
1026 if (iter_data != m_nodeMap.end()) {
1027 switch (iter_data->second) {
1028 case use_lod:
1029 m_useLod = (dataNode.text().as_int() != 0);
1030 use_lod_node = true;
1031 break;
1032
1033 case min_line_length_threshold:
1034 m_minLineLengthThreshold = dataNode.text().as_double();
1035 min_line_length_threshold_node = true;
1036 break;
1037
1038 case min_polygon_area_threshold:
1039 m_minPolygonAreaThreshold = dataNode.text().as_double();
1040 min_polygon_area_threshold_node = true;
1041 break;
1042
1043 default:
1044 break;
1045 }
1046 }
1047 }
1048 }
1049
1050 if (m_verbose) {
1051 if (!use_lod_node)
1052 std::cout << "lod : use lod : " << m_useLod << " (default)" << std::endl;
1053 else
1054 std::cout << "lod : use lod : " << m_useLod << std::endl;
1055
1056 if (!min_line_length_threshold_node)
1057 std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << " (default)" << std::endl;
1058 else
1059 std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << std::endl;
1060
1061 if (!min_polygon_area_threshold_node)
1062 std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << " (default)" << std::endl;
1063 else
1064 std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << std::endl;
1065 }
1066 }
1067
read_projection_error(const pugi::xml_node & node)1068 void read_projection_error(const pugi::xml_node &node)
1069 {
1070 bool step_node = false;
1071 bool kernel_size_node = false;
1072
1073 // current data values.
1074 double d_stp = m_projectionErrorMe.getSampleStep();
1075 std::string kernel_size_str;
1076
1077 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
1078 if (dataNode.type() == pugi::node_element) {
1079 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
1080 if (iter_data != m_nodeMap.end()) {
1081 switch (iter_data->second) {
1082 case projection_error_sample_step:
1083 d_stp = dataNode.text().as_int();
1084 step_node = true;
1085 break;
1086
1087 case projection_error_kernel_size:
1088 kernel_size_str = dataNode.text().as_string();
1089 kernel_size_node = true;
1090 break;
1091
1092 default:
1093 break;
1094 }
1095 }
1096 }
1097 }
1098
1099 m_projectionErrorMe.setSampleStep(d_stp);
1100
1101 if (kernel_size_str == "3x3") {
1102 m_projectionErrorKernelSize = 1;
1103 } else if (kernel_size_str == "5x5") {
1104 m_projectionErrorKernelSize = 2;
1105 } else if (kernel_size_str == "7x7") {
1106 m_projectionErrorKernelSize = 3;
1107 } else if (kernel_size_str == "9x9") {
1108 m_projectionErrorKernelSize = 4;
1109 } else if (kernel_size_str == "11x11") {
1110 m_projectionErrorKernelSize = 5;
1111 } else if (kernel_size_str == "13x13") {
1112 m_projectionErrorKernelSize = 6;
1113 } else if (kernel_size_str == "15x15") {
1114 m_projectionErrorKernelSize = 7;
1115 } else {
1116 std::cerr << "Unsupported kernel size." << std::endl;
1117 }
1118
1119 if (m_verbose) {
1120 if (!step_node)
1121 std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << " (default)" << std::endl;
1122 else
1123 std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << std::endl;
1124
1125 if (!kernel_size_node)
1126 std::cout << "projection_error : kernel_size : " << m_projectionErrorKernelSize*2+1 << "x"
1127 << m_projectionErrorKernelSize*2+1 << " (default)" << std::endl;
1128 else
1129 std::cout << "projection_error : kernel_size : " << kernel_size_str << std::endl;
1130 }
1131 }
1132
1133 /*!
1134 Read sample information.
1135
1136 \param node : Pointer to the node of the sample information.
1137 */
read_sample_deprecated(const pugi::xml_node & node)1138 void read_sample_deprecated(const pugi::xml_node &node)
1139 {
1140 bool step_node = false;
1141 // bool nb_sample_node = false;
1142
1143 // current data values.
1144 double d_stp = m_ecm.getSampleStep();
1145
1146 for (pugi::xml_node dataNode = node.first_child(); dataNode; dataNode = dataNode.next_sibling()) {
1147 if (dataNode.type() == pugi::node_element) {
1148 std::map<std::string, int>::const_iterator iter_data = m_nodeMap.find(dataNode.name());
1149 if (iter_data != m_nodeMap.end()) {
1150 switch (iter_data->second) {
1151 case step:
1152 d_stp = dataNode.text().as_int();
1153 step_node = true;
1154 break;
1155
1156 default:
1157 break;
1158 }
1159 }
1160 }
1161 }
1162
1163 m_ecm.setSampleStep(d_stp);
1164
1165 if (m_verbose) {
1166 if (!step_node)
1167 std::cout << "[DEPRECATED] sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
1168 else
1169 std::cout << "[DEPRECATED] sample : sample_step : " << m_ecm.getSampleStep() << std::endl;
1170
1171 std::cout << " WARNING : This node (sample) is deprecated." << std::endl;
1172 std::cout << " It should be moved in the ecm node (ecm : sample)." << std::endl;
1173 }
1174 }
1175
getAngleAppear() const1176 double getAngleAppear() const { return m_angleAppear; }
getAngleDisappear() const1177 double getAngleDisappear() const { return m_angleDisappear; }
1178
getCameraParameters(vpCameraParameters & cam) const1179 void getCameraParameters(vpCameraParameters &cam) const { cam = m_cam; }
1180
getEdgeMe(vpMe & moving_edge) const1181 void getEdgeMe(vpMe &moving_edge) const { moving_edge = m_ecm; }
1182
getDepthDenseSamplingStepX() const1183 unsigned int getDepthDenseSamplingStepX() const { return m_depthDenseSamplingStepX; }
getDepthDenseSamplingStepY() const1184 unsigned int getDepthDenseSamplingStepY() const { return m_depthDenseSamplingStepY; }
1185
getDepthNormalFeatureEstimationMethod() const1186 vpMbtFaceDepthNormal::vpFeatureEstimationType getDepthNormalFeatureEstimationMethod() const
1187 {
1188 return m_depthNormalFeatureEstimationMethod;
1189 }
getDepthNormalPclPlaneEstimationMethod() const1190 int getDepthNormalPclPlaneEstimationMethod() const { return m_depthNormalPclPlaneEstimationMethod; }
getDepthNormalPclPlaneEstimationRansacMaxIter() const1191 int getDepthNormalPclPlaneEstimationRansacMaxIter() const
1192 {
1193 return m_depthNormalPclPlaneEstimationRansacMaxIter;
1194 }
getDepthNormalPclPlaneEstimationRansacThreshold() const1195 double getDepthNormalPclPlaneEstimationRansacThreshold() const
1196 {
1197 return m_depthNormalPclPlaneEstimationRansacThreshold;
1198 }
getDepthNormalSamplingStepX() const1199 unsigned int getDepthNormalSamplingStepX() const { return m_depthNormalSamplingStepX; }
getDepthNormalSamplingStepY() const1200 unsigned int getDepthNormalSamplingStepY() const { return m_depthNormalSamplingStepY; }
1201
getFarClippingDistance() const1202 double getFarClippingDistance() const { return m_farClipping; }
getFovClipping() const1203 bool getFovClipping() const { return m_fovClipping; }
1204
getKltBlockSize() const1205 unsigned int getKltBlockSize() const { return m_kltBlockSize; }
getKltHarrisParam() const1206 double getKltHarrisParam() const { return m_kltHarrisParam; }
getKltMaskBorder() const1207 unsigned int getKltMaskBorder() const { return m_kltMaskBorder; }
getKltMaxFeatures() const1208 unsigned int getKltMaxFeatures() const { return m_kltMaxFeatures; }
getKltMinDistance() const1209 double getKltMinDistance() const { return m_kltMinDist; }
getKltPyramidLevels() const1210 unsigned int getKltPyramidLevels() const { return m_kltPyramidLevels; }
getKltQuality() const1211 double getKltQuality() const { return m_kltQualityValue; }
getKltWindowSize() const1212 unsigned int getKltWindowSize() const { return m_kltWinSize; }
1213
getLodState() const1214 bool getLodState() const { return m_useLod; }
getLodMinLineLengthThreshold() const1215 double getLodMinLineLengthThreshold() const { return m_minLineLengthThreshold; }
getLodMinPolygonAreaThreshold() const1216 double getLodMinPolygonAreaThreshold() const { return m_minPolygonAreaThreshold; }
1217
getNearClippingDistance() const1218 double getNearClippingDistance() const { return m_nearClipping; }
1219
getProjectionErrorMe(vpMe & me) const1220 void getProjectionErrorMe(vpMe &me) const { me = m_projectionErrorMe; }
getProjectionErrorKernelSize() const1221 unsigned int getProjectionErrorKernelSize() const { return m_projectionErrorKernelSize; }
1222
hasFarClippingDistance() const1223 bool hasFarClippingDistance() const { return m_hasFarClipping; }
hasNearClippingDistance() const1224 bool hasNearClippingDistance() const { return m_hasNearClipping; }
1225
setAngleAppear(const double & aappear)1226 void setAngleAppear(const double &aappear) { m_angleAppear = aappear; }
setAngleDisappear(const double & adisappear)1227 void setAngleDisappear(const double &adisappear) { m_angleDisappear = adisappear; }
1228
setCameraParameters(const vpCameraParameters & cam)1229 void setCameraParameters(const vpCameraParameters &cam) { m_cam = cam; }
1230
setDepthDenseSamplingStepX(unsigned int stepX)1231 void setDepthDenseSamplingStepX(unsigned int stepX) { m_depthDenseSamplingStepX = stepX; }
setDepthDenseSamplingStepY(unsigned int stepY)1232 void setDepthDenseSamplingStepY(unsigned int stepY) { m_depthDenseSamplingStepY = stepY; }
setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType & method)1233 void setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method)
1234 {
1235 m_depthNormalFeatureEstimationMethod = method;
1236 }
setDepthNormalPclPlaneEstimationMethod(int method)1237 void setDepthNormalPclPlaneEstimationMethod(int method)
1238 {
1239 m_depthNormalPclPlaneEstimationMethod = method;
1240 }
setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)1241 void setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)
1242 {
1243 m_depthNormalPclPlaneEstimationRansacMaxIter = maxIter;
1244 }
setDepthNormalPclPlaneEstimationRansacThreshold(double threshold)1245 void setDepthNormalPclPlaneEstimationRansacThreshold(double threshold)
1246 {
1247 m_depthNormalPclPlaneEstimationRansacThreshold = threshold;
1248 }
setDepthNormalSamplingStepX(unsigned int stepX)1249 void setDepthNormalSamplingStepX(unsigned int stepX) { m_depthNormalSamplingStepX = stepX; }
setDepthNormalSamplingStepY(unsigned int stepY)1250 void setDepthNormalSamplingStepY(unsigned int stepY) { m_depthNormalSamplingStepY = stepY; }
1251
setEdgeMe(const vpMe & moving_edge)1252 void setEdgeMe(const vpMe &moving_edge) { m_ecm = moving_edge; }
1253
setFarClippingDistance(const double & fclip)1254 void setFarClippingDistance(const double &fclip) { m_farClipping = fclip; }
1255
setKltBlockSize(const unsigned int & bs)1256 void setKltBlockSize(const unsigned int &bs) { m_kltBlockSize = bs; }
setKltHarrisParam(const double & hp)1257 void setKltHarrisParam(const double &hp) { m_kltHarrisParam = hp; }
setKltMaskBorder(const unsigned int & mb)1258 void setKltMaskBorder(const unsigned int &mb) { m_kltMaskBorder = mb; }
setKltMaxFeatures(const unsigned int & mF)1259 void setKltMaxFeatures(const unsigned int &mF) { m_kltMaxFeatures = mF; }
setKltMinDistance(const double & mD)1260 void setKltMinDistance(const double &mD) { m_kltMinDist = mD; }
setKltPyramidLevels(const unsigned int & pL)1261 void setKltPyramidLevels(const unsigned int &pL) { m_kltPyramidLevels = pL; }
setKltQuality(const double & q)1262 void setKltQuality(const double &q) { m_kltQualityValue = q; }
setKltWindowSize(const unsigned int & w)1263 void setKltWindowSize(const unsigned int &w) { m_kltWinSize = w; }
1264
setNearClippingDistance(const double & nclip)1265 void setNearClippingDistance(const double &nclip) { m_nearClipping = nclip; }
1266
setProjectionErrorMe(const vpMe & me)1267 void setProjectionErrorMe(const vpMe &me) { m_projectionErrorMe = me; }
setProjectionErrorKernelSize(const unsigned int & kernel_size)1268 void setProjectionErrorKernelSize(const unsigned int &kernel_size) { m_projectionErrorKernelSize = kernel_size; }
1269
setVerbose(bool verbose)1270 void setVerbose(bool verbose) { m_verbose = verbose; }
1271
1272 protected:
1273 //! Parser type
1274 int m_parserType;
1275 //! Camera parameters.
1276 vpCameraParameters m_cam;
1277 //! Angle to determine if a face appeared
1278 double m_angleAppear;
1279 //! Angle to determine if a face disappeared
1280 double m_angleDisappear;
1281 //! Is near clipping distance specified?
1282 bool m_hasNearClipping;
1283 //! Near clipping distance
1284 double m_nearClipping;
1285 //! Is far clipping distance specified?
1286 bool m_hasFarClipping;
1287 //! Near clipping distance
1288 double m_farClipping;
1289 //! Fov Clipping
1290 bool m_fovClipping;
1291 // LOD
1292 //! If true, the LOD is enabled, otherwise it is not
1293 bool m_useLod;
1294 //! Minimum line length to track a segment when LOD is enabled
1295 double m_minLineLengthThreshold;
1296 //! Minimum polygon area to track a face when LOD is enabled
1297 double m_minPolygonAreaThreshold;
1298 // Edge
1299 //! Moving edges parameters.
1300 vpMe m_ecm;
1301 // KLT
1302 //! Border of the mask used on Klt points
1303 unsigned int m_kltMaskBorder;
1304 //! Maximum of Klt features
1305 unsigned int m_kltMaxFeatures;
1306 //! Windows size
1307 unsigned int m_kltWinSize;
1308 //! Quality of the Klt points
1309 double m_kltQualityValue;
1310 //! Minimum distance between klt points
1311 double m_kltMinDist;
1312 //! Harris free parameters
1313 double m_kltHarrisParam;
1314 //! Block size
1315 unsigned int m_kltBlockSize;
1316 //! Number of pyramid levels
1317 unsigned int m_kltPyramidLevels;
1318 // Depth normal
1319 //! Feature estimation method
1320 vpMbtFaceDepthNormal::vpFeatureEstimationType m_depthNormalFeatureEstimationMethod;
1321 //! PCL plane estimation method
1322 int m_depthNormalPclPlaneEstimationMethod;
1323 //! PCL RANSAC maximum number of iterations
1324 int m_depthNormalPclPlaneEstimationRansacMaxIter;
1325 //! PCL RANSAC threshold
1326 double m_depthNormalPclPlaneEstimationRansacThreshold;
1327 //! Sampling step in X
1328 unsigned int m_depthNormalSamplingStepX;
1329 //! Sampling step in Y
1330 unsigned int m_depthNormalSamplingStepY;
1331 // Depth dense
1332 //! Sampling step in X
1333 unsigned int m_depthDenseSamplingStepX;
1334 //! Sampling step in Y
1335 unsigned int m_depthDenseSamplingStepY;
1336 // Projection error
1337 //! ME parameters for projection error computation
1338 vpMe m_projectionErrorMe;
1339 //! Kernel size (actual_kernel_size = size*2 + 1) used for projection error computation
1340 unsigned int m_projectionErrorKernelSize;
1341 std::map<std::string, int> m_nodeMap;
1342 //! Verbose flag
1343 bool m_verbose;
1344
1345 enum vpDataToParseMb {
1346 //<conf>
1347 conf,
1348 //<face>
1349 face,
1350 angle_appear,
1351 angle_disappear,
1352 near_clipping,
1353 far_clipping,
1354 fov_clipping,
1355 //<camera>
1356 camera,
1357 height,
1358 width,
1359 u0,
1360 v0,
1361 px,
1362 py,
1363 lod,
1364 use_lod,
1365 min_line_length_threshold,
1366 min_polygon_area_threshold,
1367 //<ecm>
1368 ecm,
1369 mask,
1370 size,
1371 nb_mask,
1372 range,
1373 tracking,
1374 contrast,
1375 edge_threshold,
1376 mu1,
1377 mu2,
1378 sample,
1379 step,
1380 //<klt>
1381 klt,
1382 mask_border,
1383 max_features,
1384 window_size,
1385 quality,
1386 min_distance,
1387 harris,
1388 size_block,
1389 pyramid_lvl,
1390 //<depth_normal>
1391 depth_normal,
1392 feature_estimation_method,
1393 PCL_plane_estimation,
1394 PCL_plane_estimation_method,
1395 PCL_plane_estimation_ransac_max_iter,
1396 PCL_plane_estimation_ransac_threshold,
1397 depth_sampling_step,
1398 depth_sampling_step_X,
1399 depth_sampling_step_Y,
1400 //<depth_dense>
1401 depth_dense,
1402 depth_dense_sampling_step,
1403 depth_dense_sampling_step_X,
1404 depth_dense_sampling_step_Y,
1405 //<projection_error>
1406 projection_error,
1407 projection_error_sample_step,
1408 projection_error_kernel_size
1409 };
1410
1411 /*!
1412 Initialise internal variables (including the map).
1413 */
init()1414 void init()
1415 {
1416 //<conf>
1417 m_nodeMap["conf"] = conf;
1418 //<face>
1419 m_nodeMap["face"] = face;
1420 m_nodeMap["angle_appear"] = angle_appear;
1421 m_nodeMap["angle_disappear"] = angle_disappear;
1422 m_nodeMap["near_clipping"] = near_clipping;
1423 m_nodeMap["far_clipping"] = far_clipping;
1424 m_nodeMap["fov_clipping"] = fov_clipping;
1425 //<camera>
1426 m_nodeMap["camera"] = camera;
1427 m_nodeMap["height"] = height;
1428 m_nodeMap["width"] = width;
1429 m_nodeMap["u0"] = u0;
1430 m_nodeMap["v0"] = v0;
1431 m_nodeMap["px"] = px;
1432 m_nodeMap["py"] = py;
1433 //<lod>
1434 m_nodeMap["lod"] = lod;
1435 m_nodeMap["use_lod"] = use_lod;
1436 m_nodeMap["min_line_length_threshold"] = min_line_length_threshold;
1437 m_nodeMap["min_polygon_area_threshold"] = min_polygon_area_threshold;
1438 //<ecm>
1439 m_nodeMap["ecm"] = ecm;
1440 m_nodeMap["mask"] = mask;
1441 m_nodeMap["size"] = size;
1442 m_nodeMap["nb_mask"] = nb_mask;
1443 m_nodeMap["range"] = range;
1444 m_nodeMap["tracking"] = tracking;
1445 m_nodeMap["contrast"] = contrast;
1446 m_nodeMap["edge_threshold"] = edge_threshold;
1447 m_nodeMap["mu1"] = mu1;
1448 m_nodeMap["mu2"] = mu2;
1449 m_nodeMap["sample"] = sample;
1450 m_nodeMap["step"] = step;
1451 //<klt>
1452 m_nodeMap["klt"] = klt;
1453 m_nodeMap["mask_border"] = mask_border;
1454 m_nodeMap["max_features"] = max_features;
1455 m_nodeMap["window_size"] = window_size;
1456 m_nodeMap["quality"] = quality;
1457 m_nodeMap["min_distance"] = min_distance;
1458 m_nodeMap["harris"] = harris;
1459 m_nodeMap["size_block"] = size_block;
1460 m_nodeMap["pyramid_lvl"] = pyramid_lvl;
1461 //<depth_normal>
1462 m_nodeMap["depth_normal"] = depth_normal;
1463 m_nodeMap["feature_estimation_method"] = feature_estimation_method;
1464 m_nodeMap["PCL_plane_estimation"] = PCL_plane_estimation;
1465 m_nodeMap["method"] = PCL_plane_estimation_method;
1466 m_nodeMap["ransac_max_iter"] = PCL_plane_estimation_ransac_max_iter;
1467 m_nodeMap["ransac_threshold"] = PCL_plane_estimation_ransac_threshold;
1468 m_nodeMap["sampling_step"] = depth_sampling_step;
1469 m_nodeMap["step_X"] = depth_sampling_step_X;
1470 m_nodeMap["step_Y"] = depth_sampling_step_Y;
1471 //<depth_dense>
1472 m_nodeMap["depth_dense"] = depth_dense;
1473 m_nodeMap["sampling_step"] = depth_dense_sampling_step;
1474 m_nodeMap["step_X"] = depth_dense_sampling_step_X;
1475 m_nodeMap["step_Y"] = depth_dense_sampling_step_Y;
1476 //<projection_error>
1477 m_nodeMap["projection_error"] = projection_error;
1478 m_nodeMap["sample_step"] = projection_error_sample_step;
1479 m_nodeMap["kernel_size"] = projection_error_kernel_size;
1480 }
1481 };
1482 #endif // DOXYGEN_SHOULD_SKIP_THIS
1483
vpMbtXmlGenericParser(int type)1484 vpMbtXmlGenericParser::vpMbtXmlGenericParser(int type) : m_impl(new Impl(type))
1485 {
1486 //https://pugixml.org/docs/manual.html#access.attrdata
1487 //https://en.cppreference.com/w/cpp/locale/setlocale
1488 //When called from Java binding, the locale seems to be changed to the default system locale
1489 //It thus mess with the parsing of numbers with pugixml and comma decimal separator environment
1490 if (std::setlocale(LC_ALL, "C") == NULL) {
1491 std::cerr << "Cannot set locale to C" << std::endl;
1492 }
1493 }
1494
~vpMbtXmlGenericParser()1495 vpMbtXmlGenericParser::~vpMbtXmlGenericParser()
1496 {
1497 delete m_impl;
1498 }
1499
1500 /*!
1501 Parse an XML config file that contains parameters for the Generic Model-Based Tracker.
1502
1503 \param filename : Document to parse.
1504 */
parse(const std::string & filename)1505 void vpMbtXmlGenericParser::parse(const std::string &filename)
1506 {
1507 m_impl->parse(filename);
1508 }
1509
1510 /*!
1511 Get the angle to determine if a face appeared.
1512 */
getAngleAppear() const1513 double vpMbtXmlGenericParser::getAngleAppear() const
1514 {
1515 return m_impl->getAngleAppear();
1516 }
1517
1518 /*!
1519 Get the angle to determine if a face disappeared.
1520 */
getAngleDisappear() const1521 double vpMbtXmlGenericParser::getAngleDisappear() const
1522 {
1523 return m_impl->getAngleDisappear();
1524 }
1525
getCameraParameters(vpCameraParameters & cam) const1526 void vpMbtXmlGenericParser::getCameraParameters(vpCameraParameters &cam) const
1527 {
1528 m_impl->getCameraParameters(cam);
1529 }
1530
1531 /*!
1532 Get moving edge parameters.
1533 */
getEdgeMe(vpMe & ecm) const1534 void vpMbtXmlGenericParser::getEdgeMe(vpMe &ecm) const
1535 {
1536 m_impl->getEdgeMe(ecm);
1537 }
1538
1539 /*!
1540 Get depth dense sampling step in X.
1541 */
getDepthDenseSamplingStepX() const1542 unsigned int vpMbtXmlGenericParser::getDepthDenseSamplingStepX() const
1543 {
1544 return m_impl->getDepthDenseSamplingStepX();
1545 }
1546
1547 /*!
1548 Get depth dense sampling step in Y.
1549 */
getDepthDenseSamplingStepY() const1550 unsigned int vpMbtXmlGenericParser::getDepthDenseSamplingStepY() const
1551 {
1552 return m_impl->getDepthDenseSamplingStepY();
1553 }
1554
1555 /*!
1556 Get depth normal feature estimation method.
1557 */
getDepthNormalFeatureEstimationMethod() const1558 vpMbtFaceDepthNormal::vpFeatureEstimationType vpMbtXmlGenericParser::getDepthNormalFeatureEstimationMethod() const
1559 {
1560 return m_impl->getDepthNormalFeatureEstimationMethod();
1561 }
1562
1563 /*!
1564 Get depth normal PCL plane estimation method.
1565 */
getDepthNormalPclPlaneEstimationMethod() const1566 int vpMbtXmlGenericParser::getDepthNormalPclPlaneEstimationMethod() const
1567 {
1568 return m_impl->getDepthNormalPclPlaneEstimationMethod();
1569 }
1570
1571 /*!
1572 Get depth normal PCL maximum number of iterations.
1573 */
getDepthNormalPclPlaneEstimationRansacMaxIter() const1574 int vpMbtXmlGenericParser::getDepthNormalPclPlaneEstimationRansacMaxIter() const
1575 {
1576 return m_impl->getDepthNormalPclPlaneEstimationRansacMaxIter();
1577 }
1578
1579 /*!
1580 Get depth normal PCL RANSAC threshold.
1581 */
getDepthNormalPclPlaneEstimationRansacThreshold() const1582 double vpMbtXmlGenericParser::getDepthNormalPclPlaneEstimationRansacThreshold() const
1583 {
1584 return m_impl->getDepthNormalPclPlaneEstimationRansacThreshold();
1585 }
1586
1587 /*!
1588 Get depth normal sampling step in X.
1589 */
getDepthNormalSamplingStepX() const1590 unsigned int vpMbtXmlGenericParser::getDepthNormalSamplingStepX() const
1591 {
1592 return m_impl->getDepthNormalSamplingStepX();
1593 }
1594
1595 /*!
1596 Get depth normal sampling step in Y.
1597 */
getDepthNormalSamplingStepY() const1598 unsigned int vpMbtXmlGenericParser::getDepthNormalSamplingStepY() const
1599 {
1600 return m_impl->getDepthNormalSamplingStepY();
1601 }
1602
1603 /*!
1604 Get the far clipping distance.
1605 */
getFarClippingDistance() const1606 double vpMbtXmlGenericParser::getFarClippingDistance() const
1607 {
1608 return m_impl->getFarClippingDistance();
1609 }
1610
1611 /*!
1612 Get if FOV clipping should be used or not.
1613 */
getFovClipping() const1614 bool vpMbtXmlGenericParser::getFovClipping() const
1615 {
1616 return m_impl->getFovClipping();
1617 }
1618
1619 /*!
1620 Get the size of a block.
1621 */
getKltBlockSize() const1622 unsigned int vpMbtXmlGenericParser::getKltBlockSize() const
1623 {
1624 return m_impl->getKltBlockSize();
1625 }
1626
1627 /*!
1628 Get the Harris free parameter.
1629 */
getKltHarrisParam() const1630 double vpMbtXmlGenericParser::getKltHarrisParam() const
1631 {
1632 return m_impl->getKltHarrisParam();
1633 }
1634
1635 /*!
1636 Get the Border of the mask.
1637 */
getKltMaskBorder() const1638 unsigned int vpMbtXmlGenericParser::getKltMaskBorder() const
1639 {
1640 return m_impl->getKltMaskBorder();
1641 }
1642
1643 /*!
1644 Get the maximum number of features for the KLT.
1645 */
getKltMaxFeatures() const1646 unsigned int vpMbtXmlGenericParser::getKltMaxFeatures() const
1647 {
1648 return m_impl->getKltMaxFeatures();
1649 }
1650
1651 /*!
1652 Get the minimum distance between KLT points.
1653 */
getKltMinDistance() const1654 double vpMbtXmlGenericParser::getKltMinDistance() const
1655 {
1656 return m_impl->getKltMinDistance();
1657 }
1658
1659 /*!
1660 Get the number of pyramid levels
1661 */
getKltPyramidLevels() const1662 unsigned int vpMbtXmlGenericParser::getKltPyramidLevels() const
1663 {
1664 return m_impl->getKltPyramidLevels();
1665 }
1666
1667 /*!
1668 Get the quality of the KLT.
1669 */
getKltQuality() const1670 double vpMbtXmlGenericParser::getKltQuality() const
1671 {
1672 return m_impl->getKltQuality();
1673 }
1674
1675 /*!
1676 Get the size of the window used in the KLT tracker.
1677 */
getKltWindowSize() const1678 unsigned int vpMbtXmlGenericParser::getKltWindowSize() const
1679 {
1680 return m_impl->getKltWindowSize();
1681 }
1682
1683 /*!
1684 Get the state of LOD setting.
1685 */
getLodState() const1686 bool vpMbtXmlGenericParser::getLodState() const
1687 {
1688 return m_impl->getLodState();
1689 }
1690
1691 /*!
1692 Get the minimum line length to track a segment when LOD is enabled.
1693 */
getLodMinLineLengthThreshold() const1694 double vpMbtXmlGenericParser::getLodMinLineLengthThreshold() const
1695 {
1696 return m_impl->getLodMinLineLengthThreshold();
1697 }
1698
1699 /*!
1700 Get the minimum polygon area to track a face when LOD is enabled.
1701 */
getLodMinPolygonAreaThreshold() const1702 double vpMbtXmlGenericParser::getLodMinPolygonAreaThreshold() const
1703 {
1704 return m_impl->getLodMinPolygonAreaThreshold();
1705 }
1706
1707 /*!
1708 Get the near clipping distance.
1709 */
getNearClippingDistance() const1710 double vpMbtXmlGenericParser::getNearClippingDistance() const
1711 {
1712 return m_impl->getNearClippingDistance();
1713 }
1714
1715 /*!
1716 Get ME parameters for projection error computation.
1717 */
getProjectionErrorMe(vpMe & me) const1718 void vpMbtXmlGenericParser::getProjectionErrorMe(vpMe &me) const
1719 {
1720 m_impl->getProjectionErrorMe(me);
1721 }
1722
getProjectionErrorKernelSize() const1723 unsigned int vpMbtXmlGenericParser::getProjectionErrorKernelSize() const
1724 {
1725 return m_impl->getProjectionErrorKernelSize();
1726 }
1727
1728 /*!
1729 Has Far clipping been specified?
1730
1731 \return True if yes, False otherwise.
1732 */
hasFarClippingDistance() const1733 bool vpMbtXmlGenericParser::hasFarClippingDistance() const
1734 {
1735 return m_impl->hasFarClippingDistance();
1736 }
1737
1738 /*!
1739 Has Near clipping been specified?
1740
1741 \return True if yes, False otherwise.
1742 */
hasNearClippingDistance() const1743 bool vpMbtXmlGenericParser::hasNearClippingDistance() const
1744 {
1745 return m_impl->hasNearClippingDistance();
1746 }
1747
1748 /*!
1749 Set the angle to determine if a face appeared.
1750
1751 \param aappear : New angleAppear
1752 */
setAngleAppear(const double & aappear)1753 void vpMbtXmlGenericParser::setAngleAppear(const double &aappear)
1754 {
1755 m_impl->setAngleAppear(aappear);
1756 }
1757
1758 /*!
1759 Set the angle to determine if a face disappeared.
1760
1761 \param adisappear : New angleDisappear
1762 */
setAngleDisappear(const double & adisappear)1763 void vpMbtXmlGenericParser::setAngleDisappear(const double &adisappear)
1764 {
1765 m_impl->setAngleDisappear(adisappear);
1766 }
1767
1768 /*!
1769 Set camera parameters.
1770
1771 \param cam : New camera parameters
1772 */
setCameraParameters(const vpCameraParameters & cam)1773 void vpMbtXmlGenericParser::setCameraParameters(const vpCameraParameters &cam)
1774 {
1775 m_impl->setCameraParameters(cam);
1776 }
1777
1778 /*!
1779 Set depth dense sampling step in X.
1780
1781 \param stepX : New sampling step
1782 */
setDepthDenseSamplingStepX(unsigned int stepX)1783 void vpMbtXmlGenericParser::setDepthDenseSamplingStepX(unsigned int stepX)
1784 {
1785 m_impl->setDepthDenseSamplingStepX(stepX);
1786 }
1787
1788 /*!
1789 Set depth dense sampling step in Y.
1790
1791 \param stepY : New sampling step
1792 */
setDepthDenseSamplingStepY(unsigned int stepY)1793 void vpMbtXmlGenericParser::setDepthDenseSamplingStepY(unsigned int stepY)
1794 {
1795 m_impl->setDepthDenseSamplingStepY(stepY);
1796 }
1797
1798 /*!
1799 Set depth normal feature estimation method.
1800
1801 \param method : New feature estimation method
1802 */
setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType & method)1803 void vpMbtXmlGenericParser::setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method)
1804 {
1805 m_impl->setDepthNormalFeatureEstimationMethod(method);
1806 }
1807
1808 /*!
1809 Set depth normal PCL plane estimation method.
1810
1811 \param method : New PCL plane estimation method
1812 */
setDepthNormalPclPlaneEstimationMethod(int method)1813 void vpMbtXmlGenericParser::setDepthNormalPclPlaneEstimationMethod(int method)
1814 {
1815 m_impl->setDepthNormalPclPlaneEstimationMethod(method);
1816 }
1817
1818 /*!
1819 Set depth normal PCL RANSAC maximum number of iterations.
1820
1821 \param maxIter : New maximum number of iterations
1822 */
setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)1823 void vpMbtXmlGenericParser::setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)
1824 {
1825 m_impl->setDepthNormalPclPlaneEstimationRansacMaxIter(maxIter);
1826 }
1827
1828 /*!
1829 Set depth normal PCL RANSAC threshold.
1830
1831 \param threshold : New RANSAC threshold
1832 */
setDepthNormalPclPlaneEstimationRansacThreshold(double threshold)1833 void vpMbtXmlGenericParser::setDepthNormalPclPlaneEstimationRansacThreshold(double threshold)
1834 {
1835 m_impl->setDepthNormalPclPlaneEstimationRansacThreshold(threshold);
1836 }
1837
1838 /*!
1839 Set depth normal sampling step in X.
1840
1841 \param stepX : New sampling step
1842 */
setDepthNormalSamplingStepX(unsigned int stepX)1843 void vpMbtXmlGenericParser::setDepthNormalSamplingStepX(unsigned int stepX)
1844 {
1845 m_impl->setDepthNormalSamplingStepX(stepX);
1846 }
1847
1848 /*!
1849 Set depth normal sampling step in Y.
1850
1851 \param stepY : New sampling step
1852 */
setDepthNormalSamplingStepY(unsigned int stepY)1853 void vpMbtXmlGenericParser::setDepthNormalSamplingStepY(unsigned int stepY)
1854 {
1855 m_impl->setDepthNormalSamplingStepY(stepY);
1856 }
1857
1858 /*!
1859 Set moving edge parameters.
1860
1861 \param ecm : New moving edge parameters
1862 */
setEdgeMe(const vpMe & ecm)1863 void vpMbtXmlGenericParser::setEdgeMe(const vpMe &ecm)
1864 {
1865 m_impl->setEdgeMe(ecm);
1866 }
1867
1868 /*!
1869 Set the far clipping distance.
1870
1871 \param fclip : New farClipping
1872 */
setFarClippingDistance(const double & fclip)1873 void vpMbtXmlGenericParser::setFarClippingDistance(const double &fclip)
1874 {
1875 m_impl->setFarClippingDistance(fclip);
1876 }
1877
1878 /*!
1879 Set the size of a block.
1880
1881 \param bs : New blockSize
1882 */
setKltBlockSize(const unsigned int & bs)1883 void vpMbtXmlGenericParser::setKltBlockSize(const unsigned int &bs)
1884 {
1885 m_impl->setKltBlockSize(bs);
1886 }
1887
1888 /*!
1889 Set the Harris free parameter.
1890
1891 \param hp : New harrisParam
1892 */
setKltHarrisParam(const double & hp)1893 void vpMbtXmlGenericParser::setKltHarrisParam(const double &hp)
1894 {
1895 m_impl->setKltHarrisParam(hp);
1896 }
1897
1898 /*!
1899 Set the Border of the mask.
1900
1901 \param mb = new maskBorder
1902 */
setKltMaskBorder(const unsigned int & mb)1903 void vpMbtXmlGenericParser::setKltMaskBorder(const unsigned int &mb)
1904 {
1905 m_impl->setKltMaskBorder(mb);
1906 }
1907
1908 /*!
1909 Set the maximum number of features for the KLT.
1910
1911 \param mF : New maxFeatures
1912 */
setKltMaxFeatures(const unsigned int & mF)1913 void vpMbtXmlGenericParser::setKltMaxFeatures(const unsigned int &mF)
1914 {
1915 m_impl->setKltMaxFeatures(mF);
1916 }
1917
1918 /*!
1919 Set the minimum distance between KLT points.
1920
1921 \param mD : New minDist
1922 */
setKltMinDistance(const double & mD)1923 void vpMbtXmlGenericParser::setKltMinDistance(const double &mD)
1924 {
1925 m_impl->setKltMinDistance(mD);
1926 }
1927
1928 /*!
1929 Set the number of pyramid levels
1930
1931 \param pL : New pyramidLevels
1932 */
setKltPyramidLevels(const unsigned int & pL)1933 void vpMbtXmlGenericParser::setKltPyramidLevels(const unsigned int &pL)
1934 {
1935 m_impl->setKltPyramidLevels(pL);
1936 }
1937
1938 /*!
1939 Set the quality of the KLT.
1940
1941 \param q : New quality
1942 */
setKltQuality(const double & q)1943 void vpMbtXmlGenericParser::setKltQuality(const double &q)
1944 {
1945 m_impl->setKltQuality(q);
1946 }
1947
1948 /*!
1949 Set the size of the window used in the KLT tracker.
1950
1951 \param w : New winSize
1952 */
setKltWindowSize(const unsigned int & w)1953 void vpMbtXmlGenericParser::setKltWindowSize(const unsigned int &w)
1954 {
1955 m_impl->setKltWindowSize(w);
1956 }
1957
1958 /*!
1959 Set the near clipping distance.
1960
1961 \param nclip : New nearClipping
1962 */
setNearClippingDistance(const double & nclip)1963 void vpMbtXmlGenericParser::setNearClippingDistance(const double &nclip)
1964 {
1965 m_impl->setNearClippingDistance(nclip);
1966 }
1967
1968 /*!
1969 Set ME parameters for projection error computation.
1970
1971 \param me : ME parameters
1972 */
setProjectionErrorMe(const vpMe & me)1973 void vpMbtXmlGenericParser::setProjectionErrorMe(const vpMe &me)
1974 {
1975 m_impl->setProjectionErrorMe(me);
1976 }
1977
1978 /*!
1979 Set kernel size used for projection error computation.
1980
1981 \param size : Kernel size computed as kernel_size = size*2 + 1
1982 */
setProjectionErrorKernelSize(const unsigned int & size)1983 void vpMbtXmlGenericParser::setProjectionErrorKernelSize(const unsigned int &size)
1984 {
1985 m_impl->setProjectionErrorKernelSize(size);
1986 }
1987
1988 /*!
1989 Set verbose mode (print tracker configuration in the standard output if set).
1990
1991 \param verbose : verbose flag
1992 */
setVerbose(bool verbose)1993 void vpMbtXmlGenericParser::setVerbose(bool verbose)
1994 {
1995 m_impl->setVerbose(verbose);
1996 }
1997