Obstacle and CircularObstacle

sources/obstacles/circular_obstacle.cpp

@@ -0,0 +1,90 @@
+#include "obstacle.h"
+#include "circular_obstacle.h"
+#include "rectangular_obstacle.h"
+#include "../struct/vector_2d.h"
+#include <cmath>
+#include <typeinfo>
+
+namespace kraken
+{
+    CircularObstacle::CircularObstacle(const Vector2D &pos, float radius) :
+            Obstacle(pos), radius_(radius), squared_radius_(radius * radius)
+    {
+    }
+
+    bool CircularObstacle::isInObstacle(const Vector2D &pos) const
+    {
+        return pos.squaredDistance(rotation_center_) <= squared_radius_;
+    }
+
+    float CircularObstacle::squaredDistance(const Vector2D &pos) const
+    {
+        // TODO : is "distance" really necessary ? (it uses a std::sqrt computation)
+        float out = std::max(0.f, pos.distance(rotation_center_) - radius_);
+        return out * out;
+    }
+
+    bool CircularObstacle::isColliding(const Vector2D &point_a, const Vector2D &point_b) const
+    {
+        const Vector2D point_c = rotation_center_;
+        const Vector2D ab = point_b - point_a;
+        const Vector2D ac = point_c - point_a;
+        float numerator = std::abs(ab.getX() * ac.getY() - ab.getY() * ac.getX());
+        float denominator = ab.squaredNorm();
+        float distance = numerator * numerator / denominator;
+
+        // no collision with the line (AB)
+        if (distance > squared_radius_)
+            return false;
+
+        // collision with the segment [AB]
+        float pscal1 = ab.dot(ac);
+        float pscal2 = -ab.dot(point_c - point_b);
+        if (pscal1 >= 0 && pscal2 >= 0)
+            return true;
+
+        // check if A or B is in the circle
+        return isInObstacle(point_a) || isInObstacle(point_b);
+    }
+
+    void CircularObstacle::getExpandedConvexHull(const float &expansion, const float &longestAllowedLength,
+                                                 std::vector<Vector2D> &vector_2d_list) const
+    {
+        int nbPoints = std::ceil(M_2_PI * (radius_ + expansion) / longestAllowedLength);
+        if (nbPoints < 3)
+            nbPoints = 3;
+
+        for (int i = 0; i < nbPoints; ++i)
+            vector_2d_list.push_back(
+                    Vector2D::fromPolar(expansion + radius_, i * M_2_PI / nbPoints) + rotation_center_);
+    }
+
+    bool CircularObstacle::operator==(const Obstacle &rhs) const
+    {
+        if (!Obstacle::operator==(rhs))
+            return false;
+
+        if (typeid(*this) != typeid(rhs))
+            return false;
+
+        return radius_ == static_cast<const CircularObstacle &>(rhs).radius_;
+    }
+
+    bool CircularObstacle::isColliding(const RectangularObstacle &obs) const
+    {
+        if (rotation_center_.squaredDistance(obs.getRotationCenter()) >=
+            (radius_ + obs.getHalfDiagonal()) * (radius_ + obs.getHalfDiagonal()))
+            return false;
+        return obs.squaredDistance(rotation_center_) < squared_radius_;
+    }
+
+#if DEBUG
+
+    std::ostream &operator<<(std::ostream &strm, const CircularObstacle &o)
+    {
+        return strm << "CircularObstacle(" << o.rotation_center_ << "," << o.radius_ << ")" << std::endl;
+    }
+
+#endif
+
+}

sources/obstacles/circular_obstacle.h

@@ -0,0 +1,37 @@
+#ifndef TESTS_CIRCULAR_OBSTACLE_H
+#define TESTS_CIRCULAR_OBSTACLE_H
+
+#include "../struct/vector_2d.h"
+#include "obstacle.h"
+
+#if DEBUG
+
+#include <ostream>
+
+#endif
+
+namespace kraken
+{
+    class CircularObstacle : public Obstacle
+    {
+    public:
+        CircularObstacle(const Vector2D &pos, float radius);
+        bool isInObstacle(const Vector2D &pos) const override;
+        float squaredDistance(const Vector2D &pos) const override;
+        void getExpandedConvexHull(const float &expansion, const float &longestAllowedLength,
+                                   std::vector<Vector2D> &vector_2d_list) const override;
+        bool isColliding(const Vector2D &point_a, const Vector2D &point_b) const override;
+        bool isColliding(const RectangularObstacle &obs) const override;
+        bool operator==(const Obstacle &rhs) const override;
+
+#if DEBUG
+        friend std::ostream &operator<<(std::ostream &strm, const CircularObstacle &o);
+#endif
+
+    protected:
+        float const radius_;
+        float const squared_radius_;
+    };
+}
+
+#endif //TESTS_CIRCULAR_OBSTACLE_H

sources/obstacles/compound_obstacle.cpp

@@ -0,0 +1,74 @@
+#include "compound_obstacle.h"
+
+#include <limits>
+#include <typeinfo>
+
+namespace kraken
+{
+    CompoundObstacle::CompoundObstacle(const Vector2D &rotation_center,
+                                       std::vector<Obstacle> obstacles_list) :
+            Obstacle(rotation_center), obstacles_list_(std::move(obstacles_list))
+    {
+    }
+
+    bool CompoundObstacle::isInObstacle(const Vector2D &pos) const
+    {
+        for (auto const &o : obstacles_list_)
+        {
+            if (o.isInObstacle(pos))
+                return true;
+        }
+
+        return false;
+    }
+
+    float CompoundObstacle::squaredDistance(const Vector2D &pos) const
+    {
+        float min = std::numeric_limits<float>::max();
+        for (auto const &o : obstacles_list_)
+        {
+            min = std::min(min, o.squaredDistance(pos));
+            if (min == 0)
+                break;
+        }
+        return min;
+    }
+
+    void CompoundObstacle::getExpandedConvexHull(const float &expansion, const float &longestAllowedLength,
+                                                 std::vector<Vector2D> &vector_2d_list) const
+    {
+        for (const auto &o : obstacles_list_)
+            o.getExpandedConvexHull(expansion, longestAllowedLength, vector_2d_list);
+    }
+
+    bool CompoundObstacle::isColliding(const Vector2D &point_a, const Vector2D &point_b) const
+    {
+        for (auto const &o : obstacles_list_)
+        {
+            if (o.isColliding(point_a, point_b))
+                return true;
+        }
+        return false;
+    }
+
+    bool CompoundObstacle::isColliding(const RectangularObstacle &obs) const
+    {
+        for (auto const &o : obstacles_list_)
+        {
+            if (o.isColliding(obs))
+                return true;
+        }
+        return false;
+    }
+
+    bool CompoundObstacle::operator==(const Obstacle &rhs) const
+    {
+        if (!Obstacle::operator==(rhs))
+            return false;
+
+        if (typeid(*this) != typeid(rhs))
+            return false;
+
+        return static_cast<const CompoundObstacle &>(rhs).obstacles_list_ == obstacles_list_;
+    }
+}

sources/obstacles/compound_obstacle.h

@@ -0,0 +1,29 @@
+#ifndef TESTS_COMPOUND_OBSTACLE_H
+#define TESTS_COMPOUND_OBSTACLE_H
+
+#include <vector>
+#include "obstacle.h"
+
+namespace kraken
+{
+
+    class CompoundObstacle : public Obstacle
+    {
+    public:
+        CompoundObstacle(const Vector2D &rotation_center, std::vector<Obstacle> obstacles_list);
+
+        bool isInObstacle(const Vector2D &pos) const override;
+        float squaredDistance(const Vector2D &pos) const override;
+        void getExpandedConvexHull(const float &expansion, const float &longestAllowedLength,
+                                   std::vector<Vector2D> &vector_2d_list) const override;
+        bool isColliding(const Vector2D &point_a, const Vector2D &point_b) const override;
+        bool isColliding(const RectangularObstacle &obs) const override;
+
+        bool operator==(const Obstacle &rhs) const override;
+
+    protected:
+        const std::vector<Obstacle> obstacles_list_;
+    };
+
+}
+#endif //TESTS_COMPOUND_OBSTACLE_H

sources/obstacles/obstacle.cpp

@@ -0,0 +1,20 @@
+#include "obstacle.h"
+
+
+namespace kraken
+{
+
+    Obstacle::Obstacle(const Vector2D &rotation_center) : rotation_center_(rotation_center)
+    {
+    }
+
+    bool Obstacle::operator==(const Obstacle &rhs) const
+    {
+        return rotation_center_ == rhs.rotation_center_;
+    }
+
+    const Vector2D &Obstacle::getRotationCenter() const
+    {
+        return rotation_center_;
+    }
+}

sources/obstacles/obstacle.h

@@ -0,0 +1,31 @@
+#ifndef TESTS_OBSTACLE_H
+#define TESTS_OBSTACLE_H
+
+#include <vector>
+#include "../struct/vector_2d.h"
+
+namespace kraken
+{
+    class RectangularObstacle;
+
+    class Obstacle
+    {
+    public:
+        Obstacle(const Vector2D &rotation_center);
+        virtual ~Obstacle() = default;
+        virtual bool isInObstacle(const Vector2D &pos) const = 0;
+        virtual float squaredDistance(const Vector2D &pos) const = 0;
+        virtual void getExpandedConvexHull(const float &expansion, const float &longestAllowedLength,
+                                           std::vector<Vector2D> &vector_2d_list) const = 0;
+        virtual bool isColliding(const Vector2D &point_a, const Vector2D &point_b) const = 0;
+        virtual bool isColliding(const RectangularObstacle &obs) const = 0;
+        virtual bool operator==(const Obstacle &rhs) const;
+
+        const Vector2D &getRotationCenter() const;
+    protected:
+        Vector2D rotation_center_;
+
+    };
+}
+
+#endif //TESTS_OBSTACLE_H