additional tests

include/box.h

 #pragma once
 
 struct Triangle;
+struct Point;
 
 struct Box {
     float minX, maxX, minY, maxY;
     bool isIn(const Triangle &t) const;
+    bool isIn(const Point &p) const;
 };
\ No newline at end of file

include/quad_tree.h

@@ -4,18 +4,21 @@
 #include <vector>
 #include "box.h"
 
+const int POINT_NOT_IN_QUADTREE = -1;
+
 #define QUADTREE_NODE_MAX_SHAPE 4
 
 class QuadTree {
     Box b;
-    std::shared_ptr<Triangle> t;
+    std::vector<Triangle> triangles; 
 
     std::vector<QuadTree> children;
 
     public:
         QuadTree(Box b);
-        void addTriangle(std::shared_ptr<Triangle> t);
+        void addTriangle(Triangle triangle);
         std::vector<Triangle> visibleSurface() const;
-        Triangle pointIntersection(Point p) const;
+        // returns triangle id
+        int pointIntersection(Point p) const;
 
 };
\ No newline at end of file

include/triangle.h

@@ -8,7 +8,7 @@ struct Triangle
     int depth;
     int id;
     bool neighbours(const Triangle &other) const;
-    Triangle(Point p1, Point p2, Point p3, int depth);
+    Triangle(Point p1, Point p2, Point p3, int depth, int id=0);
     bool pointInTriangle(const Point &p) const;
     Point nextPoint(int pointIndex) const;
 };

src/data_structures/box.cpp

@@ -11,4 +11,11 @@ bool Box::isIn(const Triangle &t) const {
         }
     }
     return false;
+}
+
+bool Box::isIn(const Point &p) const {
+    if (p.x > minX && p.x < maxX && p.y > minY && p.y < maxY) {
+        return true;
+    }
+    return false;
 }
\ No newline at end of file

src/data_structures/quad_tree.cpp

@@ -3,42 +3,78 @@
 
 QuadTree::QuadTree(Box b) : b{b} {}
 
-void QuadTree::addTriangle(std::shared_ptr<Triangle> t)
+int QuadTree::pointIntersection(Point p) const
 {
+    int triangleId = POINT_NOT_IN_QUADTREE;
+    if (!b.isIn(p))
+    {
+        return POINT_NOT_IN_QUADTREE;
+    }
+    if (triangles.size() > 0)
+    {
+        int depth = INT32_MAX;
+        for (const Triangle &t : triangles)
+        {
+            if (t.depth < depth && t.pointInTriangle(p))
+            {
+                depth = t.depth;
+                triangleId = t.id;
+            }
+        }
+        return triangleId;
+    }
 
-    if (!b.isIn(*t))
+    for (const QuadTree &q : children)
     {
-        return;
+        int id = q.pointIntersection(p);
+        if (id != POINT_NOT_IN_QUADTREE)
+        {
+            triangleId = POINT_NOT_IN_QUADTREE;
+        }
     }
+    return triangleId;
+}
+
+void QuadTree::addTriangle(Triangle triangle)
+{
 
-    if (this->t == nullptr && children.empty())
+    if (!b.isIn(triangle))
     {
-        this->t = t;
         return;
     }
 
-    if (!children.empty())
+    if (triangles.size() >= QUADTREE_NODE_MAX_SHAPE && children.empty())
     {
-        for (auto &c : children)
+        children = {
+            QuadTree(Box{b.minX, b.maxX / 2, b.minY, b.maxY}),
+            QuadTree(Box{b.maxX / 2, b.maxX, b.minY, b.maxY / 2}),
+            QuadTree(Box{b.maxX / 2, b.maxX, b.maxY / 2, b.maxY}),
+            QuadTree(Box{b.minX, b.maxX / 2, b.minY, b.maxY / 2})};
+
+        for (QuadTree &c : children)
         {
-            c.addTriangle(t);
+
+            c.addTriangle(triangle);
+            for (const Triangle &t : triangles)
+            {
+                c.addTriangle(t);
+            }
         }
+        triangles.clear();
+        return;
     }
 
-    children = {
-        QuadTree(Box{b.minX, b.maxX / 2, b.minY, b.maxY}),
-        QuadTree(Box{b.maxX / 2, b.maxX, b.minY, b.maxY / 2}),
-        QuadTree(Box{b.maxX / 2, b.maxX, b.maxY / 2, b.maxY}),
-        QuadTree(Box{b.minX, b.maxX / 2, b.minY, b.maxY / 2})};
-
-    auto newTriangles = unionize(*t, *(this->t));
-    this->t = nullptr;
+    if (children.empty())
+    {
+        triangles.push_back(triangle);
+        return;
+    }
 
-    for (auto &c : children)
+    for (QuadTree &c : children)
     {
-        for (auto &newT : newTriangles)
+        for (const Triangle &t : triangles)
         {
-            c.addTriangle(std::make_shared<Triangle>(newT));
+            c.addTriangle(t);
         }
     }
 }
\ No newline at end of file

src/shapes/triangle.cpp

@@ -6,7 +6,7 @@ bool Triangle::neighbours(const Triangle &other) const {
     return false;
 }
 
-Triangle::Triangle(Point p1, Point p2, Point p3, int depth) : points{p1,p2,p3}, depth{depth} {}
+Triangle::Triangle(Point p1, Point p2, Point p3, int depth, int id) : points{p1,p2,p3}, depth{depth}, id{id} {}
 
 bool Triangle::pointInTriangle(const Point &p) const {
     // all tests must be positive

tests/quad_tree_tests.cpp

 #include <gtest/gtest.h>
 #include <quad_tree.h>
 
+TEST (QuadTreeTest, OverlappingTriangles) {
+
+    QuadTree q{Box{0, 10, 0, 10}};
+    auto t1 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 1);
+    auto t2 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 2);
+    auto t3 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 3);
+    auto t4 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 4);
+    auto t5 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 5);
+
+    q.addTriangle(t1);
+    q.addTriangle(t2);
+    q.addTriangle(t3);
+    q.addTriangle(t4);
+    q.addTriangle(t5);
+    EXPECT_EQ(q.pointIntersection(Point{1,1}), 1);
+
+}
+
 TEST (QuadTreeTest, SingleInsertion) {
     QuadTree q{Box{0, 10, 0, 10}};
 
@@ -9,8 +27,26 @@ TEST (QuadTreeTest, SingleInsertion) {
     auto t2 = Triangle(Point{3,1}, Point{6,1}, Point{4,3}, 0);
     
 
-    q.addTriangle(std::make_shared<Triangle>(t1));
-    q.addTriangle(std::make_shared<Triangle>(t2));
+    q.addTriangle(t1);
+    q.addTriangle(t2);
 
     EXPECT_TRUE(true);
+}
+
+TEST (QuadTreeTest, PointOnTriangleQueryTest) {
+    QuadTree q{Box{0, 10, 0, 10}};
+
+    auto t1 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 1, 1);
+
+    auto t2 = Triangle(Point{3,1}, Point{6,1}, Point{4,3}, 2, 2);
+    
+
+    q.addTriangle(t1);
+    q.addTriangle(t2);
+
+    EXPECT_EQ(q.pointIntersection(Point{1,1}), 1);
+    EXPECT_EQ(q.pointIntersection(Point{5,1.5}), 2);
+    EXPECT_EQ(q.pointIntersection(Point{3.5, 1.5}), 1);
+    EXPECT_EQ(q.pointIntersection(Point{-1,-1}), POINT_NOT_IN_QUADTREE);
+
 }
\ No newline at end of file