COccupancyGridMapFeatureExtractor.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 "slam-precomp.h"  // Precompiled headers
 
#include <mrpt/slam/COccupancyGridMapFeatureExtractor.h>
 
using namespace mrpt;
using namespace mrpt::maps;
using namespace mrpt::slam;
using namespace mrpt::poses;
using namespace mrpt::img;
using namespace mrpt::system;
 
void COccupancyGridMapFeatureExtractor::uncached_extractFeatures(
        const mrpt::maps::COccupancyGridMap2D& grid,
        mrpt::maps::CLandmarksMap& outMap, const size_t number_of_features,
        const mrpt::vision::TDescriptorType descriptors,
        const mrpt::vision::CFeatureExtraction::TOptions& feat_options)
{
        MRPT_START
 
        // get the gridmap as an image:
        CImage img(1, 1, 1);
        grid.getAsImageFiltered(img, true /*vertical flip*/, false /* force RGB */);
 
        // Detect features:
        vision::CFeatureExtraction fExt;
        vision::CFeatureList lstFeatures;
 
        fExt.options = feat_options;
        fExt.options.patchSize = 0;  // Do NOT extract patch
 
        // Detect interest points:
        fExt.detectFeatures(img, lstFeatures, 0 /* Init ID */, number_of_features);
 
        // Extract descriptors:
        if (descriptors != mrpt::vision::descAny)
                fExt.computeDescriptors(img, lstFeatures, descriptors);
 
        // Copy all the features to a map of landmarks:
        for (vision::CFeatureList::iterator it = lstFeatures.begin();
                 it != lstFeatures.end(); ++it)
        {
                CLandmark lm;
                lm.ID = (*it)->ID;
                lm.features.resize(1);
 
                lm.features[0] = *it;  // Insert the full feature there:
 
                lm.pose_mean.x =
                        grid.getXMin() + ((*it)->x + 0.5f) * grid.getResolution();
                lm.pose_mean.y =
                        grid.getYMin() + ((*it)->y + 0.5f) * grid.getResolution();
                lm.pose_mean.z = 0;
 
                lm.pose_cov_11 = lm.pose_cov_22 = lm.pose_cov_33 =
                        square(grid.getResolution());
                lm.pose_cov_12 = lm.pose_cov_13 = lm.pose_cov_23 = 0;
 
                lm.seenTimesCount = 1;
 
                outMap.landmarks.push_back(lm);
        }
 
        MRPT_END_WITH_CLEAN_UP(try {
                grid.saveMetricMapRepresentationToFile(
                        "__DEBUG_DUMP_GRIDMAP_ON_EXCEPTION");
        } catch (...){});
}
 
/*---------------------------------------------------------------
                                                extractFeatures
  ---------------------------------------------------------------*/
void COccupancyGridMapFeatureExtractor::extractFeatures(
        const mrpt::maps::COccupancyGridMap2D& grid,
        mrpt::maps::CLandmarksMap& outMap, const size_t number_of_features,
        const mrpt::vision::TDescriptorType descriptors,
        const mrpt::vision::CFeatureExtraction::TOptions& feat_options)
{
#if 0
        // Un-cashed version:
        uncached_extractFeatures(grid,outMap,number_of_features,descriptors,feat_options);
#else
        // Use cache mechanism:
 
        TCache::const_iterator it = m_cache.find(&grid);
        if (it == m_cache.end())
        {
                // We have to recompute the features:
                CLandmarksMap::Ptr theMap = mrpt::make_aligned_shared<CLandmarksMap>();
 
                uncached_extractFeatures(
                        grid, *theMap, number_of_features, descriptors, feat_options);
 
                outMap = *theMap;
 
                // Insert into the cache:
                m_cache[&grid] = theMap;
        }
        else
        {
                // Already in the cache:
                outMap = *(it->second);
        }
 
#endif
}
 
// This will receive the events from maps in order to purge the cache.
void COccupancyGridMapFeatureExtractor::OnEvent(const mrptEvent& e)
{
        const COccupancyGridMap2D* src = nullptr;
 
        // Upon map change or destruction, remove from our cache:
        if (e.isOfType<mrptEventOnDestroy>())
                src = static_cast<const COccupancyGridMap2D*>(
                        static_cast<const mrptEventOnDestroy*>(&e)->source_object);
        if (e.isOfType<mrptEventMetricMapClear>())
                src = static_cast<const COccupancyGridMap2D*>(
                        static_cast<const mrptEventMetricMapClear*>(&e)->source_map);
        if (e.isOfType<mrptEventMetricMapInsert>())
                src = static_cast<const COccupancyGridMap2D*>(
                        static_cast<const mrptEventMetricMapClear*>(&e)->source_map);
 
        if (src)
        {
                // Remove from cache:
                m_cache.erase(src);
 
                // Unsubscribe:
                this->observeEnd(*const_cast<COccupancyGridMap2D*>(src));
        }
}