init quadtree

CMakeLists.txt

@@ -40,6 +40,7 @@ add_executable(
 	tests/unit_tests/intersections_tests.cpp
 	src/data_structures/box.cpp
 	src/data_structures/quad_tree.cpp
+	tests/quad_tree_tests.cpp
 )
 
 include_directories(include)

include/box.h

 #pragma once
 
+struct Triangle;
+
 struct Box {
     float minX, maxX, minY, maxY;
     bool isIn(const Triangle &t) const;

include/constants.h

@@ -2,4 +2,4 @@
 
 #define MAX_TRIANGLE_INTERSECTION_POINTS 12
 
-#define NB_TRIANGLE_SIDES 3
\ No newline at end of file
+#define NB_TRIANGLE_SIDES 3

include/quad_tree.h

+#pragma once
+#include "triangle.h"
+#include <memory>
+#include <vector>
+#include "box.h"
+
+#define QUADTREE_NODE_MAX_SHAPE 4
+
+class QuadTree {
+    Box b;
+    std::shared_ptr<Triangle> t;
+
+    std::vector<QuadTree> children;
+
+    public:
+        QuadTree(Box b);
+        void addTriangle(std::shared_ptr<Triangle> t);
+        std::vector<Triangle> visibleSurface() const;
+        Triangle pointIntersection(Point p) const;
+
+};
\ No newline at end of file

include/triangle.h

@@ -2,9 +2,11 @@
 #include "point.h"
 
 // points specified counterclockwise
-struct Triangle {
-	Point points[3];
-	int depth;
+struct Triangle
+{
+    Point points[3];
+    int depth;
+    int id;
     bool neighbours(const Triangle &other) const;
     Triangle(Point p1, Point p2, Point p3, int depth);
     bool pointInTriangle(const Point &p) const;

src/data_structures/quad_tree.cpp

+#include <quad_tree.h>
+#include <union.h>
+
+QuadTree::QuadTree(Box b) : b{b} {}
+
+void QuadTree::addTriangle(std::shared_ptr<Triangle> t)
+{
+
+    if (!b.isIn(*t))
+    {
+        return;
+    }
+
+    if (this->t == nullptr && children.empty())
+    {
+        this->t = t;
+        return;
+    }
+
+    if (!children.empty())
+    {
+        for (auto &c : children)
+        {
+            c.addTriangle(t);
+        }
+    }
+
+    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;
+
+    for (auto &c : children)
+    {
+        for (auto &newT : newTriangles)
+        {
+            c.addTriangle(std::make_shared<Triangle>(newT));
+        }
+    }
+}
\ No newline at end of file

src/utilities/contourize.cpp

@@ -10,34 +10,7 @@ Triangle clockwiseToCounterclockwise(const Triangle &t)
     return Triangle(t.points[0], t.points[2], t.points[1], t.depth);
 }
 
-/*
-bool isCounterClockwiseForAll(const Point &previous, const Point &candidate, const std::vector<Point> & points) {
-    for (const auto &point : points) {
-        if (previous == point || candidate == point) {
-            continue;
-        }
-        if (orientation(previous, point, candidate) != Counterclockwise) {
-            return false;
-        }
-    }
-    return true;
-}
-*/
 
-/*
-Point nextPoint(const Point &previous, std::vector<Point> &candidates, const std::vector<Point> &points) {
-    Point mostCounterclockwise = candidates[0];
-    for (int i = 1; i < candidates.size(); i++) {
-        if (isCounterClockwiseForAll(previous, candidates[i], points)) {
-            Point p = candidates[i];
-            candidates.erase(i + candidates.begin());
-            return p;
-        }
-    }
-
-    return Point{-69,-69};
-}
-*/
 
 float distanceSquared(const Point &p1, const Point &p2)
 {

src/utilities/triangulation.cpp

@@ -4,6 +4,7 @@
 #include <triangle.h>
 #include <optional>
 #include <pointList.h>
+#include <orientation.h>
 
 
 
@@ -17,23 +18,19 @@ bool isAnEar(Triangle triangle, const std::vector<Point> &points) {
     return true;
 }
 
-int mod(int a, int b) {
-    return (a + b) % b;
-}
-
-
 
 std::optional<Triangle> removeEar(int &index, PointList &pointList, const std::vector<Point> &allPoints) {
     PointNode &p = pointList.points[index];
-    const int next = pointList.next(p);
-    const int prev = pointList.prev(p);
+    const int next = p.next();
+    const int prev = p.prev();
+
 
     const PointNode &nextNode = pointList.points[next];
     const PointNode &prevNode = pointList.points[prev];
 
     Triangle candidate = Triangle{p.p, nextNode.p, prevNode.p, 0}; 
 
-    if (isAnEar(candidate, allPoints)) {
+    if (orientation(p.p, nextNode.p, prevNode.p) == Counterclockwise && isAnEar(candidate, allPoints)) {
 
         pointList.remove(index);
         index = next;
@@ -61,8 +58,8 @@ std::vector<Triangle> triangulate(std::vector<Point> points) {
     }
 
     const PointNode curr = polygon.points[i];
-    const int next = polygon.next(curr);
-    const int prev = polygon.prev(curr);
+    const int next = curr.next();
+    const int prev = curr.prev();
     
     Triangle last {curr.p, polygon.points[next].p, polygon.points[prev].p, 0};
     result.push_back(last);

tests/quad_tree_tests.cpp

+#include <gtest/gtest.h>
+#include <quad_tree.h>
+
+TEST (QuadTreeTest, SingleInsertion) {
+    QuadTree q{Box{0, 10, 0, 10}};
+
+    auto t1 = Triangle(Point{0,0}, Point{5,0},  Point{2,3}, 0);
+
+    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));
+
+    EXPECT_TRUE(true);
+}
\ No newline at end of file