private void Start()
{
//Init GUI
flipText.text = "Flipped edges: " + 0;
//Generate the points we want to triangulate
HashSet <Vector3> points = TestAlgorithmsHelpMethods.GenerateRandomPoints(seed, halfMapSize, numberOfPoints);
//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
//We should use all points, including the constraints
List <MyVector2> allPoints = new List <MyVector2>();
allPoints.AddRange(new List <MyVector2>(points_2d));
normalizingBox = HelpMethods.GetAABB(new List <MyVector2>(points_2d));
dMax = HelpMethods.CalculateDMax(normalizingBox);
HashSet <MyVector2> points_2d_normalized = HelpMethods.Normalize(points_2d, normalizingBox, dMax);
//Run delaunay with some algorithm
FlipEdgesVisual flipEdges = GetComponent <FlipEdgesVisual>();
if (flipEdges != null)
{
flipEdges.Delaunay_FlipEdges_Visualizer(points_2d_normalized, new HalfEdgeData2());
}
}
public void GenererateTriangulation()
{
//Get the random points
HashSet <Vector3> points = TestAlgorithmsHelpMethods.GenerateRandomPoints(seed, halfMapSize, numberOfPoints);
//From 3d to 2d
HashSet <MyVector2> points_2d = new HashSet <MyVector2>();
foreach (Vector3 v in points)
{
points_2d.Add(v.ToMyVector2());
}
List <MyVector2> constraints_2d = new List <MyVector2>();
foreach (Vector3 v in constraints)
{
constraints_2d.Add(v.ToMyVector2());
}
//Normalize to range 0-1
//We should use all points, including the constraints
List <MyVector2> allPoints = new List <MyVector2>();
allPoints.AddRange(new List <MyVector2>(points_2d));
allPoints.AddRange(constraints_2d);
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);
List <MyVector2> constraints_2d_normalized = HelpMethods.Normalize(constraints_2d, normalizingBox, dMax);
//
// Generate the triangulation
//
//Algorithm 1. Delaunay by triangulate all points with some bad algorithm and then flip edges until we get a delaunay triangulation
//HalfEdgeData2 triangleData_normalized = _Delaunay.FlippingEdges(points_2d_normalized, new HalfEdgeData2());
//Algorithm 2. Delaunay by inserting point-by-point while flipping edges after inserting a single point
//HalfEdgeData2 triangleData_normalized = _Delaunay.PointByPoint(points_2d_normalized, new HalfEdgeData2());
//Algorithm 3. Constrained delaunay
HalfEdgeData2 triangleData_normalized = _Delaunay.ConstrainedBySloan(points_2d_normalized, constraints_2d_normalized, false, new HalfEdgeData2());
//UnNormalize
HalfEdgeData2 triangleData = HelpMethods.UnNormalize(triangleData_normalized, normalizingBox, dMax);
//From half-edge to triangle
HashSet <Triangle2> triangles_2d = _TransformBetweenDataStructures.HalfEdge2ToTriangle2(triangleData);
//From triangulation to mesh
//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(), t.p2.ToMyVector3(), t.p3.ToMyVector3()));
}
triangulatedMesh = _TransformBetweenDataStructures.Triangle3ToCompressedMesh(triangles_3d);
}
private void Start()
{
//Init GUI
flipText.text = "Flipped edges: " + 0;
//Create the material we use to display meshes with a single color
blackMaterial = new Material(Shader.Find("Unlit/Color"));
blackMaterial.color = Color.black;
//Set active point to be outside of screen
activePoint = new MyVector2(-10000f, -10000f);
//Generate the points we want to triangulate
HashSet <Vector3> points = TestAlgorithmsHelpMethods.GenerateRandomPoints(seed, halfMapSize, numberOfPoints);
//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
//We should use all points, including the constraints
List <MyVector2> allPoints = new List <MyVector2>();
allPoints.AddRange(new List <MyVector2>(points_2d));
normalizingBox = HelpMethods.GetAABB(new List <MyVector2>(points_2d));
dMax = HelpMethods.CalculateDMax(normalizingBox);
HashSet <MyVector2> points_2d_normalized = HelpMethods.Normalize(points_2d, normalizingBox, dMax);
//Run delaunay with some algorithm
//DelaunayFlipEdgesVisual flipEdges = GetComponent<DelaunayFlipEdgesVisual>();
//if (flipEdges != null)
//{
// flipEdges.StartVisualizer(points_2d_normalized, new HalfEdgeData2());
//}
//DelaunayPointByPointVisual pointByPoint = GetComponent<DelaunayPointByPointVisual>();
//if (pointByPoint != null)
//{
// pointByPoint.StartVisualizer(points_2d_normalized, new HalfEdgeData2());
//}
//Triangulate with visible edges
VisibleEdgeVisualizer visibleEdge = GetComponent <VisibleEdgeVisualizer>();
if (visibleEdge)
{
visibleEdge.StartVisualization(points_2d_normalized);
}
}
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
AABB normalizingBox = HelpMethods.GetAABB(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);
//
// 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. Find the colinear points while triangulating the hull
//HashSet<Triangle2> triangles_2d_normalized = _TriangulatePoints.PointsOnConvexHull(pointsOnHull_normalized);
//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);
//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(), t.p2.ToMyVector3(), t.p3.ToMyVector3()));
}
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
AABB normalizingBox = HelpMethods.GetAABB(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);
if (pointsOnConvexHull_2d_normalized == null)
{
Debug.Log("Couldnt find a convex hull");
}
//
// 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 = 1; i < pointsOnConvexHull.Count; i++)
{
Gizmos.DrawLine(pointsOnConvexHull[i - 1], 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);
}
}