public void TriangulateThePoints()
{
if (pointsOnHull != null)
{
pointsOnHull.Clear();
}
//
// Get points to triangulate
//
//Random points
//points = TestAlgorithmsHelpMethods.GenerateRandomPoints(seed, mapSize, numberOfPoints);
//Points from a plane mesh to test colinear points
points = TestAlgorithmsHelpMethods.GeneratePointsFromPlane(planeTrans);
//
// Prepare the points
//
//3d to 2d
HashSet <MyVector2> points_2d = new HashSet <MyVector2>();
foreach (Vector3 v in points)
{
points_2d.Add(v.ToMyVector2());
}
//Normalize to range 0-1
AABB2 normalizingBox = new AABB2(new List <MyVector2>(points_2d));
float dMax = HelpMethods.CalculateDMax(normalizingBox);
HashSet <MyVector2> points_2d_normalized = HelpMethods.Normalize(points_2d, normalizingBox, dMax);
//
// Triangulate points on convex hull and points inside of convex hull
//
//Method 1
//Sort the points and then add triangles by checking which edge is visible to that point
//HashSet<Triangle2> triangles_2d_normalized = _TriangulatePoints.VisibleEdgesTriangulation(points_2d_normalized);
//Method 2
//Triangulate the convex polygon, then add the rest of the points one-by-one
//The old triangle the point ends up in is split into tree new triangles
//HashSet<Triangle2> triangles_2d_normalized = _TriangulatePoints.TriangleSplitting(points_2d_normalized, addColinearPoints: true);
//
// Triangulate points on convex hull
//
//First find the convex hull of the points
//This means that we first need to find the points on the convex hull
List <MyVector2> pointsOnHull_normalized = _ConvexHull.JarvisMarch(points_2d_normalized);
//Method 1
//Go through the convex hull point-by-point and build triangles while anchoring to the first vertex
HashSet <Triangle2> triangles_2d_normalized = _TriangulatePoints.PointsOnConvexHull(pointsOnHull_normalized, addColinearPoints: true);
//Method 2
//Add a point inside of the convex hull to deal with colinear points
//MyVector2 insidePoint = HelpMethods.NormalizePoint(planeTrans.position.ToMyVector2(), normalizingBox, dMax);
//HashSet<Triangle2> triangles_2d_normalized = _TriangulatePoints.PointsOnConvexHull(pointsOnHull_normalized, insidePoint);
//
// Display
//
Debug.Log("Number of triangles: " + triangles_2d_normalized.Count);
/*
* if (pointsOnHull_normalized != null)
* {
* pointsOnHull = HelpMethods.UnNormalize(pointsOnHull_normalized, normalizingBox, dMax);
* }
*/
if (triangles_2d_normalized != null)
{
//Unnormalized the triangles
HashSet <Triangle2> triangles_2d = HelpMethods.UnNormalize(triangles_2d_normalized, normalizingBox, dMax);
testTriangles = triangles_2d;
//Make sure the triangles have the correct orientation
triangles_2d = HelpMethods.OrientTrianglesClockwise(triangles_2d);
//From 2d to 3d
HashSet <Triangle3> triangles_3d = new HashSet <Triangle3>();
foreach (Triangle2 t in triangles_2d)
{
triangles_3d.Add(new Triangle3(t.p1.ToMyVector3_Yis3D(), t.p2.ToMyVector3_Yis3D(), t.p3.ToMyVector3_Yis3D()));
}
triangulatedMesh = _TransformBetweenDataStructures.Triangle3ToCompressedMesh(triangles_3d);
}
}
private void OnDrawGizmos()
{
//
// Generate the points we are going to find the convex hull from
//
//Random points
//HashSet<Vector3> points = TestAlgorithmsHelpMethods.GenerateRandomPoints(seed, mapSize, numberOfPoints);
//Points from a plane mesh
HashSet <Vector3> points = TestAlgorithmsHelpMethods.GeneratePointsFromPlane(planeTrans);
//
// Prepare the points
//
//From 3d to 2d
HashSet <MyVector2> points_2d = new HashSet <MyVector2>();
foreach (Vector3 v in points)
{
points_2d.Add(v.ToMyVector2());
}
//Normalize to range 0-1
AABB2 normalizingBox = new AABB2(new List <MyVector2>(points_2d));
float dMax = HelpMethods.CalculateDMax(normalizingBox);
HashSet <MyVector2> points_2d_normalized = HelpMethods.Normalize(points_2d, normalizingBox, dMax);
//
// Generate the convex hull
//
//Algorithm 1. Jarvis March - slow but simple
//List<MyVector2> pointsOnConvexHull_2d_normalized = _ConvexHull.JarvisMarch(points_2d_normalized);
//Algorithm 2. Quickhull
//List<MyVector2> pointsOnConvexHull_2d_normalized = _ConvexHull.Quickhull(points_2d_normalized, includeColinearPoints: true, normalizingBox, dMax);
List <MyVector2> pointsOnConvexHull_2d_normalized = _ConvexHull.Quickhull(points_2d_normalized, includeColinearPoints: true);
if (pointsOnConvexHull_2d_normalized == null)
{
Debug.Log("Couldnt find a convex hull");
}
else
{
Debug.Log($"Found a hull with: {pointsOnConvexHull_2d_normalized.Count} points");
}
//
// Display
//
//Display points on the hull and lines between the points
if (pointsOnConvexHull_2d_normalized != null)
{
//UnNormalize
List <MyVector2> pointsOnConvexHull_2d = HelpMethods.UnNormalize(pointsOnConvexHull_2d_normalized, normalizingBox, dMax);
//From 2d to 3d
List <Vector3> pointsOnConvexHull = new List <Vector3>();
foreach (MyVector2 v in pointsOnConvexHull_2d)
{
pointsOnConvexHull.Add(v.ToVector3());
}
//print(pointsOnConvexHull.Count);
for (int i = 0; i < pointsOnConvexHull.Count; i++)
{
int i_minus_one = MathUtility.ClampListIndex(i - 1, pointsOnConvexHull.Count);
Gizmos.DrawLine(pointsOnConvexHull[i_minus_one], pointsOnConvexHull[i]);
}
float size = 0.1f;
for (int i = 1; i < pointsOnConvexHull.Count; i++)
{
Gizmos.DrawWireSphere(pointsOnConvexHull[i], size);
//So we can see in which order they were added
size += 0.01f;
}
}
//Display all the original points
foreach (Vector3 p in points)
{
Gizmos.DrawSphere(p, 0.1f);
}
}