vpXmlConfigParserKeyPoint.cpp

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2015 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
 * ("GPL") version 2 as published by the Free Software Foundation.
 * 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:
 * XML parser to load configuration for vpKeyPoint class.
 *
 * Authors:
 * Souriya Trinh
 *
 *****************************************************************************/

#include <iostream>

#include <visp3/vision/vpXmlConfigParserKeyPoint.h>

#ifdef VISP_HAVE_XML2

vpXmlConfigParserKeyPoint::vpXmlConfigParserKeyPoint() : m_detectorName("ORB"), m_extractorName("ORB"),
  m_matcherName("BruteForce-Hamming"), m_matchingFactorThreshold(2.0), m_matchingMethod(ratioDistanceThreshold),
  m_matchingRatioThreshold(0.85), m_nbRansacIterations(200), m_nbRansacMinInlierCount(100),
  m_ransacConsensusPercentage(20.0), m_ransacReprojectionError(6.0), m_ransacThreshold(0.01),
  m_useRansacConsensusPercentage(false), m_useRansacVVS(true)
{
  init();
}

void
vpXmlConfigParserKeyPoint::init()
{
  setMainTag("conf");

  nodeMap["conf"] = conf;
  nodeMap["detector"] = detector;
  nodeMap["extractor"] = extractor;
  nodeMap["matcher"] = matcher;
  nodeMap["name"] = name;
  nodeMap["matching_method"] = matching_method;
  nodeMap["constantFactorDistanceThreshold"] = constant_factor_distance_threshold;
  nodeMap["stdDistanceThreshold"] = std_distance_threshold;
  nodeMap["ratioDistanceThreshold"] = ratio_distance_threshold;
  nodeMap["stdAndRatioDistanceThreshold"] = std_and_ratio_distance_threshold;
  nodeMap["noFilterMatching"] = no_filter_matching;
  nodeMap["matchingFactorThreshold"] = matching_factor_threshold;
  nodeMap["matchingRatioThreshold"] = matching_ratio_threshold;
  nodeMap["ransac"] = ransac;
  nodeMap["useRansacVVS"] = use_ransac_vvs;
  nodeMap["useRansacConsensusPercentage"] = use_ransac_consensus_percentage;
  nodeMap["nbRansacIterations"] = nb_ransac_iterations;
  nodeMap["ransacReprojectionError"] = ransac_reprojection_error;
  nodeMap["nbRansacMinInlierCount"] = nb_ransac_min_inlier_count;
  nodeMap["ransacThreshold"] = ransac_threshold;
  nodeMap["ransacConsensusPercentage"] = ransac_consensus_percentage;
}

void
vpXmlConfigParserKeyPoint::parse(const std::string &filename)
{
  vpXmlParser::parse(filename);
}

void
vpXmlConfigParserKeyPoint::readMainClass(xmlDocPtr doc, xmlNodePtr node)
{
  bool detector_node = false;
  bool extractor_node = false;
  bool matcher_node = false;

  for(xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL;  dataNode = dataNode->next)  {
    if(dataNode->type == XML_ELEMENT_NODE){
      std::map<std::string, int>::iterator iter_data= this->nodeMap.find((char*)dataNode->name);
      if(iter_data != nodeMap.end()){
        switch (iter_data->second){
        case detector:
          this->read_detector(doc, dataNode);
          detector_node = true;
          break;

        case extractor:
          this->read_extractor(doc, dataNode);
          extractor_node = true;
          break;

        case matcher:
          this->read_matcher(doc, dataNode);
          matcher_node = true;
          break;

        case ransac:
          this->read_ransac(doc, dataNode);
          break;

        default:
          break;
        }
      }
    }
  }

  if(!detector_node) {
    std::cout << "detector: name: "<< m_detectorName << " (default)" << std::endl;
  }

  if(!extractor_node) {
    std::cout << "extractor: name: "<< m_extractorName << " (default)" << std::endl;
  }

  if(!matcher_node) {
    std::cout << "matcher: name: "<< m_matcherName << " (default)" << std::endl;
  }
}

void
vpXmlConfigParserKeyPoint::read_detector(xmlDocPtr doc, xmlNodePtr node)
{
  bool detector_name_node = false;

  for(xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
    if(dataNode->type == XML_ELEMENT_NODE) {
      std::map<std::string, int>::iterator iter_data = this->nodeMap.find((char*) dataNode->name);
      if (iter_data != nodeMap.end()) {
        switch(iter_data->second) {
        case name:
          m_detectorName = xmlReadStringChild(doc, dataNode);
          detector_name_node = true;
          break;

        default:
          break;
        }
      }
    }
  }

  if(!detector_name_node)
    std::cout << "detector : Name : "<< m_detectorName << " (default)" << std::endl;
  else
    std::cout << "detector : Name : "<< m_detectorName << std::endl;
}

void
vpXmlConfigParserKeyPoint::read_extractor(xmlDocPtr doc, xmlNodePtr node)
{
  bool extractor_name_node = false;

  for(xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
    if(dataNode->type == XML_ELEMENT_NODE) {
      std::map<std::string, int>::iterator iter_data = this->nodeMap.find((char*) dataNode->name);
      if (iter_data != nodeMap.end()) {
        switch(iter_data->second) {
        case name:
          m_extractorName = xmlReadStringChild(doc, dataNode);
          extractor_name_node = true;
          break;

        default:
          break;
        }
      }
    }
  }

  if(!extractor_name_node)
    std::cout << "extractor : Name : "<< m_extractorName << " (default)" << std::endl;
  else
    std::cout << "extractor : Name : "<< m_extractorName << std::endl;
}

void
vpXmlConfigParserKeyPoint::read_matcher(xmlDocPtr doc, xmlNodePtr node)
{
  bool matcher_name_node = false;
  bool matching_method_node = false;
  std::string matchingMethodName = "ratioDistanceThreshold";
  bool matching_factor_threshold_node = false;
  bool matching_ratio_threshold_node = false;

  for(xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
    if(dataNode->type == XML_ELEMENT_NODE) {
      std::map<std::string, int>::iterator iter_data = this->nodeMap.find((char*) dataNode->name);
      if(iter_data != nodeMap.end()) {
        switch(iter_data->second) {
        case name:
          m_matcherName = xmlReadStringChild(doc, dataNode);
          matcher_name_node = true;
          break;

        case matching_method:
        {
          matchingMethodName = xmlReadStringChild(doc, dataNode);

          std::map<std::string, int>::iterator iter_data2 = nodeMap.find(matchingMethodName);
          if(iter_data2 != nodeMap.end()) {
            matching_method_node = true;
            switch(iter_data2->second) {
            case constant_factor_distance_threshold:
              m_matchingMethod = constantFactorDistanceThreshold;
              break;

            case std_distance_threshold:
              m_matchingMethod = stdDistanceThreshold;
              break;

            case ratio_distance_threshold:
              m_matchingMethod = ratioDistanceThreshold;
              break;

            case std_and_ratio_distance_threshold:
              m_matchingMethod = stdAndRatioDistanceThreshold;
              break;

            case no_filter_matching:
              m_matchingMethod = noFilterMatching;
              break;

            default:
              matching_method_node = false;
              break;
            }
          }
          break;
        }

        case matching_factor_threshold:
          m_matchingFactorThreshold = xmlReadDoubleChild(doc, dataNode);
          matching_factor_threshold_node = true;
          break;

        case matching_ratio_threshold:
          m_matchingRatioThreshold = xmlReadDoubleChild(doc, dataNode);
          matching_ratio_threshold_node = true;
          break;

        default:
          break;
        }
      }
    }
  }

  if(!matcher_name_node)
    std::cout << "matcher : Name : "<< m_matcherName << " (default)" << std::endl;
  else
    std::cout << "matcher : Name : "<< m_matcherName <<std::endl;

  if(!matching_method_node)
    std::cout << "matcher : Filter method : "<< matchingMethodName << " (default)" << std::endl;
  else
    std::cout << "matcher : Filter method : "<< matchingMethodName << std::endl;

  if(!matching_factor_threshold_node)
    std::cout << "matcher : matching factor threshold : "<< m_matchingFactorThreshold << " (default)" << std::endl;
  else
    std::cout << "matcher : matching factor threshold : "<< m_matchingFactorThreshold << std::endl;

  if(!matching_ratio_threshold_node)
    std::cout << "matcher : matching ratio threshold : "<< m_matchingRatioThreshold << " (default)" << std::endl;
  else
    std::cout << "matcher : matching ratio threshold : "<< m_matchingRatioThreshold << std::endl;
}

void
vpXmlConfigParserKeyPoint::read_ransac(xmlDocPtr doc, xmlNodePtr node)
{
  bool use_ransac_vvs_node = false;
  bool use_ransac_consensus_percentage_node = false;
  bool nb_ransac_iterations_node = false;
  bool ransac_reprojection_error_node = false;
  bool nb_ransac_min_inlier_count_node = false;
  bool ransac_threshold_node = false;
  bool ransac_consensus_percentage_node = false;

  for(xmlNodePtr dataNode = node->xmlChildrenNode; dataNode != NULL; dataNode = dataNode->next) {
    if(dataNode->type == XML_ELEMENT_NODE) {
      std::map<std::string, int>::iterator iter_data = this->nodeMap.find((char*) dataNode->name);
      if(iter_data != nodeMap.end()) {
        switch(iter_data->second) {
        case use_ransac_vvs:
          m_useRansacVVS = xmlReadIntChild(doc, dataNode) != 0;
          use_ransac_vvs_node = true;
          break;

        case use_ransac_consensus_percentage:
          m_useRansacConsensusPercentage = xmlReadIntChild(doc, dataNode) != 0;
          use_ransac_consensus_percentage_node = true;
          break;

        case nb_ransac_iterations:
          m_nbRansacIterations = xmlReadIntChild(doc, dataNode);
          nb_ransac_iterations_node = true;
          break;

        case ransac_reprojection_error:
          m_ransacReprojectionError = xmlReadDoubleChild(doc, dataNode);
          ransac_reprojection_error_node = true;
          break;

        case nb_ransac_min_inlier_count:
          m_nbRansacMinInlierCount = xmlReadIntChild(doc, dataNode);
          nb_ransac_min_inlier_count_node = true;
          break;

        case ransac_threshold:
          m_ransacThreshold = xmlReadDoubleChild(doc, dataNode);
          ransac_threshold_node = true;
          break;

        case ransac_consensus_percentage:
          m_ransacConsensusPercentage = xmlReadDoubleChild(doc, dataNode);
          ransac_consensus_percentage_node = true;
          break;

        default:
          break;
        }
      }
    }
  }

  if(!use_ransac_vvs_node)
    std::cout << "ransac: use ransac vvs pose estimation: "<< m_useRansacVVS << " (default)" << std::endl;
  else
    std::cout << "ransac: use ransac vvs pose estimation: "<< m_useRansacVVS <<std::endl;

  if(!use_ransac_consensus_percentage_node)
    std::cout << "ransac: use consensus percentage: "<< m_useRansacConsensusPercentage << " (default)" << std::endl;
  else
    std::cout << "ransac: use consensus percentage: "<< m_useRansacConsensusPercentage <<std::endl;

  if(!nb_ransac_iterations_node)
    std::cout << "ransac: nb ransac iterations: "<< m_nbRansacIterations << " (default)" << std::endl;
  else
    std::cout << "ransac: nb ransac iterations: "<< m_nbRansacIterations <<std::endl;

  if(!ransac_reprojection_error_node)
    std::cout << "ransac: ransac reprojection error in pixel (for OpenCV function): "<< m_ransacReprojectionError << " (default)" << std::endl;
  else
    std::cout << "ransac: ransac reprojection error in pixel (for OpenCV function): "<< m_ransacReprojectionError <<std::endl;

  if(!nb_ransac_min_inlier_count_node)
    std::cout << "ransac: nb ransac min inlier count: "<< m_nbRansacMinInlierCount << " (default)" << std::endl;
  else
    std::cout << "ransac: nb ransac min inlier count: "<< m_nbRansacMinInlierCount <<std::endl;

  if(!ransac_threshold_node)
    std::cout << "ransac: ransac threshold in meter (for ViSP function): "<< m_ransacThreshold << " (default)" << std::endl;
  else
    std::cout << "ransac: ransac threshold in meter (for ViSP function): "<< m_ransacThreshold <<std::endl;

  if(!ransac_consensus_percentage_node)
    std::cout << "ransac: consensus percentage: "<< m_ransacConsensusPercentage << " (default)" << std::endl;
  else
    std::cout << "ransac: consensus percentage: "<< m_ransacConsensusPercentage <<std::endl;
}

#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work arround to avoid warning: libvisp_vision.a(vpXmlConfigParserKeyPoint.cpp.o) has no symbols
void dummy_vpXmlConfigParserKeyPoint() {};
#endif //VISP_HAVE_XML2