vpMbtXmlGenericParser.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Load XML Parameter for Model Based Tracker.
 *
 *****************************************************************************/

#ifndef _vpMbtXmlGenericParser_h_
#define _vpMbtXmlGenericParser_h_

#include <visp3/core/vpConfig.h>

#ifdef VISP_HAVE_XML2

#include <libxml/xmlmemory.h>

#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpXmlParser.h>
#include <visp3/mbt/vpMbtFaceDepthNormal.h>
#include <visp3/me/vpMe.h>

class VISP_EXPORT vpMbtXmlGenericParser : public vpXmlParser
{
public:
  enum vpParserType {
    EDGE_PARSER = 1 << 0,         
    KLT_PARSER = 1 << 1,          
    DEPTH_NORMAL_PARSER = 1 << 2, 
    DEPTH_DENSE_PARSER = 1 << 3   
    , PROJECTION_ERROR_PARSER = 0 
  };

protected:
  vpParserType m_parserType;
  vpCameraParameters m_cam;
  double m_angleAppear;
  double m_angleDisappear;
  bool m_hasNearClipping;
  double m_nearClipping;
  bool m_hasFarClipping;
  double m_farClipping;
  bool m_fovClipping;
  // LOD
  bool m_useLod;
  double m_minLineLengthThreshold;
  double m_minPolygonAreaThreshold;
  // Edge
  vpMe m_ecm;
  // KLT
  unsigned int m_kltMaskBorder;
  unsigned int m_kltMaxFeatures;
  unsigned int m_kltWinSize;
  double m_kltQualityValue;
  double m_kltMinDist;
  double m_kltHarrisParam;
  unsigned int m_kltBlockSize;
  unsigned int m_kltPyramidLevels;
  // Depth normal
  vpMbtFaceDepthNormal::vpFeatureEstimationType m_depthNormalFeatureEstimationMethod;
  int m_depthNormalPclPlaneEstimationMethod;
  int m_depthNormalPclPlaneEstimationRansacMaxIter;
  double m_depthNormalPclPlaneEstimationRansacThreshold;
  unsigned int m_depthNormalSamplingStepX;
  unsigned int m_depthNormalSamplingStepY;
  // Depth dense
  unsigned int m_depthDenseSamplingStepX;
  unsigned int m_depthDenseSamplingStepY;
  // Projection error
  vpMe m_projectionErrorMe;
  unsigned int m_projectionErrorKernelSize;

  enum vpDataToParseMb {
    //<conf>
    conf,
    //<face>
    face,
    angle_appear,
    angle_disappear,
    near_clipping,
    far_clipping,
    fov_clipping,
    //<camera>
    camera,
    height,
    width,
    u0,
    v0,
    px,
    py,
    lod,
    use_lod,
    min_line_length_threshold,
    min_polygon_area_threshold,
    //<ecm>
    ecm,
    mask,
    size,
    nb_mask,
    range,
    tracking,
    contrast,
    edge_threshold,
    mu1,
    mu2,
    sample,
    step,
    //<klt>
    klt,
    mask_border,
    max_features,
    window_size,
    quality,
    min_distance,
    harris,
    size_block,
    pyramid_lvl,
    //<depth_normal>
    depth_normal,
    feature_estimation_method,
    PCL_plane_estimation,
    PCL_plane_estimation_method,
    PCL_plane_estimation_ransac_max_iter,
    PCL_plane_estimation_ransac_threshold,
    depth_sampling_step,
    depth_sampling_step_X,
    depth_sampling_step_Y,
    //<depth_dense>
    depth_dense,
    depth_dense_sampling_step,
    depth_dense_sampling_step_X,
    depth_dense_sampling_step_Y,
    //<projection_error>
    projection_error,
    projection_error_sample_step,
    projection_error_kernel_size
  };

public:
  explicit vpMbtXmlGenericParser(const vpParserType &type = EDGE_PARSER);
  virtual ~vpMbtXmlGenericParser();

  inline double getAngleAppear() const { return m_angleAppear; }

  inline double getAngleDisappear() const { return m_angleDisappear; }

  void getCameraParameters(vpCameraParameters &_cam) const { _cam = m_cam; }

  void getEdgeMe(vpMe &_ecm) const { _ecm = m_ecm; }

  inline unsigned int getDepthDenseSamplingStepX() const { return m_depthDenseSamplingStepX; }

  inline unsigned int getDepthDenseSamplingStepY() const { return m_depthDenseSamplingStepY; }

  vpMbtFaceDepthNormal::vpFeatureEstimationType getDepthNormalFeatureEstimationMethod() const
  {
    return m_depthNormalFeatureEstimationMethod;
  }

  inline int getDepthNormalPclPlaneEstimationMethod() const { return m_depthNormalPclPlaneEstimationMethod; }

  inline int getDepthNormalPclPlaneEstimationRansacMaxIter() const
  {
    return m_depthNormalPclPlaneEstimationRansacMaxIter;
  }

  inline double getDepthNormalPclPlaneEstimationRansacThreshold() const
  {
    return m_depthNormalPclPlaneEstimationRansacThreshold;
  }

  inline unsigned int getDepthNormalSamplingStepX() const { return m_depthNormalSamplingStepX; }

  inline unsigned int getDepthNormalSamplingStepY() const { return m_depthNormalSamplingStepY; }

  inline double getFarClippingDistance() const { return m_farClipping; }

  inline bool getFovClipping() const { return m_fovClipping; }

  inline unsigned int getKltBlockSize() const { return m_kltBlockSize; }

  inline double getKltHarrisParam() const { return m_kltHarrisParam; }

  inline unsigned int getKltMaskBorder() const { return m_kltMaskBorder; }

  inline unsigned int getKltMaxFeatures() const { return m_kltMaxFeatures; }

  inline double getKltMinDistance() const { return m_kltMinDist; }

  inline unsigned int getKltPyramidLevels() const { return m_kltPyramidLevels; }

  inline double getKltQuality() const { return m_kltQualityValue; }

  inline unsigned int getKltWindowSize() const { return m_kltWinSize; }

  inline bool getLodState() const { return m_useLod; }

  inline double getLodMinLineLengthThreshold() const { return m_minLineLengthThreshold; }

  inline double getLodMinPolygonAreaThreshold() const { return m_minPolygonAreaThreshold; }

  inline double getNearClippingDistance() const { return m_nearClipping; }

  inline void getProjectionErrorMe(vpMe &me) const { me = m_projectionErrorMe; }

  inline unsigned int getProjectionErrorKernelSize() const { return m_projectionErrorKernelSize; }

  inline bool hasFarClippingDistance() const { return m_hasFarClipping; }

  inline bool hasNearClippingDistance() const { return m_hasNearClipping; }

  virtual void readMainClass(xmlDocPtr doc, xmlNodePtr node);

  inline void setAngleAppear(const double &aappear) { m_angleAppear = aappear; }

  inline void setAngleDisappear(const double &adisappear) { m_angleDisappear = adisappear; }

  inline void setCameraParameters(const vpCameraParameters &_cam) { m_cam = _cam; }

  inline void setDepthDenseSamplingStepX(const unsigned int stepX) { m_depthDenseSamplingStepX = stepX; }

  inline void setDepthDenseSamplingStepY(const unsigned int stepY) { m_depthDenseSamplingStepY = stepY; }

  inline void setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method)
  {
    m_depthNormalFeatureEstimationMethod = method;
  }

  inline void setDepthNormalPclPlaneEstimationMethod(const int method)
  {
    m_depthNormalPclPlaneEstimationMethod = method;
  }

  inline void setDepthNormalPclPlaneEstimationRansacMaxIter(const int maxIter)
  {
    m_depthNormalPclPlaneEstimationRansacMaxIter = maxIter;
  }

  inline void setDepthNormalPclPlaneEstimationRansacThreshold(const double threshold)
  {
    m_depthNormalPclPlaneEstimationRansacThreshold = threshold;
  }

  inline void setDepthNormalSamplingStepX(const unsigned int stepX) { m_depthNormalSamplingStepX = stepX; }

  inline void setDepthNormalSamplingStepY(const unsigned int stepY) { m_depthNormalSamplingStepY = stepY; }

  inline void setEdgeMe(const vpMe &_ecm) { m_ecm = _ecm; }

  inline void setFarClippingDistance(const double &fclip) { m_farClipping = fclip; }

  inline void setKltBlockSize(const unsigned int &bs) { m_kltBlockSize = bs; }

  inline void setKltHarrisParam(const double &hp) { m_kltHarrisParam = hp; }

  inline void setKltMaskBorder(const unsigned int &mb) { m_kltMaskBorder = mb; }

  inline void setKltMaxFeatures(const unsigned int &mF) { m_kltMaxFeatures = mF; }

  inline void setKltMinDistance(const double &mD) { m_kltMinDist = mD; }

  inline void setKltPyramidLevels(const unsigned int &pL) { m_kltPyramidLevels = pL; }

  inline void setKltQuality(const double &q) { m_kltQualityValue = q; }

  inline void setKltWindowSize(const unsigned int &w) { m_kltWinSize = w; }

  inline void setNearClippingDistance(const double &nclip) { m_nearClipping = nclip; }

  inline void setProjectionErrorMe(const vpMe &me) { m_projectionErrorMe = me; }

  inline void setProjectionErrorKernelSize(const unsigned int &size) { m_projectionErrorKernelSize = size; }

  void writeMainClass(xmlNodePtr node);

protected:
  void init();

  void read_camera(xmlDocPtr doc, xmlNodePtr node);
  void read_face(xmlDocPtr doc, xmlNodePtr node);
  void read_lod(xmlDocPtr doc, xmlNodePtr node);

  // Edge
  void read_ecm(xmlDocPtr doc, xmlNodePtr node);
  void read_ecm_sample(xmlDocPtr doc, xmlNodePtr node);
  void read_sample_deprecated(xmlDocPtr doc, xmlNodePtr node);
  void read_ecm_mask(xmlDocPtr doc, xmlNodePtr node);
  void read_ecm_range(xmlDocPtr doc, xmlNodePtr node);
  void read_ecm_contrast(xmlDocPtr doc, xmlNodePtr node);

  // KLT
  void read_klt(xmlDocPtr doc, xmlNodePtr node);

  // Depth normal
  void read_depth_normal(xmlDocPtr doc, xmlNodePtr node);
  void read_depth_normal_PCL(xmlDocPtr doc, xmlNodePtr node);
  void read_depth_normal_sampling_step(xmlDocPtr doc, xmlNodePtr node);

  // Depth dense
  void read_depth_dense(xmlDocPtr doc, xmlNodePtr node);
  void read_depth_dense_sampling_step(xmlDocPtr doc, xmlNodePtr node);

  // Projection error
  void read_projection_error(xmlDocPtr doc, xmlNodePtr node);
};

#endif

#endif