added edge union cases

CMakeLists.txt

@@ -26,8 +26,6 @@ add_executable(
 	src/debug_utilities/mostly_equal.cpp
 	tests/unit_tests/simple_triangle_tests.cpp
 	tests/unit_tests/point_in_triangle_tests.cpp
-	tests/unit_tests/triangulation_tests.cpp
-	tests/unit_tests/ear_removal_tests.cpp
 	src/utilities/intersections.cpp
 	tests/union_tests.cpp
 	src/shapes/triangle.cpp
@@ -37,13 +35,10 @@ add_executable(
 	src/utilities/orientation.cpp
 	src/shapes/point.cpp
 	src/union.cpp
-	src/utilities/triangulation.cpp
 	src/utilities/pointList.cpp
 	tests/unit_tests/orientation_tests.cpp
 	tests/unit_tests/intersections_tests.cpp
 	src/data_structures/box.cpp
-	src/data_structures/quad_tree.cpp
-	tests/quad_tree_tests.cpp
 	tests/edge_union_cases.cpp
 	tests/unit_tests/convex_triangulation_tests.cpp
 	src/utilities/convex_triangulation.cpp
@@ -53,6 +48,9 @@ add_executable(
 	src/utilities/split_triangle.cpp
 	tests/unit_tests/orientation_tests.cpp
 	tests/union_neighbours_tests.cpp
+	src/debug_utilities/shift_triangle.cpp
+	src/utilities/interpolate_z.cpp
+	tests/unit_tests/interpolate_z_tests.cpp
 )
 
 include_directories(include)

include/contourize.h

 #pragma once
 #include <vector>
+#include <string>
+#include <exception>
 
 struct Triangle;
 struct Point;
 
+class ContourizeException : public std::exception {
+    virtual const char *what() const throw();
+};
 
 // creates a contour from a list of points 
 std::vector<Point> contourize(const std::vector<Point> &points);
\ No newline at end of file

include/convex_triangulation.h

@@ -5,4 +5,4 @@
 #include <vector>
 
 // Requires a convex shape
-std::vector<Triangle> convexTriangulation(const std::vector<Point> &points, int depth, int triangleId);
+std::vector<Triangle> convexTriangulation(const std::vector<Point> &points, int triangleId);

include/interpolate_z.h

+#pragma once
+#include <vector>
+struct Point;
+
+float interpolateZ(const std::vector<Point> &shape, const Point &p);
\ No newline at end of file

include/orientation.h

 #pragma once
-
+struct Triangle;
 struct Point;
 enum Orientation {
     Clockwise, Collinear, Counterclockwise
 };
 
-Orientation orientation(const Point &p1, const Point &p2, const Point &p3);
+Orientation orientation(const Point &p1, const Point &p2, const Point &p3);
\ No newline at end of file
+
+Orientation orientation(const Triangle &t);
\ No newline at end of file

include/point.h

@@ -4,6 +4,9 @@
 struct Point {
 	float x, y, z;
 	bool operator==(const Point &other) const;
+	Point operator-(const Point &other) const;
+	Point operator+(const Point &other) const;
+	Point operator-() const;
 };
 
 std::ostream &operator<<(std::ostream &os, Point const &p);

include/shift_triangle.h

+#pragma once
+struct Triangle;
+
+void shiftZ(Triangle &t, float z) ;
\ No newline at end of file

include/triangle.h

@@ -3,7 +3,7 @@
 #include "print_triangle.h"
 #include <vector>
 
-// points specified counterclockwise
+// points specified in counterclockwise or collinear (line / point) order
 struct Triangle
 {
     Point points[3];

include/triangulation.h

-#pragma once
-#include <vector>
-#include <optional>
-#include <triangle.h>
-
-class PointList;
-struct Point;
-
-std::optional<Triangle> removeEar(int &index, PointList &pointList, const std::vector<Point> &allPoints, int depth, int id);
-
-std::vector<Triangle> triangulate(std::vector<Point> points, int depth, int id);
-
-std::vector<Triangle> triangulate(Triangle t1, Triangle t2);
\ No newline at end of file

src/data_structures/quad_tree.cpp

-#include <quad_tree.h>
-#include <union.h>
-
-QuadTree::QuadTree(Box b) : b{b} {}
-
-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;
-    }
-
-    for (const QuadTree &q : children)
-    {
-        int id = q.pointIntersection(p);
-        if (id != POINT_NOT_IN_QUADTREE)
-        {
-            triangleId = POINT_NOT_IN_QUADTREE;
-        }
-    }
-    return triangleId;
-}
-
-void QuadTree::addTriangle(Triangle triangle)
-{
-
-    if (!b.isIn(triangle))
-    {
-        return;
-    }
-
-    if (triangles.size() >= QUADTREE_NODE_MAX_SHAPE && children.empty())
-    {
-        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(triangle);
-            for (const Triangle &t : triangles)
-            {
-                c.addTriangle(t);
-            }
-        }
-        triangles.clear();
-        return;
-    }
-
-    if (children.empty())
-    {
-        triangles.push_back(triangle);
-        return;
-    }
-
-    for (QuadTree &c : children)
-    {
-        for (const Triangle &t : triangles)
-        {
-            c.addTriangle(t);
-        }
-    }
-}
\ No newline at end of file

src/debug_utilities/mostly_equal.cpp

@@ -17,6 +17,5 @@ bool Triangle::operator==(const Triangle &other) const {
 	return mostlyEqual(points[0], other.points[0]) &&
 		mostlyEqual(points[1], other.points[1]) &&
 		mostlyEqual(points[2], other.points[2]) &&
-		depth == other.depth &&
 		id == other.id;
 }
\ No newline at end of file

src/debug_utilities/print_triangles.cpp

@@ -4,7 +4,6 @@
 
 std::ostream &operator<<(std::ostream &os, const Triangle &t) {
 	return os << "Triangle: " << t.id
-			<< ", " << "Depth: " << t.depth
 			<< " {" << t.points[0] << ", " << t.points[1] << ", " << t.points[2] << "}";
 }
 /*

src/debug_utilities/shift_triangle.cpp

+#include <shift_triangle.h>
+#include <triangle.h>
+#include <constants.h>
+
+void shiftZ(Triangle &t, float z) {
+    for (int i =0; i < NB_TRIANGLE_SIDES; i++) {
+        t.points[i].z += z;
+    }
+}
\ No newline at end of file

src/shapes/point.cpp

@@ -9,3 +9,17 @@ bool Point::operator==(const Point &other) const {
 std::ostream &operator<<(std::ostream &os, Point const &p) { 
     return os << "(" << p.x << "," << p.y << "," << p.z << ")";
 }
+
+Point Point::operator-() const {
+    return {-x, -y,-z};
+}
+
+
+Point Point::operator+(const Point &other) const {
+    return {x + other.x, y + other.y, z + other.z};
+}
+
+
+Point Point::operator-(const Point &other) const {
+    return *this + (- other);
+}
\ No newline at end of file

src/shapes/triangle.cpp

@@ -2,7 +2,7 @@
 #include "triangle_edges.h"
 #include "edge.h"
 
-Triangle::Triangle(const Point &p1, const Point &p2, const Point &p3, int depth, int id, std::vector<int> neighbours) : points{p1,p2,p3}, depth{depth}, id{id}, neighbours{neighbours} {}
+Triangle::Triangle(const Point &p1, const Point &p2, const Point &p3, int id, std::vector<int> neighbours) : points{p1,p2,p3}, id{id}, neighbours{neighbours} {}
 
 bool Triangle::pointInTriangle(const Point &p) const {
     // all tests must be positive

src/union.cpp

@@ -6,13 +6,12 @@
 #include <triangle_edges.h>
 #include <intersections.h>
 #include <split_triangle.h>
-#include <triangulation.h>
+#include <convex_triangulation.h>
 
 std::vector<Triangle> unionizeTopAndBottom(const Triangle &top, const Triangle &bot)
 {
     std::vector<Triangle> result;
 
-    std::list<Point> intr;
     TriangleEdges topEdges = TriangleEdges(top);
 
     // keep track of relevant triangles
@@ -21,13 +20,16 @@ std::vector<Triangle> unionizeTopAndBottom(const Triangle &top, const Triangle &
     for (int i = 0; i < NB_TRIANGLE_SIDES; i++)
     {
         const Edge &e = topEdges.edges[i];
+
+        // index 0: On the "outside" of the edge 
+        // index 1: On the "inside" of the edge
         auto shapes = splitShape(relv, e);
         // split triangle if exists
         // currently relevant triangles
         // add these to result
         if (!shapes[0].empty())
         {
-            std::vector<Triangle> relvTriangles = triangulate(shapes[0], bot.depth, bot.id);
+            std::vector<Triangle> relvTriangles = convexTriangulation(shapes[0], bot.id);
             result.insert(result.end(), relvTriangles.begin(), relvTriangles.end());
         }
         // future relevant triangles
@@ -47,7 +49,7 @@ std::vector<Triangle> unionize(const Triangle &t1, const Triangle &t2)
     {
         return {t1, t2};
     }
-    if (t1.depth < t2.depth)
+    if (t1.points[0].z < t2.points[0].z)
     {
         return unionizeTopAndBottom(t1, t2);
     }

src/utilities/contourize.cpp

@@ -3,12 +3,20 @@
 #include <orientation.h>
 #include <list>
 
+const char* ContourizeException::what() const throw() {
+    return "Infinite Loop detected";
+}
+
 bool isCounterClockwiseForAll(const Point &previous, const Point &candidate, const std::vector<Point> & points) {
     for (const auto &point : points) {
         if (previous == point || candidate == point) {
             continue;
         }
 	auto o = orientation(previous, candidate, point);
+        if (o == Collinear) {
+            continue;
+        }
+
         if (o != Counterclockwise) {
             return false;
         }
@@ -21,19 +29,34 @@ std::vector<Point> contourize(const std::vector<Point> &points) {
         return points;
     }
 
+
+
     std::vector<Point> result;
 
     Point previous = points[0];
     result.push_back(previous);
     std::list<Point> candidates(points.begin() + 1, points.end());
+    const int size = candidates.size();
+
+    // infinite loop detection
+    int seen = 0;
+
     while (!candidates.empty()) {
+        // detect infinite loop
+        if (seen >= candidates.size()) {
+            throw ContourizeException();
+        }
+  
+
         if (isCounterClockwiseForAll(previous, candidates.front(), points)) {
             previous = candidates.front();
             candidates.pop_front();
-	    result.push_back(previous);
+	        result.push_back(previous);
+            seen = 0;
         } else {
             candidates.push_back(candidates.front());
             candidates.pop_front();
+            seen++;
         }
     }
     return result;

src/utilities/convex_triangulation.cpp

 #include <convex_triangulation.h>
 
-std::vector<Triangle> convexTriangulation(const std::vector<Point> &points, int depth, int triangleId) {
+std::vector<Triangle> convexTriangulation(const std::vector<Point> &points, int triangleId) {
 	const int size = points.size();
 	if (size < 3) {
 		return std::vector<Triangle>{};
 	}
 
-	const Triangle t1 = Triangle(points[0], points[1], points[2], depth, triangleId);
+	const Triangle t1 = Triangle(points[0], points[1], points[2], triangleId);
 	std::vector<Triangle> results = {t1};
 
 	
 	Point first = points[0];
 	for (int i = size - 1; i >= 3; i--) {
-		results.push_back(Triangle(first, points[2], points[i], depth, triangleId));
+		results.push_back(Triangle(first, points[2], points[i], triangleId));
 		first = points[i];
 	}
 	return results;

src/utilities/interpolate_z.cpp

+#include <interpolate_z.h>
+#include <limits>
+#include <point.h>
+#include <cmath>
+
+
+float interpolateZ(const std::vector<Point> &shape, const Point &p) {
+    // create direction vectors
+    const Point v1 = -(shape[0] - shape[1]);
+    const Point v2 = -(shape[0] - shape[2]);
+
+    const Point &origin = shape[0];
+
+    float t = (p.y * v1.x - origin.y * v1.x - p.x * v1.y + origin.x * v1.y) / (v1.x * v2.y - v1.y * v2.x);
+    float s = (p.y - origin.y - t * v2.y) / v1.y;
+
+    if (s == - std::numeric_limits<float>::infinity() || std::isnan(s)) {
+        s = 0;
+    }
+
+    if (t == - std::numeric_limits<float>::infinity() || std::isnan(t)) {
+       t = 0; 
+    }
+
+    return origin.z + v1.z * s + v2.z * t;
+}

src/utilities/intersections.cpp

@@ -4,6 +4,7 @@
 #include <triangle.h>
 #include <constants.h>
 #include <edge.h>
+#include <interpolate_z.h>
 
 std::optional<float> getB(std::optional<float> slope, Point p)
 {
@@ -138,7 +139,6 @@ std::optional<Point> intersection(const Edge &e1, const Edge &e2)
     {
         return {};
     }
-
     return candPoint;
 }
 void intersections(const Edge &e1, const TriangleEdges &te, std::vector<Point> &results)
@@ -172,6 +172,9 @@ std::vector<Point> intersections(const std::vector<Point> &points, const Edge &l
         auto cand = intersectionFirstSide(line, es[i]);
         if (cand.has_value())
         {
+            // add depth information
+            float z = interpolateZ(points, cand.value());
+            cand.value().z = z;
             result.push_back(cand.value());
         }
     }