PlannerRRT_SE2_TPS.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 "nav-precomp.h"  // Precomp header
 
#include <mrpt/nav/planners/PlannerRRT_SE2_TPS.h>
#include <mrpt/nav/tpspace/CPTG_DiffDrive_CollisionGridBased.h>
#include <mrpt/system/CTicTac.h>
#include <mrpt/random.h>
#include <mrpt/system/filesystem.h>
 
using namespace mrpt::nav;
using namespace mrpt::math;
using namespace mrpt::system;
using namespace mrpt::poses;
using namespace std;
 
MRPT_TODO("Optimize getNearestNode() with KD-tree!")
 
PlannerRRT_SE2_TPS::PlannerRRT_SE2_TPS() : m_initialized(false) {}
/** Load all params from a config file source */
void PlannerRRT_SE2_TPS::loadConfig(
        const mrpt::config::CConfigFileBase& ini, const std::string& sSect)
{
        PlannerTPS_VirtualBase::internal_loadConfig_PTG(ini, sSect);
}
 
/** Must be called after setting all params (see `loadConfig()`) and before
 * calling `solve()` */
void PlannerRRT_SE2_TPS::initialize()
{
        PlannerTPS_VirtualBase::internal_initialize_PTG();
 
        m_initialized = true;
}
 
/** The main API entry point: tries to find a planned path from 'goal' to
 * 'target' */
void PlannerRRT_SE2_TPS::solve(
        const PlannerRRT_SE2_TPS::TPlannerInput& pi,
        PlannerRRT_SE2_TPS::TPlannerResult& result)
{
        mrpt::system::CTimeLoggerEntry tleg(m_timelogger, "PT_RRT::solve");
 
        // Sanity checks:
        ASSERTMSG_(m_initialized, "initialize() must be called before!");
 
        // Calc maximum vehicle shape radius:
        double max_veh_radius = 0.;
        for (const auto& ptg : m_PTGs)
                mrpt::keep_max(max_veh_radius, ptg->getMaxRobotRadius());
 
        // [Algo `tp_space_rrt`: Line 1]: Init tree adding the initial pose
        if (result.move_tree.getAllNodes().empty())
        {
                result.move_tree.root = 0;
                result.move_tree.insertNode(
                        result.move_tree.root, TNodeSE2_TP(pi.start_pose));
        }
 
        mrpt::system::CTicTac working_time;
        working_time.Tic();
        size_t rrt_iter_counter = 0;
 
        size_t SAVE_3D_TREE_LOG_DECIMATION_CNT = 0;
        static size_t SAVE_LOG_SOLVE_COUNT = 0;
        SAVE_LOG_SOLVE_COUNT++;
 
        // Keep track of the best solution so far:
        // By reusing the contents of "result" we make the algorithm re-callable
        // ("any-time" algorithm) to refine results
 
        // [Algo `tp_space_rrt`: Line 2]: Iterate
        // ------------------------------------------
        for (;;)
        {
                // Check end conditions:
                const double elap_tim = working_time.Tac();
                if ((end_criteria.maxComputationTime > 0 &&
                         elap_tim > end_criteria.maxComputationTime)  // Max comp time
                        ||
                        (result.goal_distance < end_criteria.acceptedDistToTarget &&
                         elap_tim >= end_criteria.minComputationTime)  // Reach closer than
                                                                                                                   // this to target
                )
                {
                        break;
                }
 
                // [Algo `tp_space_rrt`: Line 3]: sample random state (with goal
                // biasing)
                // -----------------------------------------
                node_pose_t x_rand;
                // bool rand_is_target=false;
                if (mrpt::random::getRandomGenerator().drawUniform(0.0, 1.0) <
                        params.goalBias)
                {
                        x_rand = pi.goal_pose;
                        // rand_is_target=true;
                }
                else
                {
                        // Sample uniform:
                        for (int i = 0; i < node_pose_t::static_size; i++)
                                x_rand[i] = mrpt::random::getRandomGenerator().drawUniform(
                                        pi.world_bbox_min[i], pi.world_bbox_max[i]);
                }
                const CPose2D x_rand_pose(x_rand);
 
                // [Algo `tp_space_rrt`: Line 4]: Init empty solution set
                // -----------------------------------------
                using sorted_solution_list_t = std::map<double, TMoveEdgeSE2_TP>;
                sorted_solution_list_t candidate_new_nodes;  // Map: cost -> info. Pick
                // begin() to select the
                // lowest-cose one.
 
                const PoseDistanceMetric<TNodeSE2>
                        distance_evaluator_se2;  // Plain distances in SE(2), not along PTGs
                bool is_new_best_solution = false;  // Just for logging purposes
 
                //#define DO_LOG_TXTS
                std::string sLogTxt;
 
                // [Algo `tp_space_rrt`: Line 5]: For each PTG
                // -----------------------------------------
                const size_t nPTGs = m_PTGs.size();
                for (size_t idxPTG = 0; idxPTG < nPTGs; ++idxPTG)
                {
                        rrt_iter_counter++;
 
                        // [Algo `tp_space_rrt`: Line 5]: Search nearest neig. to x_rand
                        // -----------------------------------------------
                        const PoseDistanceMetric<TNodeSE2_TP> distance_evaluator(
                                *m_PTGs[idxPTG]);
 
                        const TNodeSE2_TP query_node(x_rand);
 
                        m_timelogger.enter("TMoveTree::getNearestNode");
                        mrpt::graphs::TNodeID x_nearest_id =
                                result.move_tree.getNearestNode(query_node, distance_evaluator);
                        m_timelogger.leave("TMoveTree::getNearestNode");
 
                        if (x_nearest_id == INVALID_NODEID)
                        {
                                // We can't find any close node, at least with this PTG's paths:
                                // skip
 
                                // Before that, save log:
                                if (params.save_3d_log_freq > 0 &&
                                        (++SAVE_3D_TREE_LOG_DECIMATION_CNT >=
                                         params.save_3d_log_freq))
                                {
                                        SAVE_3D_TREE_LOG_DECIMATION_CNT =
                                                0;  // Reset decimation counter
                                        TRenderPlannedPathOptions render_options;
                                        render_options.highlight_path_to_node_id =
                                                result.best_goal_node_id;
                                        render_options.highlight_last_added_edge = false;
                                        render_options.x_rand_pose = &x_rand_pose;
                                        render_options.log_msg = "SKIP: Can't find any close node";
                                        render_options.log_msg_position = mrpt::math::TPoint3D(
                                                pi.world_bbox_min.x, pi.world_bbox_min.y, 0);
                                        render_options.ground_xy_grid_frequency = 1.0;
 
                                        mrpt::opengl::COpenGLScene scene;
                                        renderMoveTree(scene, pi, result, render_options);
                                        mrpt::system::createDirectory("./rrt_log_trees");
                                        scene.saveToFile(mrpt::format(
                                                "./rrt_log_trees/rrt_log_%03u_%06u.3Dscene",
                                                static_cast<unsigned int>(SAVE_LOG_SOLVE_COUNT),
                                                static_cast<unsigned int>(rrt_iter_counter)));
                                }
 
                                continue;  // Skip
                        }
 
                        const TNodeSE2_TP& x_nearest_node =
                                result.move_tree.getAllNodes().find(x_nearest_id)->second;
 
                        // [Algo `tp_space_rrt`: Line 6]: Relative target
                        // -----------------------------------------------
                        const CPose2D x_nearest_pose(x_nearest_node.state);
                        const CPose2D x_rand_rel = x_rand_pose - x_nearest_pose;
 
                        // [Algo `tp_space_rrt`: Line 7]: Relative target in TP-Space
                        // ------------------------------------------------------------
                        const double D_max =
                                std::min(params.maxLength, m_PTGs[idxPTG]->getRefDistance());
 
                        double d_rand;  // Coordinates in TP-space
                        int k_rand;  // k_rand is the index of target_alpha in PTGs
                        // corresponding to a specific d_rand
                        // bool tp_point_is_exact =
                        m_PTGs[idxPTG]->inverseMap_WS2TP(
                                x_rand_rel.x(), x_rand_rel.y(), k_rand, d_rand);
                        d_rand *=
                                m_PTGs[idxPTG]
                                        ->getRefDistance();  // distance to target, in "real meters"
 
                        float d_free;
                        // bool local_obs_ok = false; // Just for 3D log files: indicates
                        // whether obstacle points have been recomputed
 
                        // [Algo `tp_space_rrt`: Line 8]: TP-Obstacles
                        // ------------------------------------------------------------
                        // Transform obstacles as seen from x_nearest_node -> TP_obstacles
                        double TP_Obstacles_k_rand = .0;  // vector<double> TP_Obstacles;
                        const double MAX_DIST_FOR_OBSTACLES =
                                1.5 * m_PTGs[idxPTG]->getRefDistance();  // Maximum Euclidean
                        // distance (radius)
                        // for considering
                        // obstacles around the
                        // current robot pose
 
                        ASSERT_ABOVE_(
                                m_PTGs[idxPTG]->getRefDistance(),
                                1.1 * max_veh_radius);  // Make sure the PTG covers at least a
                        // bit more than the vehicle shape!!
                        // (should be much, much higher)
 
                        {
                                CTimeLoggerEntry tle(
                                        m_timelogger, "PT_RRT::solve.changeCoordinatesReference");
                                transformPointcloudWithSquareClipping(
                                        pi.obstacles_points, m_local_obs,
                                        CPose2D(x_nearest_node.state), MAX_DIST_FOR_OBSTACLES);
                                // local_obs_ok=true;
                        }
                        {
                                CTimeLoggerEntry tle(
                                        m_timelogger, "PT_RRT::solve.SpaceTransformer");
                                spaceTransformerOneDirectionOnly(
                                        k_rand, m_local_obs, m_PTGs[idxPTG].get(),
                                        MAX_DIST_FOR_OBSTACLES, TP_Obstacles_k_rand);
                        }
 
                        // directions k_rand in TP_obstacles[k_rand] = d_free
                        // this is the collision free distance to the TP_target
                        d_free = TP_Obstacles_k_rand;  // TP_Obstacles[k_rand];
 
                        // [Algo `tp_space_rrt`: Line 10]: d_new
                        // ------------------------------------------------------------
                        double d_new = std::min(
                                D_max,
                                d_rand);  // distance of the new candidate state in TP-space
 
                        // mrpt::poses::CPose2D *log_new_state_ptr=NULL; // For graphical
                        // logs only
 
#ifdef DO_LOG_TXTS
                        sLogTxt += mrpt::format(
                                "tp_idx=%u tp_exact=%c\n d_free: %f d_rand=%f d_new=%f\n",
                                static_cast<unsigned int>(idxPTG),
                                tp_point_is_exact ? 'Y' : 'N', d_free, d_rand, d_new);
                        sLogTxt += mrpt::format(
                                " nearest:%s\n", x_nearest_pose.asString().c_str());
#endif
 
                        // [Algo `tp_space_rrt`: Line 13]: Do we have free space?
                        // ------------------------------------------------------------
                        if (d_free >= d_new)
                        {
                                // [Algo `tp_space_rrt`: Line 14]: PTG function
                                // ------------------------------------------------------------
                                // given d_rand and k_rand provides x,y,phi of the point in
                                // c-space
                                uint32_t nStep;
                                m_PTGs[idxPTG]->getPathStepForDist(k_rand, d_new, nStep);
 
                                mrpt::math::TPose2D rel_pose;
                                m_PTGs[idxPTG]->getPathPose(k_rand, nStep, rel_pose);
 
                                mrpt::math::wrapToPiInPlace(rel_pose.phi);  // wrap to [-pi,pi]
                                // -->avoid out of
                                // bounds errors
 
                                // [Algo `tp_space_rrt`: Line 15]: pose composition
                                // ------------------------------------------------------------
                                const mrpt::poses::CPose2D new_state_rel(rel_pose);
                                mrpt::poses::CPose2D new_state =
                                        x_nearest_pose + new_state_rel;  // compose the new_motion
                                // as the last nmotion and
                                // the new state
                                // log_new_state_ptr = &new_state;
 
                                // Check whether there's already a too-close node around:
                                // --------------------------------------------------------
                                bool accept_this_node = true;
 
                                // Is this a potential solution
                                const double goal_dist =
                                        new_state.distance2DTo(pi.goal_pose.x, pi.goal_pose.y);
                                const double goal_ang = std::abs(
                                        mrpt::math::angDistance(new_state.phi(), pi.goal_pose.phi));
                                const bool is_acceptable_goal =
                                        (goal_dist < end_criteria.acceptedDistToTarget) &&
                                        (goal_ang < end_criteria.acceptedAngToTarget);
 
                                mrpt::graphs::TNodeID new_nearest_id = INVALID_NODEID;
                                if (!is_acceptable_goal)  // Only check for nearby nodes if this
                                // is not a solution!
                                {
                                        double new_nearest_dist;
                                        const TNodeSE2 new_state_node(new_state.asTPose());
 
                                        m_timelogger.enter("TMoveTree::getNearestNode");
                                        new_nearest_id = result.move_tree.getNearestNode(
                                                new_state_node, distance_evaluator_se2,
                                                &new_nearest_dist, &result.acceptable_goal_node_ids);
                                        m_timelogger.leave("TMoveTree::getNearestNode");
 
                                        if (new_nearest_id != INVALID_NODEID)
                                        {
                                                // Also check angular distance:
                                                const double new_nearest_ang =
                                                        std::abs(mrpt::math::angDistance(
                                                                new_state.phi(), result.move_tree.getAllNodes()
                                                                                                         .find(new_nearest_id)
                                                                                                         ->second.state.phi));
                                                accept_this_node =
                                                        (new_nearest_dist >=
                                                                 params.minDistanceBetweenNewNodes ||
                                                         new_nearest_ang >= params.minAngBetweenNewNodes);
                                        }
                                }
 
                                if (!accept_this_node)
                                {
#ifdef DO_LOG_TXTS
                                        if (new_nearest_id != INVALID_NODEID)
                                        {
                                                sLogTxt += mrpt::format(
                                                        " -> new node NOT accepted for closeness to: %s\n",
                                                        result.move_tree.getAllNodes()
                                                                .find(new_nearest_id)
                                                                ->second.state.asString()
                                                                .c_str());
                                        }
#endif
                                        continue;  // Too close node, skip!
                                }
 
                                // [Algo `tp_space_rrt`: Line 16]: Add to candidate solution set
                                // ------------------------------------------------------------
                                // Create "movement" (tree edge) object:
                                TMoveEdgeSE2_TP new_edge(x_nearest_id, new_state.asTPose());
 
                                new_edge.cost = d_new;
                                new_edge.ptg_index = idxPTG;
                                new_edge.ptg_K = k_rand;
                                new_edge.ptg_dist = d_new;
 
                                candidate_new_nodes[new_edge.cost] = new_edge;
 
                        }  // end if the path is obstacle free
                        else
                        {
#ifdef DO_LOG_TXTS
                                sLogTxt += mrpt::format(" -> d_free NOT < d_rand\n");
#endif
                        }
 
                }  // end for idxPTG
 
                // [Algo `tp_space_rrt`: Line 19]: Any solution found?
                // ------------------------------------------------------------
                if (!candidate_new_nodes.empty())
                {
                        const TMoveEdgeSE2_TP& best_edge =
                                candidate_new_nodes.begin()->second;
                        const TNodeSE2_TP new_state_node(best_edge.end_state);
 
                        // Insert into the tree:
                        const mrpt::graphs::TNodeID new_child_id =
                                result.move_tree.getNextFreeNodeID();
                        result.move_tree.insertNodeAndEdge(
                                best_edge.parent_id, new_child_id, new_state_node, best_edge);
 
                        // Distance to goal:
                        const double goal_dist =
                                mrpt::poses::CPose2D(best_edge.end_state)
                                        .distance2DTo(pi.goal_pose.x, pi.goal_pose.y);
                        const double goal_ang = std::abs(mrpt::math::angDistance(
                                best_edge.end_state.phi, pi.goal_pose.phi));
 
                        const bool is_acceptable_goal =
                                (goal_dist < end_criteria.acceptedDistToTarget) &&
                                (goal_ang < end_criteria.acceptedAngToTarget);
 
                        if (is_acceptable_goal)
                                result.acceptable_goal_node_ids.insert(new_child_id);
 
                        // Total path length:
                        double this_path_cost = std::numeric_limits<double>::max();
                        if (is_acceptable_goal)  // Don't waste time computing path length
                        // if it doesn't matter anyway
                        {
                                TMoveTreeSE2_TP::path_t candidate_solution_path;
                                result.move_tree.backtrackPath(
                                        new_child_id, candidate_solution_path);
                                this_path_cost = 0;
                                for (TMoveTreeSE2_TP::path_t::const_iterator it =
                                                 candidate_solution_path.begin();
                                         it != candidate_solution_path.end(); ++it)
                                        if (it->edge_to_parent)
                                                this_path_cost += it->edge_to_parent->cost;
                        }
 
                        // Check if this should be the new optimal path:
                        if (is_acceptable_goal && this_path_cost < result.path_cost)
                        {
                                result.goal_distance = goal_dist;
                                result.path_cost = this_path_cost;
 
                                result.best_goal_node_id = new_child_id;
                                is_new_best_solution = true;
                        }
                }  // end if any candidate found
 
                //  Graphical logging, if enabled:
                // ------------------------------------------------------
                if (params.save_3d_log_freq > 0 &&
                        (++SAVE_3D_TREE_LOG_DECIMATION_CNT >= params.save_3d_log_freq ||
                         is_new_best_solution))
                {
                        CTimeLoggerEntry tle(
                                m_timelogger, "PT_RRT::solve.generate_log_files");
                        SAVE_3D_TREE_LOG_DECIMATION_CNT = 0;  // Reset decimation counter
 
                        // Render & save to file:
                        TRenderPlannedPathOptions render_options;
                        render_options.highlight_path_to_node_id = result.best_goal_node_id;
                        render_options.x_rand_pose = &x_rand_pose;
                        // render_options.x_nearest_pose = &x_nearest_pose;
                        // if (local_obs_ok) render_options.local_obs_from_nearest_pose =
                        // &m_local_obs;
                        // render_options.new_state = log_new_state_ptr;
                        render_options.highlight_last_added_edge = true;
                        render_options.ground_xy_grid_frequency = 1.0;
 
                        render_options.log_msg = sLogTxt;
                        render_options.log_msg_position = mrpt::math::TPoint3D(
                                pi.world_bbox_min.x, pi.world_bbox_min.y, 0);
 
                        mrpt::opengl::COpenGLScene scene;
                        renderMoveTree(scene, pi, result, render_options);
 
                        mrpt::system::createDirectory("./rrt_log_trees");
                        scene.saveToFile(mrpt::format(
                                "./rrt_log_trees/rrt_log_%03u_%06u.3Dscene",
                                static_cast<unsigned int>(SAVE_LOG_SOLVE_COUNT),
                                static_cast<unsigned int>(rrt_iter_counter)));
                }
 
        }  // end loop until end conditions
 
        // [Algo `tp_space_rrt`: Line 17]: Tree back trace
        // ------------------------------------------------------------
        result.success = (result.goal_distance < end_criteria.acceptedDistToTarget);
        result.computation_time = working_time.Tac();
 
}  // end solve()