Main MRPT website > C++ reference for MRPT 1.3.2
maps/CRandomFieldGridMap2D.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2015, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 
10 #ifndef CRandomFieldGridMap2D_H
11 #define CRandomFieldGridMap2D_H
12 
14 #include <mrpt/utils/CImage.h>
16 #include <mrpt/math/CMatrixD.h>
18 #include <mrpt/utils/TEnumType.h>
19 #include <mrpt/maps/CMetricMap.h>
21 
22 #include <mrpt/maps/link_pragmas.h>
23 #if EIGEN_VERSION_AT_LEAST(3,1,0) // eigen 3.1+
24  #include <Eigen/SparseCore>
25  #include <Eigen/SparseCholesky>
26 #endif
27 
28 namespace mrpt
29 {
30 namespace maps
31 {
32  DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE_LINKAGE( CRandomFieldGridMap2D , CMetricMap, MAPS_IMPEXP )
33 
34  // Pragma defined to ensure no structure packing: since we'll serialize TRandomFieldCell to streams, we want it not to depend on compiler options, etc.
35 #if defined(MRPT_IS_X86_AMD64)
36 #pragma pack(push,1)
37 #endif
38 
39  /** The contents of each cell in a CRandomFieldGridMap2D map.
40  * \ingroup mrpt_maps_grp
41  **/
43  {
44  /** Constructor */
45  TRandomFieldCell(double kfmean_dm_mean = 1e-20, double kfstd_dmmeanw = 0) :
46  kf_mean (kfmean_dm_mean),
47  kf_std (kfstd_dmmeanw),
48  dmv_var_mean (0),
49  last_updated(mrpt::system::now()),
50  updated_std (kfstd_dmmeanw)
51  { }
52 
53  // *Note*: Use unions to share memory between data fields, since only a set
54  // of the variables will be used for each mapping strategy.
55  // You can access to a "TRandomFieldCell *cell" like: cell->kf_mean, cell->kf_std, etc..
56  // but accessing cell->kf_mean would also modify (i.e. ARE the same memory slot) cell->dm_mean, for example.
57 
58  // Note 2: If the number of type of fields are changed in the future,
59  // *PLEASE* also update the writeToStream() and readFromStream() methods!!
60 
61  union
62  {
63  double kf_mean; //!< [KF-methods only] The mean value of this cell
64  double dm_mean; //!< [Kernel-methods only] The cumulative weighted readings of this cell
65  double gmrf_mean; //!< [GMRF only] The mean value of this cell
66  };
67 
68  union
69  {
70  double kf_std; //!< [KF-methods only] The standard deviation value of this cell
71  double dm_mean_w; //!< [Kernel-methods only] The cumulative weights (concentration = alpha * dm_mean / dm_mean_w + (1-alpha)*r0 )
72  double gmrf_std;
73  };
74 
75  double dmv_var_mean; //!< [Kernel DM-V only] The cumulative weighted variance of this cell
76 
77  mrpt::system::TTimeStamp last_updated; //!< [Dynamic maps only] The timestamp of the last time the cell was updated
78  double updated_std; //!< [Dynamic maps only] The std cell value that was updated (to be used in the Forgetting_curve
79  };
80 
81 #if defined(MRPT_IS_X86_AMD64)
82 #pragma pack(pop)
83 #endif
84 
85  /** CRandomFieldGridMap2D represents a 2D grid map where each cell is associated one real-valued property which is estimated by this map, either
86  * as a simple value or as a probility distribution (for each cell).
87  *
88  * There are a number of methods available to build the gas grid-map, depending on the value of
89  * "TMapRepresentation maptype" passed in the constructor.
90  *
91  * The following papers describe the mapping alternatives implemented here:
92  * - mrKernelDM: A kernel-based method. See:
93  * - "Building gas concentration gridmaps with a mobile robot", Lilienthal, A. and Duckett, T., Robotics and Autonomous Systems, v.48, 2004.
94  * - mrKernelDMV: A kernel-based method. See:
95  * - "A Statistical Approach to Gas Distribution Modelling with Mobile Robots--The Kernel DM+ V Algorithm", Lilienthal, A.J. and Reggente, M. and Trincavelli, M. and Blanco, J.L. and Gonzalez, J., IROS 2009.
96  * - mrKalmanFilter: A "brute-force" approach to estimate the entire map with a dense (linear) Kalman filter. Will be very slow for mid or large maps. It's provided just for comparison purposes, not useful in practice.
97  * - mrKalmanApproximate: A compressed/sparse Kalman filter approach. See:
98  * - "A Kalman Filter Based Approach to Probabilistic Gas Distribution Mapping", JL Blanco, JG Monroy, J Gonzalez-Jimenez, A Lilienthal, 28th Symposium On Applied Computing (SAC), 2013.
99  * - mrGMRF: Time-Varying Gas Distribution Mapping with a Sparse MArkov Random Field estimator. See:
100  * - (under review)
101  *
102  * Note that this class is virtual, since derived classes still have to implement:
103  * - mrpt::maps::CMetricMap::internal_computeObservationLikelihood()
104  * - mrpt::maps::CMetricMap::internal_insertObservation()
105  * - Serialization methods: writeToStream() and readFromStream()
106  *
107  * \sa mrpt::maps::CGasConcentrationGridMap2D, mrpt::maps::CWirelessPowerGridMap2D, mrpt::maps::CMetricMap, mrpt::utils::CDynamicGrid, The application icp-slam, mrpt::maps::CMultiMetricMap
108  * \ingroup mrpt_maps_grp
109  */
110  class CRandomFieldGridMap2D : public mrpt::maps::CMetricMap, public utils::CDynamicGrid<TRandomFieldCell>
111  {
113 
114  // This must be added to any CSerializable derived class:
116  public:
117 
118  /** Calls the base CMetricMap::clear
119  * Declared here to avoid ambiguity between the two clear() in both base classes.
120  */
121  inline void clear() { CMetricMap::clear(); }
122 
123  // This method is just used for the ::saveToTextFile() method in base class.
124  float cell2float(const TRandomFieldCell& c) const
125  {
126  return c.kf_mean;
127  }
128 
129  /** The type of map representation to be used, see CRandomFieldGridMap2D for a discussion.
130  */
132  {
133  mrKernelDM = 0,
134  mrAchim = 0, //!< Another alias for "mrKernelDM", for backwards compatibility
140  mrGMRF_L
141  };
142 
143  /** Constructor
144  */
146  TMapRepresentation mapType = mrAchim,
147  float x_min = -2,
148  float x_max = 2,
149  float y_min = -2,
150  float y_max = 2,
151  float resolution = 0.1
152  );
153 
154  /** Destructor */
155  virtual ~CRandomFieldGridMap2D();
156 
157  /** Returns true if the map is empty/no observation has been inserted (in this class it always return false,
158  * unless redefined otherwise in base classes)
159  */
160  virtual bool isEmpty() const;
161 
162 
163  /** Save the current map as a graphical file (BMP,PNG,...).
164  * The file format will be derived from the file extension (see CImage::saveToFile )
165  * It depends on the map representation model:
166  * mrAchim: Each pixel is the ratio \f$ \sum{\frac{wR}{w}} \f$
167  * mrKalmanFilter: Each pixel is the mean value of the Gaussian that represents each cell.
168  *
169  * \sa \a getAsBitmapFile()
170  */
171  virtual void saveAsBitmapFile(const std::string &filName) const;
172 
173  /** Returns an image just as described in \a saveAsBitmapFile */
174  virtual void getAsBitmapFile(mrpt::utils::CImage &out_img) const;
175 
176  /** Parameters common to any derived class.
177  * Derived classes should derive a new struct from this one, plus "public utils::CLoadableOptions",
178  * and call the internal_* methods where appropiate to deal with the variables declared here.
179  * Derived classes instantions of their "TInsertionOptions" MUST set the pointer "m_insertOptions_common" upon construction.
180  */
182  {
183  TInsertionOptionsCommon(); //!< Default values loader
184 
185  /** See utils::CLoadableOptions */
186  void internal_loadFromConfigFile_common(
187  const mrpt::utils::CConfigFileBase &source,
188  const std::string &section);
189 
190  void internal_dumpToTextStream_common(mrpt::utils::CStream &out) const; //!< See utils::CLoadableOptions
191 
192  /** @name Kernel methods (mrKernelDM, mrKernelDMV)
193  @{ */
194  float sigma; //!< The sigma of the "Parzen"-kernel Gaussian
195  float cutoffRadius; //!< The cutoff radius for updating cells.
196  float R_min,R_max; //!< Limits for normalization of sensor readings.
197  double dm_sigma_omega; //!< [DM/DM+V methods] The scaling parameter for the confidence "alpha" values (see the IROS 2009 paper; see CRandomFieldGridMap2D) */
198  /** @} */
199 
200  /** @name Kalman-filter methods (mrKalmanFilter, mrKalmanApproximate)
201  @{ */
202  float KF_covSigma; //!< The "sigma" for the initial covariance value between cells (in meters).
203  float KF_initialCellStd; //!< The initial standard deviation of each cell's concentration (will be stored both at each cell's structure and in the covariance matrix as variances in the diagonal) (in normalized concentration units).
204  float KF_observationModelNoise; //!< The sensor model noise (in normalized concentration units).
205  float KF_defaultCellMeanValue; //!< The default value for the mean of cells' concentration.
206  uint16_t KF_W_size; //!< [mrKalmanApproximate] The size of the window of neighbor cells.
207  /** @} */
208 
209  /** @name Gaussian Markov Random Fields methods (mrGMRF_)
210  @{ */
211  float GMRF_lambdaPrior; //!< The information (Lambda) of fixed map constraints
212  float GMRF_lambdaObs; //!< The initial information (Lambda) of each observation (this information will decrease with time)
213  float GMRF_lambdaObsLoss; //!< The loss of information of the observations with each iteration
214 
215  bool GMRF_use_occupancy_information; //!< wether to use information of an occupancy_gridmap map for buidling the GMRF
216  std::string GMRF_simplemap_file; //!< simplemap_file name of the occupancy_gridmap
217  std::string GMRF_gridmap_image_file; //!< image name of the occupancy_gridmap
218  float GMRF_gridmap_image_res; //!< occupancy_gridmap resolution: size of each pixel (m)
219  size_t GMRF_gridmap_image_cx; //!< Pixel coordinates of the origin for the occupancy_gridmap
220  size_t GMRF_gridmap_image_cy; //!< Pixel coordinates of the origin for the occupancy_gridmap
221 
222  uint16_t GMRF_constraintsSize; //!< The size of the Gaussian window to impose fixed restrictions between cells.
223  float GMRF_constraintsSigma; //!< The sigma of the Gaussian window to impose fixed restrictions between cells.
224  /** @} */
225  };
226 
227  /** Changes the size of the grid, maintaining previous contents.
228  * \sa setSize
229  */
230  virtual void resize( float new_x_min,
231  float new_x_max,
232  float new_y_min,
233  float new_y_max,
234  const TRandomFieldCell& defaultValueNewCells,
235  float additionalMarginMeters = 1.0f );
236 
237  /** See docs in base class: in this class this always returns 0 */
238  float compute3DMatchingRatio(
239  const mrpt::maps::CMetricMap *otherMap,
240  const mrpt::poses::CPose3D &otherMapPose,
241  float maxDistForCorr = 0.10f,
242  float maxMahaDistForCorr = 2.0f
243  ) const;
244 
245 
246  /** The implementation in this class just calls all the corresponding method of the contained metric maps.
247  */
248  virtual void saveMetricMapRepresentationToFile(
249  const std::string &filNamePrefix
250  ) const;
251 
252  /** Save a matlab ".m" file which represents as 3D surfaces the mean and a given confidence level for the concentration of each cell.
253  * This method can only be called in a KF map model.
254  * \sa getAsMatlab3DGraphScript
255  */
256  virtual void saveAsMatlab3DGraph(const std::string &filName) const;
257 
258  /** Return a large text block with a MATLAB script to plot the contents of this map \sa saveAsMatlab3DGraph
259  * This method can only be called in a KF map model.
260  */
261  void getAsMatlab3DGraphScript(std::string &out_script) const;
262 
263  /** Returns a 3D object representing the map (mean).
264  */
265  virtual void getAs3DObject ( mrpt::opengl::CSetOfObjectsPtr &outObj ) const;
266 
267  /** Returns two 3D objects representing the mean and variance maps.
268  */
269  virtual void getAs3DObject ( mrpt::opengl::CSetOfObjectsPtr &meanObj, mrpt::opengl::CSetOfObjectsPtr &varObj ) const;
270 
271  /** Return the type of the random-field grid map, according to parameters passed on construction.
272  */
273  TMapRepresentation getMapType();
274 
275  /** Direct update of the map with a reading in a given position of the map, using
276  * the appropriate method according to mapType passed in the constructor.
277  *
278  * This is a direct way to update the map, an alternative to the generic insertObservation() method which works with mrpt::obs::CObservation objects.
279  */
280  void insertIndividualReading(const float sensorReading,const mrpt::math::TPoint2D & point);
281 
282  /** Returns the prediction of the measurement at some (x,y) coordinates, and its certainty (in the form of the expected variance).
283  * This methods is implemented differently for the different gas map types.
284  */
285  virtual void predictMeasurement(
286  const double &x,
287  const double &y,
288  double &out_predict_response,
289  double &out_predict_response_variance );
290 
291  /** Return the mean and covariance vector of the full Kalman filter estimate (works for all KF-based methods). */
292  void getMeanAndCov( mrpt::math::CVectorDouble &out_means, mrpt::math::CMatrixDouble &out_cov) const;
293 
294  /** Return the mean and STD vectors of the full Kalman filter estimate (works for all KF-based methods). */
295  void getMeanAndSTD( mrpt::math::CVectorDouble &out_means, mrpt::math::CVectorDouble &out_STD) const;
296 
297  /** Load the mean and STD vectors of the full Kalman filter estimate (works for all KF-based methods). */
298  void setMeanAndSTD( mrpt::math::CVectorDouble &out_means, mrpt::math::CVectorDouble &out_STD);
299 
300  protected:
301  /** Common options to all random-field grid maps: pointer that is set to the derived-class instance of "insertOptions" upon construction of this class. */
303 
304  /** Get the part of the options common to all CRandomFieldGridMap2D classes */
305  virtual CRandomFieldGridMap2D::TInsertionOptionsCommon* getCommonInsertOptions() = 0;
306 
307  /** The map representation type of this map, as passed in the constructor */
309 
310  mrpt::math::CMatrixD m_cov; //!< The whole covariance matrix, used for the Kalman Filter map representation.
311 
312  /** The compressed band diagonal matrix for the KF2 implementation.
313  * The format is a Nx(W^2+2W+1) matrix, one row per cell in the grid map with the
314  * cross-covariances between each cell and half of the window around it in the grid.
315  */
317  mutable bool m_hasToRecoverMeanAndCov; //!< Only for the KF2 implementation.
318 
319  /** @name Auxiliary vars for DM & DM+V methods
320  @{ */
322  std::vector<float> m_DM_gaussWindow;
323  double m_average_normreadings_mean, m_average_normreadings_var;
325  /** @} */
326 
327  /** @name Auxiliary vars for GMRF method
328  @{ */
329 #if EIGEN_VERSION_AT_LEAST(3,1,0)
330  std::vector<Eigen::Triplet<double> > H_prior; // the prior part of H
331 #endif
332  Eigen::VectorXd g; // Gradient vector
333  size_t nPriorFactors; // L
334  size_t nObsFactors; // M
335  size_t nFactors; // L+M
336  std::multimap<size_t,size_t> cell_interconnections; //Store the interconnections (relations) of each cell with its neighbourds
337 
338  std::vector<float> gauss_val; // For factor Weigths (only for mrGMRF_G)
339 
341  {
342  float obsValue;
343  float Lambda;
344  bool time_invariant; //if the observation will lose weight (lambda) as time goes on (default false)
345  };
346 
347  std::vector<std::vector<TobservationGMRF> > activeObs; //Vector with the active observations and their respective Information
348 
349 
350  /** @} */
351 
352  /** The implementation of "insertObservation" for Achim Lilienthal's map models DM & DM+V.
353  * \param normReading Is a [0,1] normalized concentration reading.
354  * \param point Is the sensor location on the map
355  * \param is_DMV = false -> map type is Kernel DM; true -> map type is DM+V
356  */
357  void insertObservation_KernelDM_DMV(
358  float normReading,
359  const mrpt::math::TPoint2D &point,
360  bool is_DMV );
361 
362  /** The implementation of "insertObservation" for the (whole) Kalman Filter map model.
363  * \param normReading Is a [0,1] normalized concentration reading.
364  * \param point Is the sensor location on the map
365  */
366  void insertObservation_KF(
367  float normReading,
368  const mrpt::math::TPoint2D &point );
369 
370  /** The implementation of "insertObservation" for the Efficient Kalman Filter map model.
371  * \param normReading Is a [0,1] normalized concentration reading.
372  * \param point Is the sensor location on the map
373  */
374  void insertObservation_KF2(
375  float normReading,
376  const mrpt::math::TPoint2D &point );
377 
378  /** The implementation of "insertObservation" for the Gaussian Markov Random Field map model.
379  * \param normReading Is a [0,1] normalized concentration reading.
380  * \param point Is the sensor location on the map
381  */
382  void insertObservation_GMRF(
383  float normReading,
384  const mrpt::math::TPoint2D &point );
385 
386  /** solves the minimum quadratic system to determine the new concentration of each cell */
387  void updateMapEstimation_GMRF();
388 
389  /** Computes the confidence of the cell concentration (alpha) */
390  double computeConfidenceCellValue_DM_DMV (const TRandomFieldCell *cell ) const;
391 
392  /** Computes the average cell concentration, or the overall average value if it has never been observed */
393  double computeMeanCellValue_DM_DMV (const TRandomFieldCell *cell ) const;
394 
395  /** Computes the estimated variance of the cell concentration, or the overall average variance if it has never been observed */
396  double computeVarCellValue_DM_DMV (const TRandomFieldCell *cell ) const;
397 
398  /** In the KF2 implementation, takes the auxiliary matrices and from them update the cells' mean and std values.
399  * \sa m_hasToRecoverMeanAndCov
400  */
401  void recoverMeanAndCov() const;
402 
403  /** Erase all the contents of the map */
404  virtual void internal_clear();
405 
406  /** Check if two cells of the gridmap (m_map) are connected, based on the provided occupancy gridmap*/
407  bool exist_relation_between2cells(
408  const mrpt::maps::COccupancyGridMap2D *m_Ocgridmap,
409  size_t cxo_min,
410  size_t cxo_max,
411  size_t cyo_min,
412  size_t cyo_max,
413  const size_t seed_cxo,
414  const size_t seed_cyo,
415  const size_t objective_cxo,
416  const size_t objective_cyo);
417  };
419 
420 
421  } // End of namespace
422 
423 
424  // Specializations MUST occur at the same namespace:
425  namespace utils
426  {
427  template <>
429  {
431  static void fill(bimap<enum_t,std::string> &m_map)
432  {
433  m_map.insert(maps::CRandomFieldGridMap2D::mrKernelDM, "mrKernelDM");
434  m_map.insert(maps::CRandomFieldGridMap2D::mrKalmanFilter, "mrKalmanFilter");
435  m_map.insert(maps::CRandomFieldGridMap2D::mrKalmanApproximate, "mrKalmanApproximate");
436  m_map.insert(maps::CRandomFieldGridMap2D::mrKernelDMV, "mrKernelDMV");
440  }
441  };
442  } // End of namespace
443 } // End of namespace
444 
445 #endif
std::multimap< size_t, size_t > cell_interconnections
uint64_t TTimeStamp
A system independent time type, it holds the the number of 100-nanosecond intervals since January 1...
Definition: datetime.h:30
std::string GMRF_gridmap_image_file
image name of the occupancy_gridmap
float sigma
The sigma of the "Parzen"-kernel Gaussian.
This class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>".
Definition: CMatrixD.h:30
float KF_defaultCellMeanValue
The default value for the mean of cells&#39; concentration.
A class for storing images as grayscale or RGB bitmaps.
Definition: CImage.h:101
uint16_t GMRF_constraintsSize
The size of the Gaussian window to impose fixed restrictions between cells.
float GMRF_lambdaObsLoss
The loss of information of the observations with each iteration.
void clear()
Erase all the contents of the map.
mrpt::math::CMatrixD m_cov
The whole covariance matrix, used for the Kalman Filter map representation.
Column vector, like Eigen::MatrixX*, but automatically initialized to zeros since construction...
Definition: eigen_frwds.h:35
mrpt::system::TTimeStamp now()
A shortcut for system::getCurrentTime.
Definition: datetime.h:70
mrpt::system::TTimeStamp last_updated
[Dynamic maps only] The timestamp of the last time the cell was updated
TMapRepresentation
The type of map representation to be used, see CRandomFieldGridMap2D for a discussion.
double gmrf_mean
[GMRF only] The mean value of this cell
Only specializations of this class are defined for each enum type of interest.
Definition: TEnumType.h:23
This class allows loading and storing values and vectors of different types from a configuration text...
#define DEFINE_VIRTUAL_SERIALIZABLE(class_name)
This declaration must be inserted in virtual CSerializable classes definition:
TMapRepresentation m_mapType
The map representation type of this map, as passed in the constructor.
double dm_mean_w
[Kernel-methods only] The cumulative weights (concentration = alpha * dm_mean / dm_mean_w + (1-alpha)...
float KF_observationModelNoise
The sensor model noise (in normalized concentration units).
TInsertionOptionsCommon * m_insertOptions_common
Common options to all random-field grid maps: pointer that is set to the derived-class instance of "i...
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition: CStream.h:38
TRandomFieldCell(double kfmean_dm_mean=1e-20, double kfstd_dmmeanw=0)
Constructor.
A 2D grid of dynamic size which stores any kind of data at each cell.
Definition: CDynamicGrid.h:39
#define DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_)
This declaration must be inserted in all CSerializable classes definition, before the class declarati...
double kf_mean
[KF-methods only] The mean value of this cell
The contents of each cell in a CRandomFieldGridMap2D map.
A bidirectional version of std::map, declared as bimap<KEY,VALUE> and which actually contains two std...
Definition: bimap.h:28
double dm_sigma_omega
[DM/DM+V methods] The scaling parameter for the confidence "alpha" values (see the IROS 2009 paper; s...
float GMRF_lambdaObs
The initial information (Lambda) of each observation (this information will decrease with time) ...
bool m_hasToRecoverMeanAndCov
Only for the KF2 implementation.
float GMRF_gridmap_image_res
occupancy_gridmap resolution: size of each pixel (m)
double updated_std
[Dynamic maps only] The std cell value that was updated (to be used in the Forgetting_curve ...
A class for storing an occupancy grid map.
float GMRF_lambdaPrior
The information (Lambda) of fixed map constraints.
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
CRandomFieldGridMap2D represents a 2D grid map where each cell is associated one real-valued property...
float KF_covSigma
The "sigma" for the initial covariance value between cells (in meters).
Declares a virtual base class for all metric maps storage classes.
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:72
double dmv_var_mean
[Kernel DM-V only] The cumulative weighted variance of this cell
bool GMRF_use_occupancy_information
wether to use information of an occupancy_gridmap map for buidling the GMRF
std::string GMRF_simplemap_file
simplemap_file name of the occupancy_gridmap
uint16_t KF_W_size
[mrKalmanApproximate] The size of the window of neighbor cells.
float GMRF_constraintsSigma
The sigma of the Gaussian window to impose fixed restrictions between cells.
mrpt::math::CMatrixD m_stackedCov
The compressed band diagonal matrix for the KF2 implementation.
void insert(const KEY &k, const VALUE &v)
Insert a new pair KEY<->VALUE in the bi-map.
Definition: bimap.h:69
double dm_mean
[Kernel-methods only] The cumulative weighted readings of this cell
size_t GMRF_gridmap_image_cx
Pixel coordinates of the origin for the occupancy_gridmap.
#define DEFINE_SERIALIZABLE_POST_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_)
Lightweight 2D point.
float cell2float(const TRandomFieldCell &c) const
float KF_initialCellStd
The initial standard deviation of each cell&#39;s concentration (will be stored both at each cell&#39;s struc...
size_t GMRF_gridmap_image_cy
Pixel coordinates of the origin for the occupancy_gridmap.
utils::CDynamicGrid< TRandomFieldCell > BASE
double kf_std
[KF-methods only] The standard deviation value of this cell
std::vector< std::vector< TobservationGMRF > > activeObs



Page generated by Doxygen 1.8.12 for MRPT 1.3.2 SVN: at Thu Nov 10 13:22:34 UTC 2016