CMultiMetricMapPDF.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 CMultiMetricMapPDF_H
#define CMultiMetricMapPDF_H
 
#include <mrpt/maps/CMultiMetricMap.h>
#include <mrpt/maps/CSimpleMap.h>
#include <mrpt/poses/CPosePDFParticles.h>
#include <mrpt/poses/CPose3DPDFParticles.h>
 
#include <mrpt/poses/CPoseRandomSampler.h>
 
#include <mrpt/bayes/CParticleFilterCapable.h>
#include <mrpt/config/CLoadableOptions.h>
#include <mrpt/slam/CICP.h>
 
#include <mrpt/slam/PF_implementations_data.h>
 
namespace mrpt
{
namespace slam
{
class CMetricMapBuilderRBPF;
}
namespace maps
{
/** Auxiliary class used in mrpt::maps::CMultiMetricMapPDF
 * \ingroup mrpt_slam_grp
  */
class CRBPFParticleData : public mrpt::serialization::CSerializable
{
        DEFINE_SERIALIZABLE(CRBPFParticleData)
   public:
        CRBPFParticleData(
                const TSetOfMetricMapInitializers* mapsInitializers = nullptr)
                : mapTillNow(mapsInitializers), robotPath()
        {
        }
 
        CMultiMetricMap mapTillNow;
        std::deque<mrpt::math::TPose3D> robotPath;
};
 
/** Declares a class that represents a Rao-Blackwellized set of particles for
 * solving the SLAM problem (This class is the base of RBPF-SLAM applications).
 *   This class is used internally by the map building algorithm in
 * "mrpt::slam::CMetricMapBuilderRBPF"
 *
 * \sa mrpt::slam::CMetricMapBuilderRBPF
 * \ingroup metric_slam_grp
 */
class CMultiMetricMapPDF
        : public mrpt::serialization::CSerializable,
          public mrpt::bayes::CParticleFilterData<CRBPFParticleData>,
          public mrpt::bayes::CParticleFilterDataImpl<
                  CMultiMetricMapPDF,
                  mrpt::bayes::CParticleFilterData<CRBPFParticleData>::CParticleList>,
          public mrpt::slam::PF_implementation<
                  CRBPFParticleData, CMultiMetricMapPDF,
                  mrpt::bayes::particle_storage_mode::POINTER>
{
        friend class mrpt::slam::CMetricMapBuilderRBPF;
 
        DEFINE_SERIALIZABLE(CMultiMetricMapPDF)
 
   protected:
        // PF algorithm implementations:
        void prediction_and_update_pfStandardProposal(
                const mrpt::obs::CActionCollection* action,
                const mrpt::obs::CSensoryFrame* observation,
                const bayes::CParticleFilter::TParticleFilterOptions& PF_options)
                override;
        void prediction_and_update_pfOptimalProposal(
                const mrpt::obs::CActionCollection* action,
                const mrpt::obs::CSensoryFrame* observation,
                const bayes::CParticleFilter::TParticleFilterOptions& PF_options)
                override;
        void prediction_and_update_pfAuxiliaryPFOptimal(
                const mrpt::obs::CActionCollection* action,
                const mrpt::obs::CSensoryFrame* observation,
                const bayes::CParticleFilter::TParticleFilterOptions& PF_options)
                override;
        void prediction_and_update_pfAuxiliaryPFStandard(
                const mrpt::obs::CActionCollection* action,
                const mrpt::obs::CSensoryFrame* observation,
                const bayes::CParticleFilter::TParticleFilterOptions& PF_options)
                override;
 
   private:
        /** Internal buffer for the averaged map. */
        mrpt::maps::CMultiMetricMap averageMap;
        bool averageMapIsUpdated;
 
        /** The SFs and their corresponding pose estimations */
        mrpt::maps::CSimpleMap SFs;
        /** A mapping between indexes in the SFs to indexes in the robot paths from
         * particles. */
        std::vector<uint32_t> SF2robotPath;
 
   public:
        /** The struct for passing extra simulation parameters to the
         * prediction/update stage
         *    when running a particle filter.
         * \sa prediction_and_update
         */
        struct TPredictionParams : public mrpt::config::CLoadableOptions
        {
                /** Default settings method */
                TPredictionParams();
 
                void loadFromConfigFile(
                        const mrpt::config::CConfigFileBase& source,
                        const std::string& section) override;  // See base docs
                void dumpToTextStream(
                        std::ostream& out) const override;  // See base docs
 
                /** [pf optimal proposal only]  Only for PF algorithm=2 (Exact
                 * "pfOptimalProposal")
                 *   Select the map on which to calculate the optimal
                 *    proposal distribution. Values:
                 *   0: Gridmap   -> Uses Scan matching-based approximation (based on
                 * Stachniss' work)
                 *   1: Landmarks -> Uses matching to approximate optimal
                 *   2: Beacons   -> Used for exact optimal proposal in RO-SLAM
                 *   3: Pointsmap -> Uses Scan matching-based approximation with a map
                 * of points (based on Stachniss' work)
                 *  Default = 0
                 */
                int pfOptimalProposal_mapSelection;
 
                /** [prediction stage][pf optimal proposal only] If
                 * useICPGlobalAlign_withGrid=true, this is the minimum quality ratio
                 * [0,1] of the alignment such as it will be accepted. Otherwise, raw
                 * odometry is used for those bad cases (default=0.7).
                  */
                float ICPGlobalAlign_MinQuality;
 
                /** [update stage] If the likelihood is computed through the occupancy
                 * grid map, then this structure is passed to the map when updating the
                 * particles weights in the update stage.
                  */
                COccupancyGridMap2D::TLikelihoodOptions update_gridMapLikelihoodOptions;
 
                mrpt::slam::TKLDParams KLD_params;
 
                /** ICP parameters, used only when "PF_algorithm=2" in the particle
                 * filter. */
                mrpt::slam::CICP::TConfigParams icp_params;
 
        } options;
 
        /** Constructor
          */
        CMultiMetricMapPDF(
                const bayes::CParticleFilter::TParticleFilterOptions& opts =
                        bayes::CParticleFilter::TParticleFilterOptions(),
                const mrpt::maps::TSetOfMetricMapInitializers* mapsInitializers =
                        nullptr,
                const TPredictionParams* predictionOptions = nullptr);
 
        /** Clear all elements of the maps, and restore all paths to a single
         * starting pose */
        void clear(const mrpt::poses::CPose2D& initialPose);
        /** \overload */
        void clear(const mrpt::poses::CPose3D& initialPose);
        /** Resets the map by loading an already-mapped map for past poses.
         * Current robot pose should be normally set to the last keyframe
         * in the simplemap. */
        void clear(
                const mrpt::maps::CSimpleMap& prevMap,
                const mrpt::poses::CPose3D& currentPose);
 
        /** Returns the estimate of the robot pose as a particles PDF for the
         * instant of time "timeStep", from 0 to N-1.
         * \sa getEstimatedPosePDF
         */
        void getEstimatedPosePDFAtTime(
                size_t timeStep,
                mrpt::poses::CPose3DPDFParticles& out_estimation) const;
 
        /** Returns the current estimate of the robot pose, as a particles PDF.
         * \sa getEstimatedPosePDFAtTime
         */
        void getEstimatedPosePDF(
                mrpt::poses::CPose3DPDFParticles& out_estimation) const;
 
        /** Returns the weighted averaged map based on the current best estimation.
         * If you need a persistent copy of this object, please use
         * "CSerializable::duplicate" and use the copy.
          * \sa Almost 100% sure you would prefer the best current map, given by
         * getCurrentMostLikelyMetricMap()
          */
        const CMultiMetricMap* getAveragedMetricMapEstimation();
 
        /** Returns a pointer to the current most likely map (associated to the most
         * likely particle) */
        const CMultiMetricMap* getCurrentMostLikelyMetricMap() const;
 
        /** Get the number of CSensoryFrame inserted into the internal member SFs */
        size_t getNumberOfObservationsInSimplemap() const { return SFs.size(); }
        /** Insert an observation to the map, at each particle's pose and to each
         * particle's metric map.
          * \param sf The SF to be inserted
          * \return true if any may was updated, false otherwise
          */
        bool insertObservation(mrpt::obs::CSensoryFrame& sf);
 
        /** Return the path (in absolute coordinate poses) for the i'th particle.
          * \exception On index out of bounds
          */
        void getPath(size_t i, std::deque<math::TPose3D>& out_path) const;
 
        /** Returns the current entropy of paths, computed as the average entropy of
         * poses along the path, where entropy of each pose estimation is computed
         * as the entropy of the gaussian approximation covariance.
          */
        double getCurrentEntropyOfPaths();
 
        /** Returns the joint entropy estimation over paths and maps, acording to
         * "Information Gain-based Exploration Using" by C. Stachniss, G. Grissetti
         * and W.Burgard.
          */
        double getCurrentJointEntropy();
 
        /** Update the poses estimation of the member "SFs" according to the current
         * path belief.
          */
        void updateSensoryFrameSequence();
 
        /** A logging utility: saves the current path estimation for each particle
         * in a text file (a row per particle, each 3-column-entry is a set
         * [x,y,phi], respectively).
          */
        void saveCurrentPathEstimationToTextFile(const std::string& fil);
 
   private:
        /** Rebuild the "expected" grid map. Used internally, do not call  */
        void rebuildAverageMap();
 
        /** An index [0,1] measuring how much information an observation aports to
         * the map (Typ. threshold=0.07) */
        float newInfoIndex;
 
   public:
        /** \name Virtual methods that the PF_implementations assume exist.
                @{ */
 
        // see docs in base
        mrpt::math::TPose3D getLastPose(
                const size_t i, bool& pose_is_valid) const override;
 
        void PF_SLAM_implementation_custom_update_particle_with_new_pose(
                CParticleDataContent* particleData,
                const mrpt::math::TPose3D& newPose) const override;
 
        // The base implementation is fine for this class.
        // void PF_SLAM_implementation_replaceByNewParticleSet( ...
 
        bool PF_SLAM_implementation_doWeHaveValidObservations(
                const CParticleList& particles,
                const mrpt::obs::CSensoryFrame* sf) const override;
 
        bool PF_SLAM_implementation_skipRobotMovement() const override;
 
        /** Evaluate the observation likelihood for one particle at a given location
         */
        double PF_SLAM_computeObservationLikelihoodForParticle(
                const mrpt::bayes::CParticleFilter::TParticleFilterOptions& PF_options,
                const size_t particleIndexForMap,
                const mrpt::obs::CSensoryFrame& observation,
                const mrpt::poses::CPose3D& x) const override;
        /** @} */
 
};  // End of class def.
 
}  // End of namespace
}  // End of namespace
 
#endif