TrajectoryChecker2D.cpp

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/>.
 */
 
#include "TrajectoryChecker2D.h"
 
#include <cmath>
 
#include <ArmarXCore/core/logging/Logging.h>
 
namespace armarx::navigation::algorithms::spfa::smoothing
{
    TrajectoryChecker2D::TrajectoryChecker2D(const algorithms::Costmap& costmap, double clearance) :
        costmap_(costmap),
        clearance_(clearance)
    {
    }
 
    bool TrajectoryChecker2D::isInCollision(float x, float y) const
    {
        const auto distOpt = costmap_.value(Eigen::Vector2f{x, y});
        if (!distOpt.has_value())
        {
            // Unknown/masked region -> treat as collision to be safe.
            return true;
        }
        return distOpt.value() < static_cast<float>(clearance_);
    }
 
    bool TrajectoryChecker2D::check(const core::GlobalTrajectory& trajectory, bool logDetails) const
    {
        bool collisionFree = true;
 
        // Check waypoints.
        for (std::size_t i = 0; i < trajectory.points().size(); ++i)
        {
            const auto& p = trajectory.points()[i].waypoint.pose.translation();
            if (isInCollision(p.x(), p.y()))
            {
                collisionFree = false;
                if (logDetails)
                {
                    ARMARX_INFO << "[TrajectoryChecker2D] Collision at waypoint " << i << " : ("
                                << p.x() << ", " << p.y() << ")";
                }
            }
        }
 
        // Check segments.
        constexpr float segmentResolution = 50.0f;
        for (std::size_t i = 0; i + 1 < trajectory.points().size(); ++i)
        {
            const auto& p1 = trajectory.points()[i].waypoint.pose.translation();
            const auto& p2 = trajectory.points()[i + 1].waypoint.pose.translation();
 
            const float dx = p2.x() - p1.x();
            const float dy = p2.y() - p1.y();
            const float dist = std::hypot(dx, dy);
            int numSamples = static_cast<int>(std::ceil(dist / segmentResolution));
            if (numSamples < 2)
                numSamples = 2;
 
            for (int s = 1; s < numSamples; ++s)
            {
                const float t = static_cast<float>(s) / numSamples;
                const float x = p1.x() + t * dx;
                const float y = p1.y() + t * dy;
                if (isInCollision(x, y))
                {
                    collisionFree = false;
                    if (logDetails)
                    {
                        ARMARX_INFO << "[TrajectoryChecker2D] Collision on segment " << i << "-"
                                    << (i + 1) << " at t=" << t;
                    }
                }
            }
        }
 
        return collisionFree;
    }
 
} // namespace armarx::navigation::algorithms::spfa::smoothing