CRandomFieldGridMap2D.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#ifndef CRandomFieldGridMap2D_H
#define CRandomFieldGridMap2D_H
 
#include <mrpt/containers/CDynamicGrid.h>
#include <mrpt/img/CImage.h>
#include <mrpt/serialization/CSerializable.h>
#include <mrpt/math/CMatrixD.h>
#include <mrpt/config/CLoadableOptions.h>
#include <mrpt/typemeta/TEnumType.h>
#include <mrpt/maps/CMetricMap.h>
#include <mrpt/graphs/ScalarFactorGraph.h>
 
#include <list>
 
namespace mrpt
{
namespace maps
{
class COccupancyGridMap2D;
 
// Pragma defined to ensure no structure packing: since we'll serialize
// TRandomFieldCell to streams, we want it not to depend on compiler options,
// etc.
#if defined(MRPT_IS_X86_AMD64)
#pragma pack(push, 1)
#endif
 
/** The contents of each cell in a CRandomFieldGridMap2D map.
 * \ingroup mrpt_maps_grp
 **/
struct TRandomFieldCell
{
        /** Constructor */
        TRandomFieldCell(double kfmean_dm_mean = 1e-20, double kfstd_dmmeanw = 0)
                : kf_mean(kfmean_dm_mean),
                  kf_std(kfstd_dmmeanw),
                  dmv_var_mean(0),
                  last_updated(mrpt::system::now()),
                  updated_std(kfstd_dmmeanw)
        {
        }
 
        // *Note*: Use unions to share memory between data fields, since only a set
        //          of the variables will be used for each mapping strategy.
        // You can access to a "TRandomFieldCell *cell" like: cell->kf_mean,
        // cell->kf_std, etc..
        //  but accessing cell->kf_mean would also modify (i.e. ARE the same memory
        //  slot) cell->dm_mean, for example.
 
        // Note 2: If the number of type of fields are changed in the future,
        //   *PLEASE* also update the writeToStream() and readFromStream() methods!!
 
        union {
                /** [KF-methods only] The mean value of this cell */
                double kf_mean;
                /** [Kernel-methods only] The cumulative weighted readings of this cell
                 */
                double dm_mean;
                /** [GMRF only] The mean value of this cell */
                double gmrf_mean;
        };
 
        union {
                /** [KF-methods only] The standard deviation value of this cell */
                double kf_std;
                /** [Kernel-methods only] The cumulative weights (concentration = alpha
                 * * dm_mean / dm_mean_w + (1-alpha)*r0 ) */
                double dm_mean_w;
                double gmrf_std;
        };
 
        /** [Kernel DM-V only] The cumulative weighted variance of this cell */
        double dmv_var_mean;
 
        /** [Dynamic maps only] The timestamp of the last time the cell was updated
         */
        mrpt::system::TTimeStamp last_updated;
        /** [Dynamic maps only] The std cell value that was updated (to be used in
         * the Forgetting_curve */
        double updated_std;
};
 
#if defined(MRPT_IS_X86_AMD64)
#pragma pack(pop)
#endif
 
/** CRandomFieldGridMap2D represents a 2D grid map where each cell is associated
 *one real-valued property which is estimated by this map, either
 *   as a simple value or as a probility distribution (for each cell).
 *
 *  There are a number of methods available to build the MRF grid-map,
 *depending on the value of
 *    `TMapRepresentation maptype` passed in the constructor.
 *
 *  The following papers describe the mapping alternatives implemented here:
 *              - `mrKernelDM`: A Gaussian kernel-based method. See:
 *                      - "Building gas concentration gridmaps with a mobile robot",
 *Lilienthal,
 *A. and Duckett, T., Robotics and Autonomous Systems, v.48, 2004.
 *              - `mrKernelDMV`: A kernel-based method. See:
 *                      - "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.
 *              - `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.
 *              - `mrKalmanApproximate`: A compressed/sparse Kalman filter approach.
 *See:
 *                      - "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.
 *              - `mrGMRF_SD`: A Gaussian Markov Random Field (GMRF) estimator, with
 *these
 *constraints:
 *                      - `mrGMRF_SD`: Each cell only connected to its 4 immediate neighbors
 *(Up,
 *down, left, right).
 *                      - (Removed in MRPT 1.5.0: `mrGMRF_G`: Each cell connected to a
 *square
 *area
 *of neighbors cells)
 *                      - See papers:
 *                              - "Time-variant gas distribution mapping with obstacle
 *information",
 *Monroy, J. G., Blanco, J. L., & Gonzalez-Jimenez, J. Autonomous Robots,
 *40(1), 1-16, 2016.
 *
 *  Note that this class is virtual, since derived classes still have to
 *implement:
 *              - mrpt::maps::CMetricMap::internal_computeObservationLikelihood()
 *              - mrpt::maps::CMetricMap::internal_insertObservation()
 *              - Serialization methods: writeToStream() and readFromStream()
 *
 * [GMRF only] A custom connectivity pattern between cells can be defined by
 *calling setCellsConnectivity().
 *
 * \sa mrpt::maps::CGasConcentrationGridMap2D,
 *mrpt::maps::CWirelessPowerGridMap2D, mrpt::maps::CMetricMap,
 *mrpt::containers::CDynamicGrid, The application icp-slam,
 *mrpt::maps::CMultiMetricMap
 * \ingroup mrpt_maps_grp
 */
class CRandomFieldGridMap2D
        : public mrpt::maps::CMetricMap,
          public mrpt::containers::CDynamicGrid<TRandomFieldCell>,
          public mrpt::system::COutputLogger
{
        using BASE = mrpt::containers::CDynamicGrid<TRandomFieldCell>;
 
        DEFINE_VIRTUAL_SERIALIZABLE(CRandomFieldGridMap2D)
   public:
        /** Calls the base CMetricMap::clear
         * Declared here to avoid ambiguity between the two clear() in both base
         * classes.
         */
        inline void clear() { CMetricMap::clear(); }
        // This method is just used for the ::saveToTextFile() method in base class.
        float cell2float(const TRandomFieldCell& c) const override
        {
                return c.kf_mean;
        }
 
        /** The type of map representation to be used, see CRandomFieldGridMap2D for
         * a discussion.
         */
        enum TMapRepresentation
        {
                /** Gaussian kernel-based estimator (see discussion in
                   mrpt::maps::CRandomFieldGridMap2D) */
                mrKernelDM = 0,
                /** Another alias for "mrKernelDM", for backwards compatibility (see
                   discussion in mrpt::maps::CRandomFieldGridMap2D) */
                mrAchim = 0,
                /** "Brute-force" Kalman filter (see discussion in
                   mrpt::maps::CRandomFieldGridMap2D) */
                mrKalmanFilter,
                /** (see discussion in mrpt::maps::CRandomFieldGridMap2D) */
                mrKalmanApproximate,
                /** Double mean + variance Gaussian kernel-based estimator (see
                   discussion in mrpt::maps::CRandomFieldGridMap2D) */
                mrKernelDMV,
                // Removed in MRPT 1.5.0: mrGMRF_G,   //!< Gaussian Markov Random Field,
                // Gaussian prior weights between neighboring cells up to a certain
                // distance (see discussion in mrpt::maps::CRandomFieldGridMap2D)
                /** Gaussian Markov Random Field, squared differences prior weights
                   between 4 neighboring cells (see discussion in
                   mrpt::maps::CRandomFieldGridMap2D) */
                mrGMRF_SD
        };
 
        /** Constructor */
        CRandomFieldGridMap2D(
                TMapRepresentation mapType = mrKernelDM, double x_min = -2,
                double x_max = 2, double y_min = -2, double y_max = 2,
                double resolution = 0.1);
 
        /** Destructor */
        virtual ~CRandomFieldGridMap2D();
 
        /** Returns true if the map is empty/no observation has been inserted (in
         * this class it always return false,
         * unless redefined otherwise in base classes)
         */
        virtual bool isEmpty() const override;
 
        /** Save the current map as a graphical file (BMP,PNG,...).
         * The file format will be derived from the file extension (see
         *CImage::saveToFile )
         *  It depends on the map representation model:
         *              mrAchim: Each pixel is the ratio \f$ \sum{\frac{wR}{w}} \f$
         *              mrKalmanFilter: Each pixel is the mean value of the Gaussian that
         *represents each cell.
         *
         * \sa \a getAsBitmapFile()
         */
        virtual void saveAsBitmapFile(const std::string& filName) const;
 
        /** Returns an image just as described in \a saveAsBitmapFile */
        virtual void getAsBitmapFile(mrpt::img::CImage& out_img) const;
 
        /** Like saveAsBitmapFile(), but returns the data in matrix form (first row
         * in the matrix is the upper (y_max) part of the map) */
        virtual void getAsMatrix(mrpt::math::CMatrixDouble& out_mat) const;
 
        /** Parameters common to any derived class.
         *  Derived classes should derive a new struct from this one, plus "public
         * utils::CLoadableOptions",
         *  and call the internal_* methods where appropiate to deal with the
         * variables declared here.
         *  Derived classes instantions of their "TInsertionOptions" MUST set the
         * pointer "m_insertOptions_common" upon construction.
         */
        struct TInsertionOptionsCommon
        {
                /** Default values loader */
                TInsertionOptionsCommon();
 
                /** See utils::CLoadableOptions */
                void internal_loadFromConfigFile_common(
                        const mrpt::config::CConfigFileBase& source,
                        const std::string& section);
 
                /** See utils::CLoadableOptions */
                void internal_dumpToTextStream_common(std::ostream& out) const;
 
                /** @name Kernel methods (mrKernelDM, mrKernelDMV)
                        @{ */
                /** The sigma of the "Parzen"-kernel Gaussian */
                float sigma;
                /** The cutoff radius for updating cells. */
                float cutoffRadius;
                /** Limits for normalization of sensor readings. */
                float R_min, R_max;
                /** [DM/DM+V methods] The scaling parameter for the confidence "alpha"
                 * values (see the IROS 2009 paper; see CRandomFieldGridMap2D) */
                double dm_sigma_omega;
                /** @} */
 
                /** @name Kalman-filter methods (mrKalmanFilter, mrKalmanApproximate)
                        @{ */
                /** The "sigma" for the initial covariance value between cells (in
                 * meters). */
                float KF_covSigma;
                /** 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). */
                float KF_initialCellStd;
                /** The sensor model noise (in normalized concentration units). */
                float KF_observationModelNoise;
                /** The default value for the mean of cells' concentration. */
                float KF_defaultCellMeanValue;
                /** [mrKalmanApproximate] The size of the window of neighbor cells. */
                uint16_t KF_W_size;
                /** @} */
 
                /** @name Gaussian Markov Random Fields methods (mrGMRF_SD)
                        @{ */
                /** The information (Lambda) of fixed map constraints */
                double GMRF_lambdaPrior;
                /** The initial information (Lambda) of each observation (this
                 * information will decrease with time) */
                double GMRF_lambdaObs;
                /** The loss of information of the observations with each iteration */
                double GMRF_lambdaObsLoss;
 
                /** whether to use information of an occupancy_gridmap map for building
                 * the GMRF */
                bool GMRF_use_occupancy_information;
                /** simplemap_file name of the occupancy_gridmap */
                std::string GMRF_simplemap_file;
                /** image name of the occupancy_gridmap */
                std::string GMRF_gridmap_image_file;
                /** occupancy_gridmap resolution: size of each pixel (m) */
                double GMRF_gridmap_image_res;
                /** Pixel coordinates of the origin for the occupancy_gridmap */
                size_t GMRF_gridmap_image_cx;
                /** Pixel coordinates of the origin for the occupancy_gridmap */
                size_t GMRF_gridmap_image_cy;
 
                /** (Default:-inf,+inf) Saturate the estimated mean in these limits */
                double GMRF_saturate_min, GMRF_saturate_max;
                /** (Default:false) Skip the computation of the variance, just compute
                 * the mean */
                bool GMRF_skip_variance;
                /** @} */
        };
 
        /** Changes the size of the grid, maintaining previous contents. \sa setSize
         */
        virtual 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, erasing previous contents.
         *  \param[in] connectivity_descriptor Optional user-supplied object that
         * will visit all grid cells to define their connectivity with neighbors and
         * the strength of existing edges. If present, it overrides all options in
         * insertionOptions
         * \sa resize
         */
        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);
 
        /** Base class for user-supplied objects capable of describing cells
         * connectivity, used to build prior factors of the MRF graph. \sa
         * setCellsConnectivity() */
        struct ConnectivityDescriptor
        {
                using Ptr = std::shared_ptr<ConnectivityDescriptor>;
                ConnectivityDescriptor();
                virtual ~ConnectivityDescriptor();
 
                /** Implement the check of whether node i=(icx,icy) is connected with
                 * node j=(jcx,jcy).
                 * This visitor method will be called only for immediate neighbors.
                 * \return true if connected (and the "information" value should be
                 * also updated in out_edge_information), false otherwise.
                 */
                virtual bool getEdgeInformation(
                        /** The parent map on which we are running */
                        const CRandomFieldGridMap2D* parent,
                        /** (cx,cy) for node "i" */
                        size_t icx, size_t icy,
                        /** (cx,cy) for node "j" */
                        size_t jcx, size_t jcy,
                        /** Must output here the inverse of the variance of the constraint
                           edge. */
                        double& out_edge_information) = 0;
        };
 
        /** Sets a custom object to define the connectivity between cells. Must call
         * clear() or setSize() afterwards for the changes to take place. */
        void setCellsConnectivity(
                const ConnectivityDescriptor::Ptr& new_connectivity_descriptor);
 
        /** See docs in base class: in this class this always returns 0 */
        float compute3DMatchingRatio(
                const mrpt::maps::CMetricMap* otherMap,
                const mrpt::poses::CPose3D& otherMapPose,
                const TMatchingRatioParams& params) const override;
 
        /** The implementation in this class just calls all the corresponding method
         * of the contained metric maps */
        virtual void saveMetricMapRepresentationToFile(
                const std::string& filNamePrefix) const override;
 
        /** Save a matlab ".m" file which represents as 3D surfaces the mean and a
         * given confidence level for the concentration of each cell.
         *  This method can only be called in a KF map model.
         *  \sa getAsMatlab3DGraphScript    */
        virtual void saveAsMatlab3DGraph(const std::string& filName) const;
 
        /** Return a large text block with a MATLAB script to plot the contents of
         * this map \sa saveAsMatlab3DGraph
         *  This method can only be called in a KF map model  */
        void getAsMatlab3DGraphScript(std::string& out_script) const;
 
        /** Returns a 3D object representing the map (mean) */
        virtual void getAs3DObject(
                mrpt::opengl::CSetOfObjects::Ptr& outObj) const override;
 
        /** Returns two 3D objects representing the mean and variance maps */
        virtual void getAs3DObject(
                mrpt::opengl::CSetOfObjects::Ptr& meanObj,
                mrpt::opengl::CSetOfObjects::Ptr& varObj) const;
 
        /** Return the type of the random-field grid map, according to parameters
         * passed on construction. */
        TMapRepresentation getMapType();
 
        /** Direct update of the map with a reading in a given position of the map,
         * using
         *  the appropriate method according to mapType passed in the constructor.
         *
         * This is a direct way to update the map, an alternative to the generic
         * insertObservation() method which works with mrpt::obs::CObservation
         * objects.
         */
        void insertIndividualReading(
                /** [in] The value observed in the (x,y) position */
                const double sensorReading,
                /** [in] The (x,y) location */
                const mrpt::math::TPoint2D& point,
                /** [in] Run a global map update after inserting this observatin
                   (algorithm-dependant) */
                const bool update_map = true,
                /** [in] Whether the observation "vanishes" with time (false) or not
                   (true) [Only for GMRF methods] */
                const bool time_invariant = true,
                /** [in] The uncertainty (standard deviation) of the reading.
                   Default="0.0" means use the default settings per map-wide parameters.
                   */
                const double reading_stddev = .0);
 
        enum TGridInterpolationMethod
        {
                gimNearest = 0,
                gimBilinear
        };
 
        /** Returns the prediction of the measurement at some (x,y) coordinates, and
         * its certainty (in the form of the expected variance).  */
        virtual void predictMeasurement(
                /** [in] Query X coordinate */
                const double x,
                /** [in] Query Y coordinate */
                const double y,
                /** [out] The output value */
                double& out_predict_response,
                /** [out] The output variance */
                double& out_predict_response_variance,
                /** [in] Whether to renormalize the prediction to a predefined
                   interval (`R` values in insertionOptions) */
                bool do_sensor_normalization,
                /** [in] Interpolation method */
                const TGridInterpolationMethod interp_method = gimNearest);
 
        /** Return the mean and covariance vector of the full Kalman filter estimate
         * (works for all KF-based methods). */
        void getMeanAndCov(
                mrpt::math::CVectorDouble& out_means,
                mrpt::math::CMatrixDouble& out_cov) const;
 
        /** Return the mean and STD vectors of the full Kalman filter estimate
         * (works for all KF-based methods). */
        void getMeanAndSTD(
                mrpt::math::CVectorDouble& out_means,
                mrpt::math::CVectorDouble& out_STD) const;
 
        /** Load the mean and STD vectors of the full Kalman filter estimate (works
         * for all KF-based methods). */
        void setMeanAndSTD(
                mrpt::math::CVectorDouble& out_means,
                mrpt::math::CVectorDouble& out_STD);
 
        /** Run the method-specific procedure required to ensure that the mean &
         * variances are up-to-date with all inserted observations. */
        void updateMapEstimation();
 
        void enableVerbose(bool enable_verbose)
        {
                this->setMinLoggingLevel(mrpt::system::LVL_DEBUG);
        }
        bool isEnabledVerbose() const
        {
                return this->getMinLoggingLevel() == mrpt::system::LVL_DEBUG;
        }
 
        void enableProfiler(bool enable = true)
        {
                this->m_gmrf.enableProfiler(enable);
        }
        bool isProfilerEnabled() const { return this->m_gmrf.isProfilerEnabled(); }
   protected:
        bool m_rfgm_run_update_upon_clear;
 
        /** Common options to all random-field grid maps: pointer that is set to the
         * derived-class instance of "insertOptions" upon construction of this
         * class. */
        TInsertionOptionsCommon* m_insertOptions_common;
 
        /** Get the part of the options common to all CRandomFieldGridMap2D classes
         */
        virtual CRandomFieldGridMap2D::TInsertionOptionsCommon*
                getCommonInsertOptions() = 0;
 
        /** The map representation type of this map, as passed in the constructor */
        TMapRepresentation m_mapType;
 
        /** The whole covariance matrix, used for the Kalman Filter map
         * representation. */
        mrpt::math::CMatrixD m_cov;
 
        /** The compressed band diagonal matrix for the KF2 implementation.
         *   The format is a Nx(W^2+2W+1) matrix, one row per cell in the grid map
         * with the
         *    cross-covariances between each cell and half of the window around it
         * in the grid.
         */
        mrpt::math::CMatrixD m_stackedCov;
        /** Only for the KF2 implementation. */
        mutable bool m_hasToRecoverMeanAndCov;
 
        /** @name Auxiliary vars for DM & DM+V methods
                @{ */
        float m_DM_lastCutOff;
        std::vector<float> m_DM_gaussWindow;
        double m_average_normreadings_mean, m_average_normreadings_var;
        size_t m_average_normreadings_count;
        /** @} */
 
        /** Empty: default */
        ConnectivityDescriptor::Ptr m_gmrf_connectivity;
 
        mrpt::graphs::ScalarFactorGraph m_gmrf;
 
        struct TObservationGMRF
                : public mrpt::graphs::ScalarFactorGraph::UnaryFactorVirtualBase
        {
                /** Observation value */
                double obsValue;
                /** "Information" of the observation (=inverse of the variance) */
                double Lambda;
                /** whether the observation will lose weight (lambda) as time goes on
                 * (default false) */
                bool time_invariant;
 
                double evaluateResidual() const override;
                double getInformation() const override;
                void evalJacobian(double& dr_dx) const override;
 
                TObservationGMRF(CRandomFieldGridMap2D& parent)
                        : obsValue(.0), Lambda(.0), time_invariant(false), m_parent(&parent)
                {
                }
 
           private:
                CRandomFieldGridMap2D* m_parent;
        };
 
        struct TPriorFactorGMRF
                : public mrpt::graphs::ScalarFactorGraph::BinaryFactorVirtualBase
        {
                /** "Information" of the observation (=inverse of the variance) */
                double Lambda;
 
                double evaluateResidual() const override;
                double getInformation() const override;
                void evalJacobian(double& dr_dx_i, double& dr_dx_j) const override;
 
                TPriorFactorGMRF(CRandomFieldGridMap2D& parent)
                        : Lambda(.0), m_parent(&parent)
                {
                }
 
           private:
                CRandomFieldGridMap2D* m_parent;
        };
 
        // Important: converted to a std::list<> so pointers are NOT invalidated
        // upon deletion.
        /** Vector with the active observations and their respective Information */
        std::vector<std::list<TObservationGMRF>> m_mrf_factors_activeObs;
        /** Vector with the precomputed priors for each GMRF model */
        std::deque<TPriorFactorGMRF> m_mrf_factors_priors;
 
        /** The implementation of "insertObservation" for Achim Lilienthal's map
         * models DM & DM+V.
         * \param normReading Is a [0,1] normalized concentration reading.
         * \param point Is the sensor location on the map
         * \param is_DMV = false -> map type is Kernel DM; true -> map type is DM+V
         */
        void insertObservation_KernelDM_DMV(
                double normReading, const mrpt::math::TPoint2D& point, bool is_DMV);
 
        /** The implementation of "insertObservation" for the (whole) Kalman Filter
         * map model.
         * \param normReading Is a [0,1] normalized concentration reading.
         * \param point Is the sensor location on the map
         */
        void insertObservation_KF(
                double normReading, const mrpt::math::TPoint2D& point);
 
        /** The implementation of "insertObservation" for the Efficient Kalman
         * Filter map model.
         * \param normReading Is a [0,1] normalized concentration reading.
         * \param point Is the sensor location on the map
         */
        void insertObservation_KF2(
                double normReading, const mrpt::math::TPoint2D& point);
 
        /** The implementation of "insertObservation" for the Gaussian Markov Random
         * Field map model.
         * \param normReading Is a [0,1] normalized concentration reading.
         * \param point Is the sensor location on the map
         */
        void insertObservation_GMRF(
                double normReading, const mrpt::math::TPoint2D& point,
                const bool update_map, const bool time_invariant,
                const double reading_information);
 
        /** solves the minimum quadratic system to determine the new concentration
         * of each cell */
        void updateMapEstimation_GMRF();
 
        /** Computes the confidence of the cell concentration (alpha) */
        double computeConfidenceCellValue_DM_DMV(
                const TRandomFieldCell* cell) const;
 
        /** Computes the average cell concentration, or the overall average value if
         * it has never been observed  */
        double computeMeanCellValue_DM_DMV(const TRandomFieldCell* cell) const;
 
        /** Computes the estimated variance of the cell concentration, or the
         * overall average variance if it has never been observed  */
        double computeVarCellValue_DM_DMV(const TRandomFieldCell* cell) const;
 
        /** In the KF2 implementation, takes the auxiliary matrices and from them
         * update the cells' mean and std values.
         * \sa m_hasToRecoverMeanAndCov
         */
        void recoverMeanAndCov() const;
 
        /** Erase all the contents of the map */
        virtual void internal_clear() override;
 
        /** Check if two cells of the gridmap (m_map) are connected, based on the
         * provided occupancy gridmap*/
        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);
};
 
}  // namespace maps
}  // namespace mrpt
 
MRPT_ENUM_TYPE_BEGIN(mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation)
MRPT_FILL_ENUM_MEMBER(
        mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrKernelDM);
MRPT_FILL_ENUM_MEMBER(
        mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrKalmanFilter);
MRPT_FILL_ENUM_MEMBER(
        mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrKalmanApproximate);
MRPT_FILL_ENUM_MEMBER(
        mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrKernelDMV);
MRPT_FILL_ENUM_MEMBER(
        mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation, mrGMRF_SD);
MRPT_ENUM_TYPE_END()
 
#endif