MRPT  1.9.9
CRandomFieldGridMap2D.h
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #pragma once
11 
15 #include <mrpt/img/CImage.h>
16 #include <mrpt/maps/CMetricMap.h>
17 #include <mrpt/math/CMatrixD.h>
20 
21 #include <list>
22 
23 namespace mrpt::maps
24 {
25 class COccupancyGridMap2D;
26 
27 // Pragma defined to ensure no structure packing: since we'll serialize
28 // TRandomFieldCell to streams, we want it not to depend on compiler options,
29 // etc.
30 #if defined(MRPT_IS_X86_AMD64)
31 #pragma pack(push, 1)
32 #endif
33 
34 /** The contents of each cell in a CRandomFieldGridMap2D map.
35  * \ingroup mrpt_maps_grp
36  **/
38 {
39  /** Constructor */
40  TRandomFieldCell(double kfmean_dm_mean = 1e-20, double kfstd_dmmeanw = 0)
41  : kf_mean(kfmean_dm_mean),
42  kf_std(kfstd_dmmeanw),
43  last_updated(mrpt::system::now()),
44  updated_std(kfstd_dmmeanw)
45  {
46  }
47 
48  // *Note*: Use unions to share memory between data fields, since only a set
49  // of the variables will be used for each mapping strategy.
50  // You can access to a "TRandomFieldCell *cell" like: cell->kf_mean,
51  // cell->kf_std, etc..
52  // but accessing cell->kf_mean would also modify (i.e. ARE the same memory
53  // slot) cell->dm_mean, for example.
54 
55  // Note 2: If the number of type of fields are changed in the future,
56  // *PLEASE* also update the writeToStream() and readFromStream() methods!!
57 
58  union {
59  /** [KF-methods only] The mean value of this cell */
60  double kf_mean;
61  /** [Kernel-methods only] The cumulative weighted readings of this cell
62  */
63  double dm_mean;
64  /** [GMRF only] The mean value of this cell */
65  double gmrf_mean;
66  };
67 
68  union {
69  /** [KF-methods only] The standard deviation value of this cell */
70  double kf_std;
71  /** [Kernel-methods only] The cumulative weights (concentration = alpha
72  * * dm_mean / dm_mean_w + (1-alpha)*r0 ) */
73  double dm_mean_w;
74  double gmrf_std;
75  };
76 
77  /** [Kernel DM-V only] The cumulative weighted variance of this cell */
78  double dmv_var_mean{0};
79 
80  /** [Dynamic maps only] The timestamp of the last time the cell was updated
81  */
83  /** [Dynamic maps only] The std cell value that was updated (to be used in
84  * the Forgetting_curve */
85  double updated_std;
86 };
87 
88 #if defined(MRPT_IS_X86_AMD64)
89 #pragma pack(pop)
90 #endif
91 
92 /** CRandomFieldGridMap2D represents a 2D grid map where each cell is associated
93  *one real-valued property which is estimated by this map, either
94  * as a simple value or as a probility distribution (for each cell).
95  *
96  * There are a number of methods available to build the MRF grid-map,
97  *depending on the value of
98  * `TMapRepresentation maptype` passed in the constructor.
99  *
100  * The following papers describe the mapping alternatives implemented here:
101  * - `mrKernelDM`: A Gaussian kernel-based method. See:
102  * - "Building gas concentration gridmaps with a mobile robot",
103  *Lilienthal,
104  *A. and Duckett, T., Robotics and Autonomous Systems, v.48, 2004.
105  * - `mrKernelDMV`: A kernel-based method. See:
106  * - "A Statistical Approach to Gas Distribution Modelling with Mobile
107  *Robots--The Kernel DM+ V Algorithm", Lilienthal, A.J. and Reggente, M. and
108  *Trincavelli, M. and Blanco, J.L. and Gonzalez, J., IROS 2009.
109  * - `mrKalmanFilter`: A "brute-force" approach to estimate the entire map
110  *with a dense (linear) Kalman filter. Will be very slow for mid or large maps.
111  *It's provided just for comparison purposes, not useful in practice.
112  * - `mrKalmanApproximate`: A compressed/sparse Kalman filter approach.
113  *See:
114  * - "A Kalman Filter Based Approach to Probabilistic Gas Distribution
115  *Mapping", JL Blanco, JG Monroy, J Gonzalez-Jimenez, A Lilienthal, 28th
116  *Symposium On Applied Computing (SAC), 2013.
117  * - `mrGMRF_SD`: A Gaussian Markov Random Field (GMRF) estimator, with
118  *these
119  *constraints:
120  * - `mrGMRF_SD`: Each cell only connected to its 4 immediate neighbors
121  *(Up,
122  *down, left, right).
123  * - (Removed in MRPT 1.5.0: `mrGMRF_G`: Each cell connected to a
124  *square
125  *area
126  *of neighbors cells)
127  * - See papers:
128  * - "Time-variant gas distribution mapping with obstacle
129  *information",
130  *Monroy, J. G., Blanco, J. L., & Gonzalez-Jimenez, J. Autonomous Robots,
131  *40(1), 1-16, 2016.
132  *
133  * Note that this class is virtual, since derived classes still have to
134  *implement:
135  * - mrpt::maps::CMetricMap::internal_computeObservationLikelihood()
136  * - mrpt::maps::CMetricMap::internal_insertObservation()
137  * - Serialization methods: writeToStream() and readFromStream()
138  *
139  * [GMRF only] A custom connectivity pattern between cells can be defined by
140  *calling setCellsConnectivity().
141  *
142  * \sa mrpt::maps::CGasConcentrationGridMap2D,
143  *mrpt::maps::CWirelessPowerGridMap2D, mrpt::maps::CMetricMap,
144  *mrpt::containers::CDynamicGrid, The application icp-slam,
145  *mrpt::maps::CMultiMetricMap
146  * \ingroup mrpt_maps_grp
147  */
149  : public mrpt::maps::CMetricMap,
150  public mrpt::containers::CDynamicGrid<TRandomFieldCell>,
152 {
154 
156  public:
157  /** Calls the base CMetricMap::clear
158  * Declared here to avoid ambiguity between the two clear() in both base
159  * classes.
160  */
161  inline void clear() { CMetricMap::clear(); }
162  // This method is just used for the ::saveToTextFile() method in base class.
163  float cell2float(const TRandomFieldCell& c) const override
164  {
165  return c.kf_mean;
166  }
167 
168  /** The type of map representation to be used, see CRandomFieldGridMap2D for
169  * a discussion.
170  */
172  {
173  /** Gaussian kernel-based estimator (see discussion in
174  mrpt::maps::CRandomFieldGridMap2D) */
176  /** Another alias for "mrKernelDM", for backwards compatibility (see
177  discussion in mrpt::maps::CRandomFieldGridMap2D) */
178  mrAchim = 0,
179  /** "Brute-force" Kalman filter (see discussion in
180  mrpt::maps::CRandomFieldGridMap2D) */
182  /** (see discussion in mrpt::maps::CRandomFieldGridMap2D) */
184  /** Double mean + variance Gaussian kernel-based estimator (see
185  discussion in mrpt::maps::CRandomFieldGridMap2D) */
187  // Removed in MRPT 1.5.0: mrGMRF_G, //!< Gaussian Markov Random Field,
188  // Gaussian prior weights between neighboring cells up to a certain
189  // distance (see discussion in mrpt::maps::CRandomFieldGridMap2D)
190  /** Gaussian Markov Random Field, squared differences prior weights
191  between 4 neighboring cells (see discussion in
192  mrpt::maps::CRandomFieldGridMap2D) */
194  };
195 
196  /** Constructor */
198  TMapRepresentation mapType = mrKernelDM, double x_min = -2,
199  double x_max = 2, double y_min = -2, double y_max = 2,
200  double resolution = 0.1);
201 
202  /** Destructor */
203  ~CRandomFieldGridMap2D() override;
204 
205  /** Returns true if the map is empty/no observation has been inserted (in
206  * this class it always return false,
207  * unless redefined otherwise in base classes)
208  */
209  bool isEmpty() const override;
210 
211  /** Save the current map as a graphical file (BMP,PNG,...).
212  * The file format will be derived from the file extension (see
213  *CImage::saveToFile )
214  * It depends on the map representation model:
215  * mrAchim: Each pixel is the ratio \f$ \sum{\frac{wR}{w}} \f$
216  * mrKalmanFilter: Each pixel is the mean value of the Gaussian that
217  *represents each cell.
218  *
219  * \sa \a getAsBitmapFile()
220  */
221  virtual void saveAsBitmapFile(const std::string& filName) const;
222 
223  /** Returns an image just as described in \a saveAsBitmapFile */
224  virtual void getAsBitmapFile(mrpt::img::CImage& out_img) const;
225 
226  /** Like saveAsBitmapFile(), but returns the data in matrix form (first row
227  * in the matrix is the upper (y_max) part of the map) */
228  virtual void getAsMatrix(mrpt::math::CMatrixDouble& out_mat) const;
229 
230  /** Parameters common to any derived class.
231  * Derived classes should derive a new struct from this one, plus "public
232  * utils::CLoadableOptions",
233  * and call the internal_* methods where appropiate to deal with the
234  * variables declared here.
235  * Derived classes instantions of their "TInsertionOptions" MUST set the
236  * pointer "m_insertOptions_common" upon construction.
237  */
239  {
240  /** Default values loader */
242 
243  /** See utils::CLoadableOptions */
246  const std::string& section);
247 
248  /** See utils::CLoadableOptions */
249  void internal_dumpToTextStream_common(std::ostream& out) const;
250 
251  /** @name Kernel methods (mrKernelDM, mrKernelDMV)
252  @{ */
253  /** The sigma of the "Parzen"-kernel Gaussian */
254  float sigma{0.15f};
255  /** The cutoff radius for updating cells. */
257  /** Limits for normalization of sensor readings. */
258  float R_min{0}, R_max{3};
259  /** [DM/DM+V methods] The scaling parameter for the confidence "alpha"
260  * values (see the IROS 2009 paper; see CRandomFieldGridMap2D) */
261  double dm_sigma_omega{0.05};
262  /** @} */
263 
264  /** @name Kalman-filter methods (mrKalmanFilter, mrKalmanApproximate)
265  @{ */
266  /** The "sigma" for the initial covariance value between cells (in
267  * meters). */
268  float KF_covSigma{0.35f};
269  /** The initial standard deviation of each cell's concentration (will be
270  * stored both at each cell's structure and in the covariance matrix as
271  * variances in the diagonal) (in normalized concentration units). */
272  float KF_initialCellStd{1.0};
273  /** The sensor model noise (in normalized concentration units). */
275  /** The default value for the mean of cells' concentration. */
277  /** [mrKalmanApproximate] The size of the window of neighbor cells. */
279  /** @} */
280 
281  /** @name Gaussian Markov Random Fields methods (mrGMRF_SD)
282  @{ */
283  /** The information (Lambda) of fixed map constraints */
284  double GMRF_lambdaPrior{0.01f};
285  /** The initial information (Lambda) of each observation (this
286  * information will decrease with time) */
287  double GMRF_lambdaObs{10.0f};
288  /** The loss of information of the observations with each iteration */
289  double GMRF_lambdaObsLoss{0.0f};
290 
291  /** whether to use information of an occupancy_gridmap map for building
292  * the GMRF */
294  /** simplemap_file name of the occupancy_gridmap */
296  /** image name of the occupancy_gridmap */
298  /** occupancy_gridmap resolution: size of each pixel (m) */
299  double GMRF_gridmap_image_res{0.01f};
300  /** Pixel coordinates of the origin for the occupancy_gridmap */
302  /** Pixel coordinates of the origin for the occupancy_gridmap */
304 
305  /** (Default:-inf,+inf) Saturate the estimated mean in these limits */
307  /** (Default:false) Skip the computation of the variance, just compute
308  * the mean */
309  bool GMRF_skip_variance{false};
310  /** @} */
311  };
312 
313  /** Changes the size of the grid, maintaining previous contents. \sa setSize
314  */
315  void resize(
316  double new_x_min, double new_x_max, double new_y_min, double new_y_max,
317  const TRandomFieldCell& defaultValueNewCells,
318  double additionalMarginMeters = 1.0f) override;
319 
320  /** Changes the size of the grid, erasing previous contents.
321  * \param[in] connectivity_descriptor Optional user-supplied object that
322  * will visit all grid cells to define their connectivity with neighbors and
323  * the strength of existing edges. If present, it overrides all options in
324  * insertionOptions
325  * \sa resize
326  */
327  virtual void setSize(
328  const double x_min, const double x_max, const double y_min,
329  const double y_max, const double resolution,
330  const TRandomFieldCell* fill_value = nullptr);
331 
332  /** Base class for user-supplied objects capable of describing cells
333  * connectivity, used to build prior factors of the MRF graph. \sa
334  * setCellsConnectivity() */
336  {
339  virtual ~ConnectivityDescriptor();
340 
341  /** Implement the check of whether node i=(icx,icy) is connected with
342  * node j=(jcx,jcy).
343  * This visitor method will be called only for immediate neighbors.
344  * \return true if connected (and the "information" value should be
345  * also updated in out_edge_information), false otherwise.
346  */
347  virtual bool getEdgeInformation(
348  /** The parent map on which we are running */
349  const CRandomFieldGridMap2D* parent,
350  /** (cx,cy) for node "i" */
351  size_t icx, size_t icy,
352  /** (cx,cy) for node "j" */
353  size_t jcx, size_t jcy,
354  /** Must output here the inverse of the variance of the constraint
355  edge. */
356  double& out_edge_information) = 0;
357  };
358 
359  /** Sets a custom object to define the connectivity between cells. Must call
360  * clear() or setSize() afterwards for the changes to take place. */
362  const ConnectivityDescriptor::Ptr& new_connectivity_descriptor);
363 
364  /** See docs in base class: in this class this always returns 0 */
366  const mrpt::maps::CMetricMap* otherMap,
367  const mrpt::poses::CPose3D& otherMapPose,
368  const TMatchingRatioParams& params) const override;
369 
370  /** The implementation in this class just calls all the corresponding method
371  * of the contained metric maps */
373  const std::string& filNamePrefix) const override;
374 
375  /** Save a matlab ".m" file which represents as 3D surfaces the mean and a
376  * given confidence level for the concentration of each cell.
377  * This method can only be called in a KF map model.
378  * \sa getAsMatlab3DGraphScript */
379  virtual void saveAsMatlab3DGraph(const std::string& filName) const;
380 
381  /** Return a large text block with a MATLAB script to plot the contents of
382  * this map \sa saveAsMatlab3DGraph
383  * This method can only be called in a KF map model */
384  void getAsMatlab3DGraphScript(std::string& out_script) const;
385 
386  /** Returns a 3D object representing the map (mean) */
387  void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr& outObj) const override;
388 
389  /** Returns two 3D objects representing the mean and variance maps */
390  virtual void getAs3DObject(
392  mrpt::opengl::CSetOfObjects::Ptr& varObj) const;
393 
394  /** Return the type of the random-field grid map, according to parameters
395  * passed on construction. */
397 
398  /** Direct update of the map with a reading in a given position of the map,
399  * using
400  * the appropriate method according to mapType passed in the constructor.
401  *
402  * This is a direct way to update the map, an alternative to the generic
403  * insertObservation() method which works with mrpt::obs::CObservation
404  * objects.
405  */
407  /** [in] The value observed in the (x,y) position */
408  const double sensorReading,
409  /** [in] The (x,y) location */
410  const mrpt::math::TPoint2D& point,
411  /** [in] Run a global map update after inserting this observatin
412  (algorithm-dependant) */
413  const bool update_map = true,
414  /** [in] Whether the observation "vanishes" with time (false) or not
415  (true) [Only for GMRF methods] */
416  const bool time_invariant = true,
417  /** [in] The uncertainty (standard deviation) of the reading.
418  Default="0.0" means use the default settings per map-wide parameters.
419  */
420  const double reading_stddev = .0);
421 
423  {
426  };
427 
428  /** Returns the prediction of the measurement at some (x,y) coordinates, and
429  * its certainty (in the form of the expected variance). */
430  virtual void predictMeasurement(
431  /** [in] Query X coordinate */
432  const double x,
433  /** [in] Query Y coordinate */
434  const double y,
435  /** [out] The output value */
436  double& out_predict_response,
437  /** [out] The output variance */
438  double& out_predict_response_variance,
439  /** [in] Whether to renormalize the prediction to a predefined
440  interval (`R` values in insertionOptions) */
441  bool do_sensor_normalization,
442  /** [in] Interpolation method */
443  const TGridInterpolationMethod interp_method = gimNearest);
444 
445  /** Return the mean and covariance vector of the full Kalman filter estimate
446  * (works for all KF-based methods). */
447  void getMeanAndCov(
448  mrpt::math::CVectorDouble& out_means,
449  mrpt::math::CMatrixDouble& out_cov) const;
450 
451  /** Return the mean and STD vectors of the full Kalman filter estimate
452  * (works for all KF-based methods). */
453  void getMeanAndSTD(
454  mrpt::math::CVectorDouble& out_means,
455  mrpt::math::CVectorDouble& out_STD) const;
456 
457  /** Load the mean and STD vectors of the full Kalman filter estimate (works
458  * for all KF-based methods). */
459  void setMeanAndSTD(
460  mrpt::math::CVectorDouble& out_means,
461  mrpt::math::CVectorDouble& out_STD);
462 
463  /** Run the method-specific procedure required to ensure that the mean &
464  * variances are up-to-date with all inserted observations. */
465  void updateMapEstimation();
466 
467  void enableVerbose(bool enable_verbose)
468  {
470  }
471  bool isEnabledVerbose() const
472  {
474  }
475 
476  void enableProfiler(bool enable = true)
477  {
478  this->m_gmrf.enableProfiler(enable);
479  }
480  bool isProfilerEnabled() const { return this->m_gmrf.isProfilerEnabled(); }
481 
482  protected:
484 
485  /** Common options to all random-field grid maps: pointer that is set to the
486  * derived-class instance of "insertOptions" upon construction of this
487  * class. */
489 
490  /** Get the part of the options common to all CRandomFieldGridMap2D classes
491  */
494 
495  /** The map representation type of this map, as passed in the constructor */
497 
498  /** The whole covariance matrix, used for the Kalman Filter map
499  * representation. */
501 
502  /** The compressed band diagonal matrix for the KF2 implementation.
503  * The format is a Nx(W^2+2W+1) matrix, one row per cell in the grid map
504  * with the
505  * cross-covariances between each cell and half of the window around it
506  * in the grid.
507  */
509  /** Only for the KF2 implementation. */
510  mutable bool m_hasToRecoverMeanAndCov{true};
511 
512  /** @name Auxiliary vars for DM & DM+V methods
513  @{ */
514  float m_DM_lastCutOff{0};
515  std::vector<float> m_DM_gaussWindow;
518  /** @} */
519 
520  /** Empty: default */
522 
524 
527  {
528  /** Observation value */
529  double obsValue;
530  /** "Information" of the observation (=inverse of the variance) */
531  double Lambda;
532  /** whether the observation will lose weight (lambda) as time goes on
533  * (default false) */
535 
536  double evaluateResidual() const override;
537  double getInformation() const override;
538  void evalJacobian(double& dr_dx) const override;
539 
541  : obsValue(.0), Lambda(.0), time_invariant(false), m_parent(&parent)
542  {
543  }
544 
545  private:
547  };
548 
551  {
552  /** "Information" of the observation (=inverse of the variance) */
553  double Lambda;
554 
555  double evaluateResidual() const override;
556  double getInformation() const override;
557  void evalJacobian(double& dr_dx_i, double& dr_dx_j) const override;
558 
560  : Lambda(.0), m_parent(&parent)
561  {
562  }
563 
564  private:
566  };
567 
568  // Important: converted to a std::list<> so pointers are NOT invalidated
569  // upon deletion.
570  /** Vector with the active observations and their respective Information */
571  std::vector<std::list<TObservationGMRF>> m_mrf_factors_activeObs;
572  /** Vector with the precomputed priors for each GMRF model */
573  std::deque<TPriorFactorGMRF> m_mrf_factors_priors;
574 
575  /** The implementation of "insertObservation" for Achim Lilienthal's map
576  * models DM & DM+V.
577  * \param normReading Is a [0,1] normalized concentration reading.
578  * \param point Is the sensor location on the map
579  * \param is_DMV = false -> map type is Kernel DM; true -> map type is DM+V
580  */
582  double normReading, const mrpt::math::TPoint2D& point, bool is_DMV);
583 
584  /** The implementation of "insertObservation" for the (whole) Kalman Filter
585  * map model.
586  * \param normReading Is a [0,1] normalized concentration reading.
587  * \param point Is the sensor location on the map
588  */
590  double normReading, const mrpt::math::TPoint2D& point);
591 
592  /** The implementation of "insertObservation" for the Efficient Kalman
593  * Filter map model.
594  * \param normReading Is a [0,1] normalized concentration reading.
595  * \param point Is the sensor location on the map
596  */
598  double normReading, const mrpt::math::TPoint2D& point);
599 
600  /** The implementation of "insertObservation" for the Gaussian Markov Random
601  * Field map model.
602  * \param normReading Is a [0,1] normalized concentration reading.
603  * \param point Is the sensor location on the map
604  */
606  double normReading, const mrpt::math::TPoint2D& point,
607  const bool update_map, const bool time_invariant,
608  const double reading_information);
609 
610  /** solves the minimum quadratic system to determine the new concentration
611  * of each cell */
613 
614  /** Computes the confidence of the cell concentration (alpha) */
616  const TRandomFieldCell* cell) const;
617 
618  /** Computes the average cell concentration, or the overall average value if
619  * it has never been observed */
620  double computeMeanCellValue_DM_DMV(const TRandomFieldCell* cell) const;
621 
622  /** Computes the estimated variance of the cell concentration, or the
623  * overall average variance if it has never been observed */
624  double computeVarCellValue_DM_DMV(const TRandomFieldCell* cell) const;
625 
626  /** In the KF2 implementation, takes the auxiliary matrices and from them
627  * update the cells' mean and std values.
628  * \sa m_hasToRecoverMeanAndCov
629  */
630  void recoverMeanAndCov() const;
631 
632  /** Erase all the contents of the map */
633  void internal_clear() override;
634 
635  /** Check if two cells of the gridmap (m_map) are connected, based on the
636  * provided occupancy gridmap*/
638  const mrpt::maps::COccupancyGridMap2D* m_Ocgridmap, size_t cxo_min,
639  size_t cxo_max, size_t cyo_min, size_t cyo_max, const size_t seed_cxo,
640  const size_t seed_cyo, const size_t objective_cxo,
641  const size_t objective_cyo);
642 };
643 
644 } // namespace mrpt::maps
void clear()
Erase all the contents of the map.
Definition: CMetricMap.cpp:30
Simple, scalar (1-dim) constraint (edge) for a GMRF.
std::string GMRF_gridmap_image_file
image name of the occupancy_gridmap
Gaussian kernel-based estimator (see discussion in mrpt::maps::CRandomFieldGridMap2D) ...
Parameters for CMetricMap::compute3DMatchingRatio()
float sigma
The sigma of the "Parzen"-kernel Gaussian.
void getMeanAndSTD(mrpt::math::CVectorDouble &out_means, mrpt::math::CVectorDouble &out_STD) const
Return the mean and STD vectors of the full Kalman filter estimate (works for all KF-based methods)...
A 2D grid of dynamic size which stores any kind of data at each cell.
Definition: CDynamicGrid.h:38
void clear()
Calls the base CMetricMap::clear Declared here to avoid ambiguity between the two clear() in both bas...
double evaluateResidual() const override
Return the residual/error of this observation.
This class is a "CSerializable" wrapper for "CMatrixDynamic<double>".
Definition: CMatrixD.h:23
unsigned __int16 uint16_t
Definition: rptypes.h:47
virtual void saveAsMatlab3DGraph(const std::string &filName) const
Save a matlab ".m" file which represents as 3D surfaces the mean and a given confidence level for the...
float KF_defaultCellMeanValue
The default value for the mean of cells&#39; concentration.
double getInformation() const override
Return the inverse of the variance of this constraint.
bool exist_relation_between2cells(const mrpt::maps::COccupancyGridMap2D *m_Ocgridmap, size_t cxo_min, size_t cxo_max, size_t cyo_min, size_t cyo_max, const size_t seed_cxo, const size_t seed_cyo, const size_t objective_cxo, const size_t objective_cyo)
Check if two cells of the gridmap (m_map) are connected, based on the provided occupancy gridmap...
Base class for user-supplied objects capable of describing cells connectivity, used to build prior fa...
void insertObservation_GMRF(double normReading, const mrpt::math::TPoint2D &point, const bool update_map, const bool time_invariant, const double reading_information)
The implementation of "insertObservation" for the Gaussian Markov Random Field map model...
void evalJacobian(double &dr_dx_i, double &dr_dx_j) const override
Returns the derivative of the residual wrt the node values.
std::vector< std::list< TObservationGMRF > > m_mrf_factors_activeObs
Vector with the active observations and their respective Information.
mrpt::math::CMatrixD m_cov
The whole covariance matrix, used for the Kalman Filter map representation.
void setMinLoggingLevel(const VerbosityLevel level)
Set the minimum logging level for which the incoming logs are going to be taken into account...
mrpt::system::TTimeStamp now()
A shortcut for system::getCurrentTime.
Definition: datetime.h:86
double Lambda
"Information" of the observation (=inverse of the variance)
mrpt::system::TTimeStamp last_updated
[Dynamic maps only] The timestamp of the last time the cell was updated
Double mean + variance Gaussian kernel-based estimator (see discussion in mrpt::maps::CRandomFieldGri...
TMapRepresentation
The type of map representation to be used, see CRandomFieldGridMap2D for a discussion.
void getMeanAndCov(mrpt::math::CVectorDouble &out_means, mrpt::math::CMatrixDouble &out_cov) const
Return the mean and covariance vector of the full Kalman filter estimate (works for all KF-based meth...
double gmrf_mean
[GMRF only] The mean value of this cell
double GMRF_lambdaPrior
The information (Lambda) of fixed map constraints.
float cutoffRadius
The cutoff radius for updating cells.
void enableVerbose(bool enable_verbose)
Another alias for "mrKernelDM", for backwards compatibility (see discussion in mrpt::maps::CRandomFie...
TMapRepresentation getMapType()
Return the type of the random-field grid map, according to parameters passed on construction.
void enableProfiler(bool enable=true)
void evalJacobian(double &dr_dx) const override
Returns the derivative of the residual wrt the node value.
void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr &outObj) const override
Returns a 3D object representing the map (mean)
double computeMeanCellValue_DM_DMV(const TRandomFieldCell *cell) const
Computes the average cell concentration, or the overall average value if it has never been observed...
virtual bool getEdgeInformation(const CRandomFieldGridMap2D *parent, size_t icx, size_t icy, size_t jcx, size_t jcy, double &out_edge_information)=0
Implement the check of whether node i=(icx,icy) is connected with node j=(jcx,jcy).
void recoverMeanAndCov() const
In the KF2 implementation, takes the auxiliary matrices and from them update the cells&#39; mean and std ...
#define DEFINE_VIRTUAL_SERIALIZABLE(class_name)
This declaration must be inserted in virtual CSerializable classes definition:
void internal_dumpToTextStream_common(std::ostream &out) const
See utils::CLoadableOptions.
TMapRepresentation m_mapType
The map representation type of this map, as passed in the constructor.
mrpt::graphs::ScalarFactorGraph m_gmrf
CRandomFieldGridMap2D(TMapRepresentation mapType=mrKernelDM, double x_min=-2, double x_max=2, double y_min=-2, double y_max=2, double resolution=0.1)
Constructor.
double dm_mean_w
[Kernel-methods only] The cumulative weights (concentration = alpha
double getInformation() const override
Return the inverse of the variance of this constraint.
float KF_observationModelNoise
The sensor model noise (in normalized concentration units).
~CRandomFieldGridMap2D() override
Destructor.
VerbosityLevel getMinLoggingLevel() const
TInsertionOptionsCommon * m_insertOptions_common
Common options to all random-field grid maps: pointer that is set to the derived-class instance of "i...
mrpt::Clock::time_point TTimeStamp
A system independent time type, it holds the the number of 100-nanosecond intervals since January 1...
Definition: datetime.h:40
bool time_invariant
whether the observation will lose weight (lambda) as time goes on (default false) ...
float R_min
Limits for normalization of sensor readings.
virtual void saveAsBitmapFile(const std::string &filName) const
Save the current map as a graphical file (BMP,PNG,...).
TRandomFieldCell(double kfmean_dm_mean=1e-20, double kfstd_dmmeanw=0)
Constructor.
This class allows loading and storing values and vectors of different types from a configuration text...
bool isEmpty() const override
Returns true if the map is empty/no observation has been inserted (in this class it always return fal...
void resize(double new_x_min, double new_x_max, double new_y_min, double new_y_max, const TRandomFieldCell &defaultValueNewCells, double additionalMarginMeters=1.0f) override
Changes the size of the grid, maintaining previous contents.
void updateMapEstimation_GMRF()
solves the minimum quadratic system to determine the new concentration of each cell ...
double kf_mean
[KF-methods only] The mean value of this cell
The contents of each cell in a CRandomFieldGridMap2D map.
void setMeanAndSTD(mrpt::math::CVectorDouble &out_means, mrpt::math::CVectorDouble &out_STD)
Load the mean and STD vectors of the full Kalman filter estimate (works for all KF-based methods)...
const GLubyte * c
Definition: glext.h:6406
Versatile class for consistent logging and management of output messages.
"Brute-force" Kalman filter (see discussion in mrpt::maps::CRandomFieldGridMap2D) ...
virtual void setSize(const double x_min, const double x_max, const double y_min, const double y_max, const double resolution, const TRandomFieldCell *fill_value=nullptr)
Changes the size of the grid, erasing previous contents.
void insertObservation_KernelDM_DMV(double normReading, const mrpt::math::TPoint2D &point, bool is_DMV)
The implementation of "insertObservation" for Achim Lilienthal&#39;s map models DM & DM+V.
float cell2float(const TRandomFieldCell &c) const override
double GMRF_lambdaObs
The initial information (Lambda) of each observation (this information will decrease with time) ...
double dm_sigma_omega
[DM/DM+V methods] The scaling parameter for the confidence "alpha" values (see the IROS 2009 paper; s...
#define MRPT_ENUM_TYPE_END()
Definition: TEnumType.h:78
void insertObservation_KF(double normReading, const mrpt::math::TPoint2D &point)
The implementation of "insertObservation" for the (whole) Kalman Filter map model.
virtual void getAsBitmapFile(mrpt::img::CImage &out_img) const
Returns an image just as described in saveAsBitmapFile.
ConnectivityDescriptor::Ptr m_gmrf_connectivity
Empty: default.
GLsizei const GLchar ** string
Definition: glext.h:4116
(see discussion in mrpt::maps::CRandomFieldGridMap2D)
void internal_loadFromConfigFile_common(const mrpt::config::CConfigFileBase &source, const std::string &section)
See utils::CLoadableOptions.
bool m_hasToRecoverMeanAndCov
Only for the KF2 implementation.
void setCellsConnectivity(const ConnectivityDescriptor::Ptr &new_connectivity_descriptor)
Sets a custom object to define the connectivity between cells.
double updated_std
[Dynamic maps only] The std cell value that was updated (to be used in the Forgetting_curve ...
double GMRF_saturate_min
(Default:-inf,+inf) Saturate the estimated mean in these limits
A class for storing an occupancy grid map.
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...
Gaussian Markov Random Field, squared differences prior weights between 4 neighboring cells (see disc...
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.
Definition: CMetricMap.h:52
bool GMRF_skip_variance
(Default:false) Skip the computation of the variance, just compute the mean
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:84
void updateMapEstimation()
Run the method-specific procedure required to ensure that the mean & variances are up-to-date with al...
void saveMetricMapRepresentationToFile(const std::string &filNamePrefix) const override
The implementation in this class just calls all the corresponding method of the contained metric maps...
void internal_clear() override
Erase all the contents of the map.
double dmv_var_mean
[Kernel DM-V only] The cumulative weighted variance of this cell
bool GMRF_use_occupancy_information
whether to use information of an occupancy_gridmap map for building 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.
GLsizei GLsizei GLchar * source
Definition: glext.h:4097
GLenum GLint GLint y
Definition: glext.h:3542
MRPT_FILL_ENUM_MEMBER(mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrKernelDM)
double computeConfidenceCellValue_DM_DMV(const TRandomFieldCell *cell) const
Computes the confidence of the cell concentration (alpha)
virtual void predictMeasurement(const double x, const double y, double &out_predict_response, double &out_predict_response_variance, bool do_sensor_normalization, const TGridInterpolationMethod interp_method=gimNearest)
Returns the prediction of the measurement at some (x,y) coordinates, and its certainty (in the form o...
mrpt::math::CMatrixD m_stackedCov
The compressed band diagonal matrix for the KF2 implementation.
virtual CRandomFieldGridMap2D::TInsertionOptionsCommon * getCommonInsertOptions()=0
Get the part of the options common to all CRandomFieldGridMap2D classes.
double evaluateResidual() const override
Return the residual/error of this observation.
double Lambda
"Information" of the observation (=inverse of the variance)
Simple, scalar (1-dim) constraint (edge) for a GMRF.
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.
std::deque< TPriorFactorGMRF > m_mrf_factors_priors
Vector with the precomputed priors for each GMRF model.
GLenum GLint x
Definition: glext.h:3542
double computeVarCellValue_DM_DMV(const TRandomFieldCell *cell) const
Computes the estimated variance of the cell concentration, or the overall average variance if it has ...
#define MRPT_ENUM_TYPE_BEGIN(_ENUM_TYPE_WITH_NS)
Definition: TEnumType.h:62
Lightweight 2D point.
Definition: TPoint2D.h:31
void insertObservation_KF2(double normReading, const mrpt::math::TPoint2D &point)
The implementation of "insertObservation" for the Efficient Kalman Filter map model.
double GMRF_gridmap_image_res
occupancy_gridmap resolution: size of each pixel (m)
GLenum const GLfloat * params
Definition: glext.h:3538
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.
virtual void getAsMatrix(mrpt::math::CMatrixDouble &out_mat) const
Like saveAsBitmapFile(), but returns the data in matrix form (first row in the matrix is the upper (y...
double kf_std
[KF-methods only] The standard deviation value of this cell
double GMRF_lambdaObsLoss
The loss of information of the observations with each iteration.
A class for storing images as grayscale or RGB bitmaps.
Definition: img/CImage.h:147
void getAsMatlab3DGraphScript(std::string &out_script) const
Return a large text block with a MATLAB script to plot the contents of this map.
void insertIndividualReading(const double sensorReading, const mrpt::math::TPoint2D &point, const bool update_map=true, const bool time_invariant=true, const double reading_stddev=.0)
Direct update of the map with a reading in a given position of the map, using the appropriate method ...
float compute3DMatchingRatio(const mrpt::maps::CMetricMap *otherMap, const mrpt::poses::CPose3D &otherMapPose, const TMatchingRatioParams &params) const override
See docs in base class: in this class this always returns 0.
Sparse solver for GMRF (Gaussian Markov Random Fields) graphical models.



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 1de0e027c Sat Sep 14 16:15:22 2019 +0200 at sáb sep 14 16:20:14 CEST 2019