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)
    {
    }
 
    float TrajectoryChecker2D::clearanceAt(float x, float y) const
    {
        const auto value = costmap_.value(Eigen::Vector2f{x, y});
 
        // Unknown or masked reads as collision.
        return value.has_value() ? value.value() : 0.F;
    }
 
    bool TrajectoryChecker2D::isInCollision(float x, float y) const
    {
        return clearanceAt(x, y) < static_cast<float>(clearance_);
    }
 
    std::vector<TrajectoryChecker2D::Violation>
    TrajectoryChecker2D::violations(const core::GlobalTrajectory& trajectory) const
    {
        std::vector<Violation> found;
 
        const auto& points = trajectory.points();
 
        for (std::size_t i = 0; i < points.size(); i++)
        {
            const auto& p = points[i].waypoint.pose.translation();
 
            if (isInCollision(p.x(), p.y()))
            {
                found.push_back({.index = i,
                                 .clearance = clearanceAt(p.x(), p.y()),
                                 .onSegment = false});
            }
 
            if (i + 1 >= points.size())
            {
                break;
            }
 
            // Same sampling as check(), so the two cannot disagree about what passes.
            constexpr float segmentResolution = 50.0F;
 
            const auto& q = points[i + 1].waypoint.pose.translation();
            const float dx = q.x() - p.x();
            const float dy = q.y() - p.y();
            int numSamples = static_cast<int>(std::ceil(std::hypot(dx, dy) / segmentResolution));
            if (numSamples < 2)
            {
                numSamples = 2;
            }
 
            for (int s = 1; s < numSamples; s++)
            {
                const float t = static_cast<float>(s) / static_cast<float>(numSamples);
                const float x = p.x() + t * dx;
                const float y = p.y() + t * dy;
 
                if (isInCollision(x, y))
                {
                    found.push_back(
                        {.index = i, .clearance = clearanceAt(x, y), .onSegment = true});
                    break; // one report per segment is enough to locate the problem
                }
            }
        }
 
        return found;
    }
 
    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