Visual Servoing Platform  version 3.2.0 under development (2019-01-22)
vpMbtXmlGenericParser.cpp
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 #ifdef VISP_HAVE_XML2
38 
39 #include <iostream>
40 #include <map>
41 
42 #include <libxml/xmlmemory.h>
43 
44 #include <visp3/mbt/vpMbtXmlGenericParser.h>
45 
47  : m_parserType(type),
48  //<camera>
49  m_cam(),
50  //<face>
51  m_angleAppear(70), m_angleDisappear(80), m_hasNearClipping(false), m_nearClipping(false), m_hasFarClipping(false),
52  m_farClipping(false), m_fovClipping(false),
53  //<lod>
54  m_useLod(false), m_minLineLengthThreshold(50.0), m_minPolygonAreaThreshold(2500.0),
55  //<ecm>
56  m_ecm(),
57  //<klt>
58  m_kltMaskBorder(0), m_kltMaxFeatures(0), m_kltWinSize(0), m_kltQualityValue(0.), m_kltMinDist(0.),
59  m_kltHarrisParam(0.), m_kltBlockSize(0), m_kltPyramidLevels(0),
60  //<depth_normal>
61  m_depthNormalFeatureEstimationMethod(vpMbtFaceDepthNormal::ROBUST_FEATURE_ESTIMATION),
62  m_depthNormalPclPlaneEstimationMethod(2), m_depthNormalPclPlaneEstimationRansacMaxIter(200),
63  m_depthNormalPclPlaneEstimationRansacThreshold(0.001), m_depthNormalSamplingStepX(2), m_depthNormalSamplingStepY(2),
64  //<depth_dense>
65  m_depthDenseSamplingStepX(2), m_depthDenseSamplingStepY(2),
66  //<projection_error>
67  m_projectionErrorMe(), m_projectionErrorKernelSize(2) //5x5
68 {
69  init();
70 }
71 
73 
78 {
79  setMainTag("conf");
80 
81  //<conf>
82  nodeMap["conf"] = conf;
83  //<face>
84  nodeMap["face"] = face;
85  nodeMap["angle_appear"] = angle_appear;
86  nodeMap["angle_disappear"] = angle_disappear;
87  nodeMap["near_clipping"] = near_clipping;
88  nodeMap["far_clipping"] = far_clipping;
89  nodeMap["fov_clipping"] = fov_clipping;
90  //<camera>
91  nodeMap["camera"] = camera;
92  nodeMap["height"] = height;
93  nodeMap["width"] = width;
94  nodeMap["u0"] = u0;
95  nodeMap["v0"] = v0;
96  nodeMap["px"] = px;
97  nodeMap["py"] = py;
98  //<lod>
99  nodeMap["lod"] = lod;
100  nodeMap["use_lod"] = use_lod;
101  nodeMap["min_line_length_threshold"] = min_line_length_threshold;
102  nodeMap["min_polygon_area_threshold"] = min_polygon_area_threshold;
103  //<ecm>
104  nodeMap["ecm"] = ecm;
105  nodeMap["mask"] = mask;
106  nodeMap["size"] = size;
107  nodeMap["nb_mask"] = nb_mask;
108  nodeMap["range"] = range;
109  nodeMap["tracking"] = tracking;
110  nodeMap["contrast"] = contrast;
111  nodeMap["edge_threshold"] = edge_threshold;
112  nodeMap["mu1"] = mu1;
113  nodeMap["mu2"] = mu2;
114  nodeMap["sample"] = sample;
115  nodeMap["step"] = step;
116  //<klt>
117  nodeMap["klt"] = klt;
118  nodeMap["mask_border"] = mask_border;
119  nodeMap["max_features"] = max_features;
120  nodeMap["window_size"] = window_size;
121  nodeMap["quality"] = quality;
122  nodeMap["min_distance"] = min_distance;
123  nodeMap["harris"] = harris;
124  nodeMap["size_block"] = size_block;
125  nodeMap["pyramid_lvl"] = pyramid_lvl;
126  //<depth_normal>
127  nodeMap["depth_normal"] = depth_normal;
128  nodeMap["feature_estimation_method"] = feature_estimation_method;
129  nodeMap["PCL_plane_estimation"] = PCL_plane_estimation;
131  nodeMap["ransac_max_iter"] = PCL_plane_estimation_ransac_max_iter;
132  nodeMap["ransac_threshold"] = PCL_plane_estimation_ransac_threshold;
133  nodeMap["sampling_step"] = depth_sampling_step;
134  nodeMap["step_X"] = depth_sampling_step_X;
135  nodeMap["step_Y"] = depth_sampling_step_Y;
136  //<depth_dense>
137  nodeMap["depth_dense"] = depth_dense;
138  nodeMap["sampling_step"] = depth_dense_sampling_step;
141  //<projection_error>
142  nodeMap["projection_error"] = projection_error;
143  nodeMap["sample_step"] = projection_error_sample_step;
144  nodeMap["kernel_size"] = projection_error_kernel_size;
145 }
146 
152 void vpMbtXmlGenericParser::writeMainClass(xmlNodePtr /*node*/)
153 {
154  throw vpException(vpException::notImplementedError, "Not implemented.");
155 }
156 
164 void vpMbtXmlGenericParser::readMainClass(xmlDocPtr doc, xmlNodePtr node)
165 {
166  bool camera_node = false;
167  bool face_node = false;
168  bool ecm_node = false;
169  bool klt_node = false;
170  bool lod_node = false;
171  bool depth_normal_node = false;
172  bool depth_dense_node = false;
173  bool projection_error_node = false;
174 
175  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
176  if (dataNode->type == XML_ELEMENT_NODE) {
177  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
178  if (iter_data != nodeMap.end()) {
179  switch (iter_data->second) {
180  case camera:
182  read_camera(doc, dataNode);
183  camera_node = true;
184  }
185  break;
186 
187  case face:
189  read_face(doc, dataNode);
190  face_node = true;
191  }
192  break;
193 
194  case lod:
196  read_lod(doc, dataNode);
197  lod_node = true;
198  }
199  break;
200 
201  case ecm:
202  if (m_parserType & EDGE_PARSER) {
203  read_ecm(doc, dataNode);
204  ecm_node = true;
205  }
206  break;
207 
208  case sample:
209  if (m_parserType & EDGE_PARSER)
210  read_sample_deprecated(doc, dataNode);
211  break;
212 
213  case klt:
214  if (m_parserType & KLT_PARSER) {
215  read_klt(doc, dataNode);
216  klt_node = true;
217  }
218  break;
219 
220  case depth_normal:
222  read_depth_normal(doc, dataNode);
223  depth_normal_node = true;
224  }
225  break;
226 
227  case depth_dense:
229  read_depth_dense(doc, dataNode);
230  depth_dense_node = true;
231  }
232  break;
233 
234  case projection_error:
236  read_projection_error(doc, dataNode);
237  projection_error_node = true;
238  }
239  break;
240 
241  default:
242  break;
243  }
244  }
245  }
246  }
247 
249  if (!projection_error_node) {
250  std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << " (default)" << std::endl;
251  std::cout << "projection_error : kernel_size : " << m_projectionErrorKernelSize*2+1 << "x"
252  << m_projectionErrorKernelSize*2+1 << " (default)" << std::endl;
253  }
254  } else {
255  if (!camera_node) {
256  std::cout << "camera : u0 : " << m_cam.get_u0() << " (default)" << std::endl;
257  std::cout << "camera : v0 : " << m_cam.get_v0() << " (default)" << std::endl;
258  std::cout << "camera : px : " << m_cam.get_px() << " (default)" << std::endl;
259  std::cout << "camera : py : " << m_cam.get_py() << " (default)" << std::endl;
260  }
261 
262  if (!face_node) {
263  std::cout << "face : Angle Appear : " << m_angleAppear << " (default)" << std::endl;
264  std::cout << "face : Angle Disappear : " << m_angleDisappear << " (default)" << std::endl;
265  }
266 
267  if (!lod_node) {
268  std::cout << "lod : use lod : " << m_useLod << " (default)" << std::endl;
269  std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << " (default)" << std::endl;
270  std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << " (default)" << std::endl;
271  }
272 
273  if (!ecm_node && (m_parserType & EDGE_PARSER)) {
274  std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
275  std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
276  std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
277  std::cout << "ecm : contrast : threshold : " << m_ecm.getThreshold() << " (default)" << std::endl;
278  std::cout << "ecm : contrast : mu1 : " << m_ecm.getMu1() << " (default)" << std::endl;
279  std::cout << "ecm : contrast : mu2 : " << m_ecm.getMu2() << " (default)" << std::endl;
280  std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
281  }
282 
283  if (!klt_node && (m_parserType & KLT_PARSER)) {
284  std::cout << "klt : Mask Border : " << m_kltMaskBorder << " (default)" << std::endl;
285  std::cout << "klt : Max Features : " << m_kltMaxFeatures << " (default)" << std::endl;
286  std::cout << "klt : Windows Size : " << m_kltWinSize << " (default)" << std::endl;
287  std::cout << "klt : Quality : " << m_kltQualityValue << " (default)" << std::endl;
288  std::cout << "klt : Min Distance : " << m_kltMinDist << " (default)" << std::endl;
289  std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << " (default)" << std::endl;
290  std::cout << "klt : Block Size : " << m_kltBlockSize << " (default)" << std::endl;
291  std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << " (default)" << std::endl;
292  }
293 
294  if (!depth_normal_node && (m_parserType & DEPTH_NORMAL_PARSER)) {
295  std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << " (default)"
296  << std::endl;
297  std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
298  << " (default)" << std::endl;
299  std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
300  << " (default)" << std::endl;
301  std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
302  << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
303  std::cout << "depth normal : sampling_step : step_X " << m_depthNormalSamplingStepX << " (default)" << std::endl;
304  std::cout << "depth normal : sampling_step : step_Y " << m_depthNormalSamplingStepY << " (default)" << std::endl;
305  }
306 
307  if (!depth_dense_node && (m_parserType & DEPTH_DENSE_PARSER)) {
308  std::cout << "depth dense : sampling_step : step_X " << m_depthDenseSamplingStepX << " (default)" << std::endl;
309  std::cout << "depth dense : sampling_step : step_Y " << m_depthDenseSamplingStepY << " (default)" << std::endl;
310  }
311  }
312 }
313 
322 void vpMbtXmlGenericParser::read_camera(xmlDocPtr doc, xmlNodePtr node)
323 {
324  bool u0_node = false;
325  bool v0_node = false;
326  bool px_node = false;
327  bool py_node = false;
328 
329  // current data values.
330  double d_u0 = m_cam.get_u0();
331  double d_v0 = m_cam.get_v0();
332  double d_px = m_cam.get_px();
333  double d_py = m_cam.get_py();
334 
335  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
336  if (dataNode->type == XML_ELEMENT_NODE) {
337  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
338  if (iter_data != nodeMap.end()) {
339  switch (iter_data->second) {
340  case u0:
341  d_u0 = xmlReadDoubleChild(doc, dataNode);
342  u0_node = true;
343  break;
344 
345  case v0:
346  d_v0 = xmlReadDoubleChild(doc, dataNode);
347  v0_node = true;
348  break;
349 
350  case px:
351  d_px = xmlReadDoubleChild(doc, dataNode);
352  px_node = true;
353  break;
354 
355  case py:
356  d_py = xmlReadDoubleChild(doc, dataNode);
357  py_node = true;
358  break;
359 
360  default:
361  break;
362  }
363  }
364  }
365  }
366 
367  m_cam.initPersProjWithoutDistortion(d_px, d_py, d_u0, d_v0);
368 
369  if (!u0_node)
370  std::cout << "camera : u0 : " << m_cam.get_u0() << " (default)" << std::endl;
371  else
372  std::cout << "camera : u0 : " << m_cam.get_u0() << std::endl;
373 
374  if (!v0_node)
375  std::cout << "camera : v0 : " << m_cam.get_v0() << " (default)" << std::endl;
376  else
377  std::cout << "camera : v0 : " << m_cam.get_v0() << std::endl;
378 
379  if (!px_node)
380  std::cout << "camera : px : " << m_cam.get_px() << " (default)" << std::endl;
381  else
382  std::cout << "camera : px : " << m_cam.get_px() << std::endl;
383 
384  if (!py_node)
385  std::cout << "camera : py : " << m_cam.get_py() << " (default)" << std::endl;
386  else
387  std::cout << "camera : py : " << m_cam.get_py() << std::endl;
388 }
389 
398 void vpMbtXmlGenericParser::read_depth_normal(xmlDocPtr doc, xmlNodePtr node)
399 {
400  bool feature_estimation_method_node = false;
401  bool PCL_plane_estimation_node = false;
402  bool sampling_step_node = false;
403 
404  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
405  if (dataNode->type == XML_ELEMENT_NODE) {
406  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
407  if (iter_data != nodeMap.end()) {
408  switch (iter_data->second) {
412  feature_estimation_method_node = true;
413  break;
414 
416  read_depth_normal_PCL(doc, dataNode);
417  PCL_plane_estimation_node = true;
418  break;
419 
420  case depth_sampling_step:
421  read_depth_normal_sampling_step(doc, dataNode);
422  sampling_step_node = true;
423  break;
424 
425  default:
426  break;
427  }
428  }
429  }
430  }
431 
432  if (!feature_estimation_method_node)
433  std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << " (default)"
434  << std::endl;
435  else
436  std::cout << "depth normal : feature_estimation_method : " << m_depthNormalFeatureEstimationMethod << std::endl;
437 
438  if (!PCL_plane_estimation_node) {
439  std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
440  << " (default)" << std::endl;
441  std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
442  << " (default)" << std::endl;
443  std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
444  << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
445  }
446 
447  if (!sampling_step_node) {
448  std::cout << "depth normal : sampling_step : step_X " << m_depthNormalSamplingStepX << " (default)" << std::endl;
449  std::cout << "depth normal : sampling_step : step_Y " << m_depthNormalSamplingStepY << " (default)" << std::endl;
450  }
451 }
452 
461 void vpMbtXmlGenericParser::read_depth_normal_PCL(xmlDocPtr doc, xmlNodePtr node)
462 {
463  bool PCL_plane_estimation_method_node = false;
464  bool PCL_plane_estimation_ransac_max_iter_node = false;
465  bool PCL_plane_estimation_ransac_threshold_node = false;
466 
467  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
468  if (dataNode->type == XML_ELEMENT_NODE) {
469  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
470  if (iter_data != nodeMap.end()) {
471  switch (iter_data->second) {
474  PCL_plane_estimation_method_node = true;
475  break;
476 
479  PCL_plane_estimation_ransac_max_iter_node = true;
480  break;
481 
484  PCL_plane_estimation_ransac_threshold_node = true;
485  break;
486 
487  default:
488  break;
489  }
490  }
491  }
492  }
493 
494  if (!PCL_plane_estimation_method_node)
495  std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
496  << " (default)" << std::endl;
497  else
498  std::cout << "depth normal : PCL_plane_estimation : method : " << m_depthNormalPclPlaneEstimationMethod
499  << std::endl;
500 
501  if (!PCL_plane_estimation_ransac_max_iter_node)
502  std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
503  << " (default)" << std::endl;
504  else
505  std::cout << "depth normal : PCL_plane_estimation : max_iter : " << m_depthNormalPclPlaneEstimationRansacMaxIter
506  << std::endl;
507 
508  if (!PCL_plane_estimation_ransac_threshold_node)
509  std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
510  << m_depthNormalPclPlaneEstimationRansacThreshold << " (default)" << std::endl;
511  else
512  std::cout << "depth normal : PCL_plane_estimation : ransac_threshold : "
514 }
515 
524 void vpMbtXmlGenericParser::read_depth_normal_sampling_step(xmlDocPtr doc, xmlNodePtr node)
525 {
526  bool sampling_step_X_node = false;
527  bool sampling_step_Y_node = false;
528 
529  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
530  if (dataNode->type == XML_ELEMENT_NODE) {
531  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
532  if (iter_data != nodeMap.end()) {
533  switch (iter_data->second) {
536  sampling_step_X_node = true;
537  break;
538 
541  sampling_step_Y_node = true;
542  break;
543 
544  default:
545  break;
546  }
547  }
548  }
549  }
550 
551  if (!sampling_step_X_node)
552  std::cout << "depth normal : sampling_step : step_X : " << m_depthNormalSamplingStepX << " (default)" << std::endl;
553  else
554  std::cout << "depth normal : sampling_step : step_X : " << m_depthNormalSamplingStepX << std::endl;
555 
556  if (!sampling_step_Y_node)
557  std::cout << "depth normal : sampling_step : step_Y : " << m_depthNormalSamplingStepY << " (default)" << std::endl;
558  else
559  std::cout << "depth normal : sampling_step : step_Y : " << m_depthNormalSamplingStepY << std::endl;
560 }
561 
570 void vpMbtXmlGenericParser::read_depth_dense(xmlDocPtr doc, xmlNodePtr node)
571 {
572  bool sampling_step_node = false;
573 
574  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
575  if (dataNode->type == XML_ELEMENT_NODE) {
576  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
577  if (iter_data != nodeMap.end()) {
578  switch (iter_data->second) {
580  read_depth_dense_sampling_step(doc, dataNode);
581  sampling_step_node = true;
582  break;
583 
584  default:
585  break;
586  }
587  }
588  }
589  }
590 
591  if (!sampling_step_node) {
592  std::cout << "depth dense : sampling_step : step_X " << m_depthDenseSamplingStepX << " (default)" << std::endl;
593  std::cout << "depth dense : sampling_step : step_Y " << m_depthDenseSamplingStepY << " (default)" << std::endl;
594  }
595 }
596 
605 void vpMbtXmlGenericParser::read_depth_dense_sampling_step(xmlDocPtr doc, xmlNodePtr node)
606 {
607  bool sampling_step_X_node = false;
608  bool sampling_step_Y_node = false;
609 
610  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
611  if (dataNode->type == XML_ELEMENT_NODE) {
612  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
613  if (iter_data != nodeMap.end()) {
614  switch (iter_data->second) {
617  sampling_step_X_node = true;
618  break;
619 
622  sampling_step_Y_node = true;
623  break;
624 
625  default:
626  break;
627  }
628  }
629  }
630  }
631 
632  if (!sampling_step_X_node)
633  std::cout << "depth dense : sampling_step : step_X : " << m_depthDenseSamplingStepX << " (default)" << std::endl;
634  else
635  std::cout << "depth dense : sampling_step : step_X : " << m_depthDenseSamplingStepX << std::endl;
636 
637  if (!sampling_step_Y_node)
638  std::cout << "depth dense : sampling_step : step_Y : " << m_depthDenseSamplingStepY << " (default)" << std::endl;
639  else
640  std::cout << "depth dense : sampling_step : step_Y : " << m_depthDenseSamplingStepY << std::endl;
641 }
642 
651 void vpMbtXmlGenericParser::read_ecm(xmlDocPtr doc, xmlNodePtr node)
652 {
653  bool mask_node = false;
654  bool range_node = false;
655  bool contrast_node = false;
656  bool sample_node = false;
657 
658  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
659  if (dataNode->type == XML_ELEMENT_NODE) {
660  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
661  if (iter_data != nodeMap.end()) {
662  switch (iter_data->second) {
663  case mask:
664  read_ecm_mask(doc, dataNode);
665  mask_node = true;
666  break;
667 
668  case range:
669  read_ecm_range(doc, dataNode);
670  range_node = true;
671  break;
672 
673  case contrast:
674  read_ecm_contrast(doc, dataNode);
675  contrast_node = true;
676  break;
677 
678  case sample:
679  read_ecm_sample(doc, dataNode);
680  sample_node = true;
681  break;
682 
683  default:
684  break;
685  }
686  }
687  }
688  }
689 
690  if (!mask_node) {
691  std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
692  std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
693  }
694 
695  if (!range_node) {
696  std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
697  }
698 
699  if (!contrast_node) {
700  std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << " (default)" << std::endl;
701  std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << " (default)" << std::endl;
702  std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << " (default)" << std::endl;
703  }
704 
705  if (!sample_node) {
706  std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
707  }
708 }
709 
718 void vpMbtXmlGenericParser::read_ecm_contrast(xmlDocPtr doc, xmlNodePtr node)
719 {
720  bool edge_threshold_node = false;
721  bool mu1_node = false;
722  bool mu2_node = false;
723 
724  // current data values.
725  double d_edge_threshold = m_ecm.getThreshold();
726  double d_mu1 = m_ecm.getMu1();
727  double d_mu2 = m_ecm.getMu2();
728 
729  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
730  if (dataNode->type == XML_ELEMENT_NODE) {
731  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
732  if (iter_data != nodeMap.end()) {
733  switch (iter_data->second) {
734  case edge_threshold:
735  d_edge_threshold = xmlReadDoubleChild(doc, dataNode);
736  edge_threshold_node = true;
737  break;
738 
739  case mu1:
740  d_mu1 = xmlReadDoubleChild(doc, dataNode);
741  mu1_node = true;
742  break;
743 
744  case mu2:
745  d_mu2 = xmlReadDoubleChild(doc, dataNode);
746  mu2_node = true;
747  break;
748 
749  default:
750  break;
751  }
752  }
753  }
754  }
755 
756  m_ecm.setMu1(d_mu1);
757  m_ecm.setMu2(d_mu2);
758  m_ecm.setThreshold(d_edge_threshold);
759 
760  if (!edge_threshold_node)
761  std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << " (default)" << std::endl;
762  else
763  std::cout << "ecm : contrast : threshold " << m_ecm.getThreshold() << std::endl;
764 
765  if (!mu1_node)
766  std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << " (default)" << std::endl;
767  else
768  std::cout << "ecm : contrast : mu1 " << m_ecm.getMu1() << std::endl;
769 
770  if (!mu2_node)
771  std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << " (default)" << std::endl;
772  else
773  std::cout << "ecm : contrast : mu2 " << m_ecm.getMu2() << std::endl;
774 }
775 
784 void vpMbtXmlGenericParser::read_ecm_mask(xmlDocPtr doc, xmlNodePtr node)
785 {
786  bool size_node = false;
787  bool nb_mask_node = false;
788 
789  // current data values.
790  unsigned int d_size = m_ecm.getMaskSize();
791  unsigned int d_nb_mask = m_ecm.getMaskNumber();
792 
793  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
794  if (dataNode->type == XML_ELEMENT_NODE) {
795  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
796  if (iter_data != nodeMap.end()) {
797  switch (iter_data->second) {
798  case size:
799  d_size = xmlReadUnsignedIntChild(doc, dataNode);
800  size_node = true;
801  break;
802 
803  case nb_mask:
804  d_nb_mask = xmlReadUnsignedIntChild(doc, dataNode);
805  nb_mask_node = true;
806  break;
807 
808  default:
809  break;
810  }
811  }
812  }
813  }
814 
815  m_ecm.setMaskSize(d_size);
816 
817  // Check to ensure that d_nb_mask > 0
818  if (d_nb_mask == 0)
819  throw(vpException(vpException::badValue, "Model-based tracker mask size "
820  "parameter should be different "
821  "from zero in xml file"));
822  m_ecm.setMaskNumber(d_nb_mask);
823 
824  if (!size_node)
825  std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << " (default)" << std::endl;
826  else
827  std::cout << "ecm : mask : size : " << m_ecm.getMaskSize() << std::endl;
828 
829  if (!nb_mask_node)
830  std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << " (default)" << std::endl;
831  else
832  std::cout << "ecm : mask : nb_mask : " << m_ecm.getMaskNumber() << std::endl;
833 }
834 
843 void vpMbtXmlGenericParser::read_ecm_range(xmlDocPtr doc, xmlNodePtr node)
844 {
845  bool tracking_node = false;
846 
847  // current data values.
848  unsigned int m_range_tracking = m_ecm.getRange();
849 
850  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
851  if (dataNode->type == XML_ELEMENT_NODE) {
852  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
853  if (iter_data != nodeMap.end()) {
854  switch (iter_data->second) {
855  case tracking:
856  m_range_tracking = xmlReadUnsignedIntChild(doc, dataNode);
857  tracking_node = true;
858  break;
859 
860  default:
861  break;
862  }
863  }
864  }
865  }
866 
867  m_ecm.setRange(m_range_tracking);
868 
869  if (!tracking_node)
870  std::cout << "ecm : range : tracking : " << m_ecm.getRange() << " (default)" << std::endl;
871  else
872  std::cout << "ecm : range : tracking : " << m_ecm.getRange() << std::endl;
873 }
874 
883 void vpMbtXmlGenericParser::read_ecm_sample(xmlDocPtr doc, xmlNodePtr node)
884 {
885  bool step_node = false;
886 
887  // current data values.
888  double d_stp = m_ecm.getSampleStep();
889 
890  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
891  if (dataNode->type == XML_ELEMENT_NODE) {
892  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
893  if (iter_data != nodeMap.end()) {
894  switch (iter_data->second) {
895  case step:
896  d_stp = xmlReadIntChild(doc, dataNode);
897  step_node = true;
898  break;
899 
900  default:
901  break;
902  }
903  }
904  }
905  }
906 
907  m_ecm.setSampleStep(d_stp);
908 
909  if (!step_node)
910  std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
911  else
912  std::cout << "ecm : sample : sample_step : " << m_ecm.getSampleStep() << std::endl;
913 }
914 
923 void vpMbtXmlGenericParser::read_face(xmlDocPtr doc, xmlNodePtr node)
924 {
925  bool angle_appear_node = false;
926  bool angle_disappear_node = false;
927  bool near_clipping_node = false;
928  bool far_clipping_node = false;
929  bool fov_clipping_node = false;
930  m_hasNearClipping = false;
931  m_hasFarClipping = false;
932 
933  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
934  if (dataNode->type == XML_ELEMENT_NODE) {
935  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
936  if (iter_data != nodeMap.end()) {
937  switch (iter_data->second) {
938  case angle_appear:
939  m_angleAppear = xmlReadDoubleChild(doc, dataNode);
940  angle_appear_node = true;
941  break;
942 
943  case angle_disappear:
944  m_angleDisappear = xmlReadDoubleChild(doc, dataNode);
945  angle_disappear_node = true;
946  break;
947 
948  case near_clipping:
949  m_nearClipping = xmlReadDoubleChild(doc, dataNode);
950  m_hasNearClipping = true;
951  near_clipping_node = true;
952  break;
953 
954  case far_clipping:
955  m_farClipping = xmlReadDoubleChild(doc, dataNode);
956  m_hasFarClipping = true;
957  far_clipping_node = true;
958  break;
959 
960  case fov_clipping:
961  if (xmlReadIntChild(doc, dataNode))
962  m_fovClipping = true;
963  else
964  m_fovClipping = false;
965  fov_clipping_node = true;
966  break;
967 
968  default:
969  break;
970  }
971  }
972  }
973  }
974 
975  if (!angle_appear_node)
976  std::cout << "face : Angle Appear : " << m_angleAppear << " (default)" << std::endl;
977  else
978  std::cout << "face : Angle Appear : " << m_angleAppear << std::endl;
979 
980  if (!angle_disappear_node)
981  std::cout << "face : Angle Disappear : " << m_angleDisappear << " (default)" << std::endl;
982  else
983  std::cout << "face : Angle Disappear : " << m_angleDisappear << std::endl;
984 
985  if (near_clipping_node)
986  std::cout << "face : Near Clipping : " << m_nearClipping << std::endl;
987 
988  if (far_clipping_node)
989  std::cout << "face : Far Clipping : " << m_farClipping << std::endl;
990 
991  if (fov_clipping_node) {
992  if (m_fovClipping)
993  std::cout << "face : Fov Clipping : True" << std::endl;
994  else
995  std::cout << "face : Fov Clipping : False" << std::endl;
996  }
997 }
998 
1007 void vpMbtXmlGenericParser::read_klt(xmlDocPtr doc, xmlNodePtr node)
1008 {
1009  bool mask_border_node = false;
1010  bool max_features_node = false;
1011  bool window_size_node = false;
1012  bool quality_node = false;
1013  bool min_distance_node = false;
1014  bool harris_node = false;
1015  bool size_block_node = false;
1016  bool pyramid_lvl_node = false;
1017 
1018  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
1019  if (dataNode->type == XML_ELEMENT_NODE) {
1020  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
1021  if (iter_data != nodeMap.end()) {
1022  switch (iter_data->second) {
1023  case mask_border:
1024  m_kltMaskBorder = xmlReadUnsignedIntChild(doc, dataNode);
1025  mask_border_node = true;
1026  break;
1027 
1028  case max_features:
1029  m_kltMaxFeatures = xmlReadUnsignedIntChild(doc, dataNode);
1030  max_features_node = true;
1031  break;
1032 
1033  case window_size:
1034  m_kltWinSize = xmlReadUnsignedIntChild(doc, dataNode);
1035  window_size_node = true;
1036  break;
1037 
1038  case quality:
1039  m_kltQualityValue = xmlReadDoubleChild(doc, dataNode);
1040  quality_node = true;
1041  break;
1042 
1043  case min_distance:
1044  m_kltMinDist = xmlReadDoubleChild(doc, dataNode);
1045  min_distance_node = true;
1046  break;
1047 
1048  case harris:
1049  m_kltHarrisParam = xmlReadDoubleChild(doc, dataNode);
1050  harris_node = true;
1051  break;
1052 
1053  case size_block:
1054  m_kltBlockSize = xmlReadUnsignedIntChild(doc, dataNode);
1055  size_block_node = true;
1056  break;
1057 
1058  case pyramid_lvl:
1060  pyramid_lvl_node = true;
1061  break;
1062 
1063  default:
1064  break;
1065  }
1066  }
1067  }
1068  }
1069 
1070  if (!mask_border_node)
1071  std::cout << "klt : Mask Border : " << m_kltMaskBorder << " (default)" << std::endl;
1072  else
1073  std::cout << "klt : Mask Border : " << m_kltMaskBorder << std::endl;
1074 
1075  if (!max_features_node)
1076  std::cout << "klt : Max Features : " << m_kltMaxFeatures << " (default)" << std::endl;
1077  else
1078  std::cout << "klt : Max Features : " << m_kltMaxFeatures << std::endl;
1079 
1080  if (!window_size_node)
1081  std::cout << "klt : Windows Size : " << m_kltWinSize << " (default)" << std::endl;
1082  else
1083  std::cout << "klt : Windows Size : " << m_kltWinSize << std::endl;
1084 
1085  if (!quality_node)
1086  std::cout << "klt : Quality : " << m_kltQualityValue << " (default)" << std::endl;
1087  else
1088  std::cout << "klt : Quality : " << m_kltQualityValue << std::endl;
1089 
1090  if (!min_distance_node)
1091  std::cout << "klt : Min Distance : " << m_kltMinDist << " (default)" << std::endl;
1092  else
1093  std::cout << "klt : Min Distance : " << m_kltMinDist << std::endl;
1094 
1095  if (!harris_node)
1096  std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << " (default)" << std::endl;
1097  else
1098  std::cout << "klt : Harris Parameter : " << m_kltHarrisParam << std::endl;
1099 
1100  if (!size_block_node)
1101  std::cout << "klt : Block Size : " << m_kltBlockSize << " (default)" << std::endl;
1102  else
1103  std::cout << "klt : Block Size : " << m_kltBlockSize << std::endl;
1104 
1105  if (!pyramid_lvl_node)
1106  std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << " (default)" << std::endl;
1107  else
1108  std::cout << "klt : Pyramid Levels : " << m_kltPyramidLevels << std::endl;
1109 }
1110 
1111 void vpMbtXmlGenericParser::read_lod(xmlDocPtr doc, xmlNodePtr node)
1112 {
1113  bool use_lod_node = false;
1114  bool min_line_length_threshold_node = false;
1115  bool min_polygon_area_threshold_node = false;
1116 
1117  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
1118  if (dataNode->type == XML_ELEMENT_NODE) {
1119  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
1120  if (iter_data != nodeMap.end()) {
1121  switch (iter_data->second) {
1122  case use_lod:
1123  m_useLod = (xmlReadIntChild(doc, dataNode) != 0);
1124  use_lod_node = true;
1125  break;
1126 
1129  min_line_length_threshold_node = true;
1130  break;
1131 
1134  min_polygon_area_threshold_node = true;
1135  break;
1136 
1137  default:
1138  break;
1139  }
1140  }
1141  }
1142  }
1143 
1144  if (!use_lod_node)
1145  std::cout << "lod : use lod : " << m_useLod << " (default)" << std::endl;
1146  else
1147  std::cout << "lod : use lod : " << m_useLod << std::endl;
1148 
1149  if (!min_line_length_threshold_node)
1150  std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << " (default)" << std::endl;
1151  else
1152  std::cout << "lod : min line length threshold : " << m_minLineLengthThreshold << std::endl;
1153 
1154  if (!min_polygon_area_threshold_node)
1155  std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << " (default)" << std::endl;
1156  else
1157  std::cout << "lod : min polygon area threshold : " << m_minPolygonAreaThreshold << std::endl;
1158 }
1159 
1160 void vpMbtXmlGenericParser::read_projection_error(xmlDocPtr doc, xmlNodePtr node)
1161 {
1162  bool step_node = false;
1163  bool kernel_size_node = false;
1164 
1165  // current data values.
1166  double d_stp = m_projectionErrorMe.getSampleStep();
1167  std::string kernel_size_str;
1168 
1169  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
1170  if (dataNode->type == XML_ELEMENT_NODE) {
1171  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
1172  if (iter_data != nodeMap.end()) {
1173  switch (iter_data->second) {
1175  d_stp = xmlReadIntChild(doc, dataNode);
1176  step_node = true;
1177  break;
1178 
1180  kernel_size_str = xmlReadCharChild(doc, dataNode);
1181  kernel_size_node = true;
1182  break;
1183 
1184  default:
1185  break;
1186  }
1187  }
1188  }
1189  }
1190 
1192 
1193  if (kernel_size_str == "3x3") {
1195  } else if (kernel_size_str == "5x5") {
1197  } else if (kernel_size_str == "7x7") {
1199  } else if (kernel_size_str == "9x9") {
1201  } else if (kernel_size_str == "11x11") {
1203  } else if (kernel_size_str == "13x13") {
1205  } else if (kernel_size_str == "15x15") {
1207  } else {
1208  std::cerr << "Unsupported kernel size." << std::endl;
1209  }
1210 
1211  if (!step_node)
1212  std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << " (default)" << std::endl;
1213  else
1214  std::cout << "projection_error : sample_step : " << m_projectionErrorMe.getSampleStep() << std::endl;
1215 
1216  if (!kernel_size_node)
1217  std::cout << "projection_error : kernel_size : " << m_projectionErrorKernelSize*2+1 << "x"
1218  << m_projectionErrorKernelSize*2+1 << " (default)" << std::endl;
1219  else
1220  std::cout << "projection_error : kernel_size : " << kernel_size_str << std::endl;
1221 }
1222 
1231 void vpMbtXmlGenericParser::read_sample_deprecated(xmlDocPtr doc, xmlNodePtr node)
1232 {
1233  bool step_node = false;
1234  // bool nb_sample_node = false;
1235 
1236  // current data values.
1237  double d_stp = m_ecm.getSampleStep();
1238 
1239  for (xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
1240  if (dataNode->type == XML_ELEMENT_NODE) {
1241  std::map<std::string, int>::const_iterator iter_data = nodeMap.find((char *)dataNode->name);
1242  if (iter_data != nodeMap.end()) {
1243  switch (iter_data->second) {
1244  case step:
1245  d_stp = xmlReadIntChild(doc, dataNode);
1246  step_node = true;
1247  break;
1248 
1249  default:
1250  break;
1251  }
1252  }
1253  }
1254  }
1255 
1256  m_ecm.setSampleStep(d_stp);
1257 
1258  if (!step_node)
1259  std::cout << "[DEPRECATED] sample : sample_step : " << m_ecm.getSampleStep() << " (default)" << std::endl;
1260  else
1261  std::cout << "[DEPRECATED] sample : sample_step : " << m_ecm.getSampleStep() << std::endl;
1262 
1263  std::cout << " WARNING : This node (sample) is deprecated." << std::endl;
1264  std::cout << " It should be moved in the ecm node (ecm : sample)." << std::endl;
1265 }
1266 
1267 #elif !defined(VISP_BUILD_SHARED_LIBS)
1268 // Work arround to avoid warning: libvisp_mbt.a(vpMbtXmlGenericParser.cpp.o)
1269 // has no symbols
1270 void dummy_vpMbtXmlGenericParser(){};
1271 #endif
Used to indicate that a value is not in the allowed range.
Definition: vpException.h:97
unsigned int getRange() const
Definition: vpMe.h:179
unsigned int getMaskSize() const
Definition: vpMe.h:142
unsigned int m_kltWinSize
Windows size.
unsigned int m_depthDenseSamplingStepX
Sampling step in X.
bool m_hasNearClipping
Is near clipping distance specified?
double get_u0() const
double m_minLineLengthThreshold
Minimum line length to track a segment when LOD is enabled.
void read_klt(xmlDocPtr doc, xmlNodePtr node)
void setMainTag(const std::string &tag)
Definition: vpXmlParser.h:295
unsigned int getMaskNumber() const
Definition: vpMe.h:128
virtual void readMainClass(xmlDocPtr doc, xmlNodePtr node)
double getMu1() const
Definition: vpMe.h:155
void setMaskNumber(const unsigned int &a)
Definition: vpMe.cpp:454
int m_depthNormalPclPlaneEstimationMethod
PCL plane estimation method.
void read_depth_normal_sampling_step(xmlDocPtr doc, xmlNodePtr node)
double m_angleDisappear
Angle to determine if a face disappeared.
void setSampleStep(const double &s)
Definition: vpMe.h:278
error that can be emited by ViSP classes.
Definition: vpException.h:71
bool m_useLod
If true, the LOD is enabled, otherwise it is not.
double xmlReadDoubleChild(xmlDocPtr doc, xmlNodePtr node)
double get_py() const
double m_nearClipping
Near clipping distance.
unsigned int m_depthDenseSamplingStepY
Sampling step in Y.
void writeMainClass(xmlNodePtr node)
void read_lod(xmlDocPtr doc, xmlNodePtr node)
void setMu1(const double &mu_1)
Definition: vpMe.h:241
void read_depth_normal_PCL(xmlDocPtr doc, xmlNodePtr node)
unsigned int m_kltBlockSize
Block size.
void read_projection_error(xmlDocPtr doc, xmlNodePtr node)
int m_depthNormalPclPlaneEstimationRansacMaxIter
PCL RANSAC maximum number of iterations.
char * xmlReadCharChild(xmlDocPtr doc, xmlNodePtr node)
void initPersProjWithoutDistortion(const double px, const double py, const double u0, const double v0)
void read_ecm_range(xmlDocPtr doc, xmlNodePtr node)
double m_kltMinDist
Minimum distance between klt points.
unsigned int m_depthNormalSamplingStepX
Sampling step in X.
double getThreshold() const
Definition: vpMe.h:193
void read_camera(xmlDocPtr doc, xmlNodePtr node)
void read_ecm_sample(xmlDocPtr doc, xmlNodePtr node)
unsigned int m_depthNormalSamplingStepY
Sampling step in Y.
void setMaskSize(const unsigned int &a)
Definition: vpMe.cpp:461
double get_v0() const
double m_kltQualityValue
Quality of the Klt points.
void read_depth_dense_sampling_step(xmlDocPtr doc, xmlNodePtr node)
bool m_fovClipping
Fov Clipping.
vpMbtFaceDepthNormal::vpFeatureEstimationType m_depthNormalFeatureEstimationMethod
Feature estimation method.
int xmlReadIntChild(xmlDocPtr doc, xmlNodePtr node)
vpCameraParameters m_cam
Camera parameters.
double m_farClipping
Near clipping distance.
double m_minPolygonAreaThreshold
Minimum polygon area to track a face when LOD is enabled.
double get_px() const
double m_depthNormalPclPlaneEstimationRansacThreshold
PCL RANSAC threshold.
vpParserType m_parserType
Parser type.
unsigned int m_projectionErrorKernelSize
Kernel size (actual_kernel_size = size*2 + 1) used for projection error computation.
unsigned int xmlReadUnsignedIntChild(xmlDocPtr doc, xmlNodePtr node)
void setMu2(const double &mu_2)
Definition: vpMe.h:248
double getMu2() const
Definition: vpMe.h:161
unsigned int m_kltMaskBorder
Border of the mask used on Klt points.
vpMbtXmlGenericParser(const vpParserType &type=EDGE_PARSER)
void setThreshold(const double &t)
Definition: vpMe.h:300
unsigned int m_kltPyramidLevels
Number of pyramid levels.
void read_ecm(xmlDocPtr doc, xmlNodePtr node)
void read_sample_deprecated(xmlDocPtr doc, xmlNodePtr node)
double m_kltHarrisParam
Harris free parameters.
void read_ecm_contrast(xmlDocPtr doc, xmlNodePtr node)
void setRange(const unsigned int &r)
Definition: vpMe.h:271
void read_ecm_mask(xmlDocPtr doc, xmlNodePtr node)
double getSampleStep() const
Definition: vpMe.h:285
unsigned int m_kltMaxFeatures
Maximum of Klt features.
void read_depth_normal(xmlDocPtr doc, xmlNodePtr node)
vpMe m_projectionErrorMe
ME parameters for projection error computation.
double m_angleAppear
Angle to determine if a face appeared.
vpMe m_ecm
Moving edges parameters.
std::map< std::string, int > nodeMap
Definition: vpXmlParser.h:226
bool m_hasFarClipping
Is far clipping distance specified?
void read_face(xmlDocPtr doc, xmlNodePtr node)
void read_depth_dense(xmlDocPtr doc, xmlNodePtr node)