CMonteCarloLocalization2D_unittest.cpp

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 |
   +------------------------------------------------------------------------+ */
 
#include <mrpt/io/CFileGZInputStream.h>
#include <mrpt/config/CConfigFile.h>
#include <mrpt/slam/CMonteCarloLocalization2D.h>
#include <mrpt/maps/CMultiMetricMap.h>
#include <mrpt/maps/CSimpleMap.h>
#include <mrpt/obs/CRawlog.h>
#include <mrpt/system/filesystem.h>
#include <mrpt/system/os.h>
#include <mrpt/random.h>
#include <gtest/gtest.h>
 
using namespace mrpt;
using namespace mrpt::bayes;
using namespace mrpt::slam;
using namespace mrpt::maps;
using namespace mrpt::io;
using namespace mrpt::poses;
using namespace mrpt::config;
using namespace mrpt::math;
using namespace mrpt::random;
using namespace mrpt::system;
using namespace mrpt::obs;
using namespace std;
 
// Defined in tests/test_main.cpp
namespace mrpt
{
extern std::string MRPT_GLOBAL_UNITTEST_SRC_DIR;
}
 
void run_test_pf_localization(CPose2D& meanPose, CMatrixDouble33& cov)
{
        // ------------------------------------------------------
        // The code below is a simplification of the program "pf-localization"
        // ------------------------------------------------------
        const string ini_fil =
                MRPT_GLOBAL_UNITTEST_SRC_DIR + string("/tests/montecarlo_test1.ini");
        if (!mrpt::system::fileExists(ini_fil))
        {
                cerr << "WARNING: Skipping test due to missing file: " << ini_fil
                         << "\n";
                return;
        }
 
        CConfigFile iniFile(ini_fil);
        std::vector<int>
                particles_count;  // Number of initial particles (if size>1, run
        // the experiments N times)
 
        // Load configuration:
        // -----------------------------------------
        string iniSectionName("LocalizationExperiment");
 
        // Mandatory entries:
        iniFile.read_vector(
                iniSectionName, "particles_count", std::vector<int>(1, 0),
                particles_count,
                /*Fail if not found*/ true);
        string RAWLOG_FILE = iniFile.read_string(
                iniSectionName, "rawlog_file", "", /*Fail if not found*/ true);
 
        RAWLOG_FILE = MRPT_GLOBAL_UNITTEST_SRC_DIR + string("/") + RAWLOG_FILE;
 
        // Non-mandatory entries:
        string MAP_FILE = iniFile.read_string(iniSectionName, "map_file", "");
 
        MAP_FILE = MRPT_GLOBAL_UNITTEST_SRC_DIR + string("/") + MAP_FILE;
 
        size_t rawlog_offset = iniFile.read_int(iniSectionName, "rawlog_offset", 0);
        int NUM_REPS = iniFile.read_int(iniSectionName, "experimentRepetitions", 1);
 
        // PF-algorithm Options:
        // ---------------------------
        CParticleFilter::TParticleFilterOptions pfOptions;
        pfOptions.loadFromConfigFile(iniFile, "PF_options");
 
        // PDF Options:
        // ------------------
        TMonteCarloLocalizationParams pdfPredictionOptions;
        pdfPredictionOptions.KLD_params.loadFromConfigFile(iniFile, "KLD_options");
 
        // Metric map options:
        // -----------------------------
        TSetOfMetricMapInitializers mapList;
        mapList.loadFromConfigFile(iniFile, "MetricMap");
 
        // --------------------------------------------------------------------
        //                                              EXPERIMENT PREPARATION
        // --------------------------------------------------------------------
        CTicTac tictac, tictacGlobal;
        CSimpleMap simpleMap;
        CRawlog rawlog;
        size_t rawlogEntry, rawlogEntries;
        CParticleFilter::TParticleFilterStats PF_stats;
 
        // Load the set of metric maps to consider in the experiments:
        CMultiMetricMap metricMap;
        metricMap.setListOfMaps(&mapList);
 
        getRandomGenerator().randomize();
 
        // Load the map (if any):
        // -------------------------
        if (MAP_FILE.size())
        {
                ASSERT_(fileExists(MAP_FILE));
 
                // Detect file extension:
                // -----------------------------
                string mapExt = lowerCase(
                        extractFileExtension(
                                MAP_FILE, true));  // Ignore possible .gz extensions
 
                if (!mapExt.compare("simplemap"))
                {
                        // It's a ".simplemap":
                        // -------------------------
                        CFileGZInputStream f(MAP_FILE);
                        mrpt::serialization::archiveFrom(f) >> simpleMap;
                        ASSERT_(simpleMap.size() > 0);
                        // Build metric map:
                        metricMap.loadFromProbabilisticPosesAndObservations(simpleMap);
                }
                else if (!mapExt.compare("gridmap"))
                {
                        // It's a ".gridmap":
                        // -------------------------
                        ASSERT_(metricMap.m_gridMaps.size() == 1);
                        CFileGZInputStream f(MAP_FILE);
                        mrpt::serialization::archiveFrom(f) >> (*metricMap.m_gridMaps[0]);
                }
                else
                {
                        THROW_EXCEPTION_FMT(
                                "Map file has unknown extension: '%s'", mapExt.c_str());
                }
        }
 
        // --------------------------
        // Load the rawlog:
        // --------------------------
        rawlog.loadFromRawLogFile(RAWLOG_FILE);
        rawlogEntries = rawlog.size();
 
        for (std::vector<int>::iterator itNum = particles_count.begin();
                 itNum != particles_count.end(); ++itNum)
        {
                int PARTICLE_COUNT = *itNum;
 
                // Global stats for all the experiment loops:
                vector<double> covergenceErrors;
                covergenceErrors.reserve(NUM_REPS);
                // --------------------------------------------------------------------
                //                                      EXPERIMENT REPETITIONS LOOP
                // --------------------------------------------------------------------
                tictacGlobal.Tic();
                for (int repetition = 0; repetition < NUM_REPS; repetition++)
                {
                        int M = PARTICLE_COUNT;
                        CMonteCarloLocalization2D pdf(M);
 
                        // PDF Options:
                        pdf.options = pdfPredictionOptions;
 
                        pdf.options.metricMap = &metricMap;
 
                        // Create the PF object:
                        CParticleFilter PF;
                        PF.m_options = pfOptions;
 
                        size_t step = 0;
                        rawlogEntry = 0;
 
                        // Initialize the PDF:
                        // -----------------------------
                        tictac.Tic();
                        if (!iniFile.read_bool(
                                        iniSectionName, "init_PDF_mode", false,
                                        /*Fail if not found*/ true))
                                pdf.resetUniformFreeSpace(
                                        metricMap.m_gridMaps[0].get(), 0.7f, PARTICLE_COUNT,
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_min_x", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_max_x", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_min_y", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_max_y", 0, true),
                                        DEG2RAD(
                                                iniFile.read_float(
                                                        iniSectionName, "init_PDF_min_phi_deg", -180)),
                                        DEG2RAD(
                                                iniFile.read_float(
                                                        iniSectionName, "init_PDF_max_phi_deg", 180)));
                        else
                                pdf.resetUniform(
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_min_x", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_max_x", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_min_y", 0, true),
                                        iniFile.read_float(
                                                iniSectionName, "init_PDF_max_y", 0, true),
                                        DEG2RAD(
                                                iniFile.read_float(
                                                        iniSectionName, "init_PDF_min_phi_deg", -180)),
                                        DEG2RAD(
                                                iniFile.read_float(
                                                        iniSectionName, "init_PDF_max_phi_deg", 180)),
                                        PARTICLE_COUNT);
 
                        // -----------------------------
                        //              Particle filter
                        // -----------------------------
                        CActionCollection::Ptr action;
                        CSensoryFrame::Ptr observations;
                        bool end = false;
 
                        // TTimeStamp cur_obs_timestamp;
 
                        while (rawlogEntry < (rawlogEntries - 1) && !end)
                        {
                                // Load pose change from the rawlog:
                                // ----------------------------------------
                                if (!rawlog.getActionObservationPair(
                                                action, observations, rawlogEntry))
                                        THROW_EXCEPTION("End of rawlog");
 
                                CPose2D expectedPose;  // Ground truth
 
                                //                              if (observations->size()>0)
                                //                                      cur_obs_timestamp =
                                // observations->getObservationByIndex(0)->timestamp;
 
                                if (step >= rawlog_offset)
                                {
                                        // Do not execute the PF at "step=0", to let the initial PDF
                                        // to be
                                        //   reflected in the logs.
                                        if (step > rawlog_offset)
                                        {
                                                // ----------------------------------------
                                                // RUN ONE STEP OF THE PARTICLE FILTER:
                                                // ----------------------------------------
                                                tictac.Tic();
 
                                                PF.executeOn(
                                                        pdf,
                                                        action.get(),  // Action
                                                        observations.get(),  // Obs.
                                                        &PF_stats  // Output statistics
                                                        );
                                        }
 
                                        pdf.getCovarianceAndMean(cov, meanPose);
                                        // cout << meanPose << " cov trace: "  << cov.trace() <<
                                        // endl;
 
                                }  // end if rawlog_offset
 
                                step++;
 
                        };  // while rawlogEntries
                }  // for repetitions
        }  // end of loop for different # of particles
}
 
// TEST =================
TEST(MonteCarlo2D, RunSampleDataset)
{
#if MRPT_IS_BIG_ENDIAN
        MRPT_TODO("Debug this issue in big endian platforms")
        return;  // Skip this test for now
#endif
 
        // Actual ending point:
        const CPose2D GT_endpose(15.904, -10.010, DEG2RAD(4.93));
 
        // Placeholder for results:
        CPose2D meanPose;
        CMatrixDouble33 cov;
 
        // Invoke test:
        // Give it 3 opportunities, since it might fail once for bad luck, or even
        // twice in an extreme bad luck:
        for (int op = 0; op < 3; op++)
        {
                run_test_pf_localization(meanPose, cov);
 
                const double final_pf_cov_trace = cov.trace();
                const CPose2D final_pf_pose = meanPose;
 
                bool pass1 = (final_pf_pose - GT_endpose).norm() < 0.10;
                bool pass2 = final_pf_cov_trace < 0.01;
 
                if (pass1 && pass2) return;  // OK!
 
                // else: give it another try...
                cout << "\n*Warning: Test failed. Will give it another chance, since "
                                "after all it's nondeterministic!\n";
        }
 
        FAIL() << "Failed to converge after 3 opportunities!!" << endl;
}