CostmapBuilder.h

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2022
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
#include <Eigen/Core>
 
#include <SimoxUtility/meta/enum/EnumNames.hpp>
#include <VirtualRobot/VirtualRobot.h>
 
#include <armarx/navigation/algorithms/Costmap.h>
#include <armarx/navigation/algorithms/Room.h>
#include <armarx/navigation/algorithms/types.h>
 
#if COSTMAP_BUILDER_SIMOX_CONTROL
#include <simox/control/environment/CollisionRobot.h>
#include <simox/control/robot/RobotInterface.h>
 
#include <hpp/fcl/broadphase/broadphase_collision_manager.h>
#include <hpp/fcl/collision_object.h>
#endif
 
namespace armarx::navigation::algorithms
{
 
    class CostmapBuilder
    {
    public:
        enum class DistanceCalculator
        {
            Simox,
            SimoxControl
        };
        const static simox::meta::EnumNames<DistanceCalculator> DistanceCalculatorNames;
 
        struct CostmapBuilderParams
        {
            DistanceCalculator calculationMethod = DistanceCalculator::Simox;
            int numThreads = 0; // 0 to let OpenMP decide how many threads to use
 
            bool restrictToRooms = false;
            /*!
             * Only applicable when restrictToRooms is true.
             * The list of rooms for which the costmap should be generated, leave empty to
             * include all rooms.
             */
            std::vector<std::string> roomEnableList;
 
            /*!
             * Robot footprint radius in mm. Only applicable when restrictToRooms is true.
             * When >= 0, cells closer than this distance to a room boundary are excluded.
             * -1 disables the footprint restriction.
             */
            float robotFootprintRadius = -1.F;
 
            /*!
             * The maximum distance from the costmap to an obstacle to be included for costmap
             * calculation. Every obstacles further away will be discarded.
             */
            float maxFilterDistance = 1000.F;
 
            Eigen::Vector3f collisionModelScaleFactor = Eigen::Vector3f::Ones();
 
            /// All poses that are further away to obstacles are set to this value
            float maxDistance = 2000.F;
 
            bool fakeModeForTesting = false;
        };
 
        CostmapBuilder(const VirtualRobot::RobotPtr& robot,
                       const VirtualRobot::SceneObjectSetPtr& obstacles,
                       const std::vector<VirtualRobot::RobotPtr>& articulatedObjects,
                       const std::vector<Room>& rooms,
                       const Costmap::Parameters& parameters,
                       const std::string& robotCollisonModelName,
                       const CostmapBuilderParams& builderParameters);
 
        Costmap create(const SceneBounds& init = SceneBounds());
        Costmap extend(Costmap costmap);
 
 
        static Eigen::MatrixXf createUniformGrid(const SceneBounds& sceneBounds,
                                                 const Costmap::Parameters& parameters);
 
 
        static void updateMask(Costmap& costmap);
 
    private:
#if COSTMAP_BUILDER_SIMOX_CONTROL
        struct CollisionSetupSC
        {
            std::unique_ptr<simox::control::robot::RobotInterface> robot;
            std::unique_ptr<simox::control::environment::CollisionRobot<hpp::fcl::OBBRSS>>
                collisionRobot;
 
            /*!
             * Thread-local wrappers around the shared obstacle geometry. Copying a
             * `CollisionObject` only duplicates its transform and AABB; the (expensive) BVH
             * geometry is shared via `shared_ptr` and is const during queries.
             *
             * Obstacles are static, so these are never updated after `setup()`.
             */
            std::vector<std::unique_ptr<hpp::fcl::CollisionObject>> obstacleColObjects;
            std::unique_ptr<hpp::fcl::BroadPhaseCollisionManager> obstacleCollisionManager;
        };
#else
        struct CollisionSetupSC
        {
            // not supported without SimoxControl
        };
#endif
        struct CollisionSetupSx
        {
            VirtualRobot::RobotPtr collisionRobot;
            VirtualRobot::CollisionModelPtr robotCollisionModel;
            VirtualRobot::SceneObjectSetPtr filteredObstacles;
        };
 
        using CollisionSetup = std::variant<std::monostate, CollisionSetupSC, CollisionSetupSx>;
 
        float computeCost(const Costmap::Position& position,
                          const CollisionSetup& collisionSetupVariant);
 
        void fillGridCosts(Costmap& costmap);
        void extendGridCosts(Costmap& costmap);
 
        // fn: collisionRobot, robotCollisionModel, mask, costs, index -> costs
        // expects mask calculation based on costs after this function
        void applyFnToCostmap(Costmap& costmap,
                              const std::function<float(const CollisionSetup& collisionSetup,
                                                        const std::optional<float>,
                                                        const float,
                                                        const Costmap::Index&)>& fn);
 
        VirtualRobot::SceneObjectSetPtr filterObjectsForCostmap(const Costmap& costmap);
 
#if COSTMAP_BUILDER_SIMOX_CONTROL
        using SharedObstacleColObjects = std::vector<std::shared_ptr<hpp::fcl::CollisionObject>>;
 
        /*!
         * Converts all obstacles into hpp-fcl collision objects.
         *
         * Must be called exactly once, serially. The conversion reads VirtualRobot state that is
         * shared between the source scene objects (`RobotFactory::createRobot` hands the
         * `CollisionModel` over by pointer instead of cloning it), so running it per-thread
         * inside the OpenMP region races and yields displaced obstacle geometry.
         */
        SharedObstacleColObjects buildSharedObstacleCollisionObjects() const;
#endif
 
        void initializeEmptyMask(Costmap& costmap);
 
        const VirtualRobot::RobotPtr robot;
        const VirtualRobot::SceneObjectSetPtr obstacles;
        const std::vector<VirtualRobot::RobotPtr> articulatedObjects;
        std::vector<Room> rooms;
        const Costmap::Parameters parameters;
        const std::string robotCollisionModelName;
 
        const CostmapBuilderParams builderParameters;
    };
 
} // namespace armarx::navigation::algorithms