parameters.h

Go to the documentation of this file.

/*
 * This file is part of the CoverageControl library
 *
 * Author: Saurav Agarwal
 * Contact: sauravag@seas.upenn.edu, agr.saurav1@gmail.com
 * Repository: https://github.com/KumarRobotics/CoverageControl
 *
 * Copyright (c) 2024, Saurav Agarwal
 *
 * The CoverageControl library 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 3 of the License, or (at your
 * option) any later version.
 *
 * The CoverageControl library is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * CoverageControl library. If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef CPPSRC_CORE_INCLUDE_COVERAGECONTROL_PARAMETERS_H_
#define CPPSRC_CORE_INCLUDE_COVERAGECONTROL_PARAMETERS_H_
 
#include <cmath>
#include <string>
 
namespace CoverageControl {
 
class Parameters {
 public:
  std::string config_file_;
 
  int pNumRobots = 32;    
 
  double pPlotScale = 1.0;
  double pResolution = 1.0;
 
  int pWorldMapSize = 1024;
 
  int pRobotMapSize = pWorldMapSize;
 
  int pLocalMapSize = 256;
 
  bool pUpdateRobotMap = true;
  bool pUpdateExplorationMap = true;
  bool pUpdateSensorView = true;
  bool pUpdateSystemMap = true;
 
  // Helps in reducing the number of erfc evaluations
  // Needs testing to be sure that the probability masses are not significantly
  // off
  int pNumGaussianFeatures = 32;  
  double pTruncationBND = 2;
 
  double pNorm = 1;
 
  // These settings are only required if the IDF is generated using random
  // gaussians
  double pMinSigma = 40;
  double pMaxSigma = 50;
  double pMinPeak = 6;
  double pMaxPeak = 10;
 
  int pNumPolygons = 0;   
  int pMaxVertices = 10;  
  double pPolygonRadius = 64;
 
  double pUnknownImportance = 0.5;
  bool pRobotMapUseUnknownImportance = false;
  // Assuming square sensor FOV.
  // Actual FOV: square with side pResolution * pSensorSize
  // Robot is placed at the center of FOV
  // Make it even so that I don't have to deal with substracting by
  // half-resolution. Have made it to half of (pWorldMapSize - 1000 /
  // pResolution)/2
  int pSensorSize = 64;  
  double pCommunicationRange = 128;  
  // in m/s. Make sure pMaxRobotSpeed * pTimeStep / pResolution < pSensorSize/2
  double pMaxRobotSpeed = 5;
  double pRobotInitDist = 1024;   
  int pRobotPosHistorySize = 20;  
  double pTimeStep = 1;  
 
  bool pAddNoisePositions = false;
  double pPositionsNoiseSigma = 0.;
  int pEpisodeSteps = 2000;  // Total time is pEpisodeSteps * pTimeStep
  bool pCheckOscillations = true;
 
  int pLloydMaxIterations = 100;
  int pLloydNumTries = 10;
  int pNumFrontiers = 10;  // Number of frontiers to be selected
  Parameters() {}
 
  explicit Parameters(std::string const &config_file)
      : config_file_{config_file} {
    ParseParameters();
    /* PrintParameters(); */
  }
 
  void SetConfig(std::string const &config_file) {
    config_file_ = config_file;
    ParseParameters();
  }
 
  void PrintParameters() const;
 
 private:
  void ParseParameters();
};
 
} /* namespace CoverageControl */
 
#endif  // CPPSRC_CORE_INCLUDE_COVERAGECONTROL_PARAMETERS_H_