public void TriangulatorTestObtuseTriangle()
{
ITriangulator triangulator = CreateDefaultTriangulator();
// Use the Assert class to test conditions
Vector3[] vertices = { new Vector3(0, 0, 0), new Vector3(2, 0, 0), new Vector3(1, 0, 0.04f) };
triangulator.Add(vertices);
Interpolant interp = triangulator.Find(new Vector3(0, 0, 0));
CheckWeight(interp, 0, 1);
CheckWeightsZero(interp, new int[] { 1, 2 });
interp = triangulator.Find(new Vector3(2.0f, 0, 0));
CheckWeight(interp, 1, 1);
CheckWeightsZero(interp, new int[] { 0, 2 });
/// This one is outside the triangle, but should interpolate to the obtuse vertex exactly.
interp = triangulator.Find(new Vector3(1.0f, 0, 02f));
CheckWeight(interp, 2, 1);
CheckWeightsZero(interp, new int[] { 0, 1 });
interp = triangulator.Find(new Vector3(1.0f, 0, 0.0f));
//CheckWeight(interp, 2, 1);
//CheckWeightsZero(interp, new int[] { 0, 1 });
}
/// <summary> Triangulates a polygon, applying quality and constraint options. </summary>
/// <param name="polygon">Polygon.</param>
/// <param name="options">Constraint options.</param>
/// <param name="quality">Quality options.</param>
/// <param name="triangulator">The triangulation algorithm.</param>
public static Mesh Triangulate(this Polygon polygon, ConstraintOptions options, QualityOptions quality,
ITriangulator triangulator)
{
return(triangulator
.Triangulate(polygon.Points)
.ApplyConstraints(polygon, options, quality));
}
public void Subdivide(ITriangulator triangulator, float largestAreaFactor, float areaThreshold)
{
Debug.Assert(spriteMeshData != null);
Debug.Assert(triangulator != null);
m_VerticesTemp.Clear();
m_EdgesTemp.Clear();
m_EdgesTemp.AddRange(spriteMeshData.edges);
for (int i = 0; i < spriteMeshData.vertexCount; ++i)
{
m_VerticesTemp.Add(spriteMeshData.GetPosition(i));
}
try
{
var indices = new List <int>();
triangulator.Tessellate(0f, 0f, 0f, largestAreaFactor, areaThreshold, 100, m_VerticesTemp, m_EdgesTemp, indices);
spriteMeshData.Clear();
for (int i = 0; i < m_VerticesTemp.Count; ++i)
{
spriteMeshData.AddVertex(m_VerticesTemp[i], default(BoneWeight));
}
spriteMeshData.edges.AddRange(m_EdgesTemp);
spriteMeshData.indices.AddRange(indices);
}
catch (Exception)
{
}
}
/// <summary>
/// Injecting the reference to the triangulation that was newly built.
/// </summary>
/// <param name="triangulator">Reference to the data on the triangle that was built.</param>
private void Initialize(ITriangulator triangulator)
{
this.triangulator = (SimpleTriangulator)triangulator;
if (meshRenderer == null && meshFilter == null)
{
meshRenderer = gameObject.AddComponent <MeshRenderer>();
meshFilter = gameObject.AddComponent <MeshFilter>();
Material[] materials = new Material[5];
materials[0] = new Material(meshMaterial);
materials[1] = new Material(weightsMaterial);
materials[2] = new Material(weightsMaterial);
materials[3] = new Material(weightsMaterial);
materials[4] = new Material(wireFrameMaterial);
meshRenderer.materials = materials;
for (int i = 0; i < 3; i++)
{
GameObject instantiatedGameObject = Instantiate(percentageWorldSpaceCanvasPrefab, transform);
SpacePinPercentageVisualizer percentageVisualizer = instantiatedGameObject.GetComponent <SpacePinPercentageVisualizer>();
percentageVisualizers[i] = percentageVisualizer;
}
}
transform.position = new Vector3(transform.position.x, GetFrozenHeadPosition().y + verticalOffset, transform.position.z);
triangleIsDirty = true;
}
public bool Run()
{
Program.PrintTitle("SETUP - DEFAULT LAUNCHER");
// Debug?
var debugView = AskUser("Enable step visualizer triangulation?");
// # of triangulations?
Console.WriteLine("\nNumber of simultaneous triangulations?");
Console.Write("> ");
var n = 0;
while (!int.TryParse(Console.ReadLine(), out n))
{
Console.WriteLine("Invalid input! Please enter a number");
Console.Write("\n> ");
}
// Setup...
var triangulator = new ITriangulator[n];
var sdf = new SDF[n];
for (int i = 0; i < n; i++)
{
Program.PrintTitle($"PERFORM SETUP {i + 1} of {n}");
triangulator[i] = Program.UserInstantiation <ITriangulator>("triangulation method");
sdf[i] = Program.UserInstantiation <IRuntimeSDF>("signed distance function").Instance();
}
// Triangulate!
Tuple <Log, IPolygon, string, long>[] result;
if (debugView)
{
result = TriangulateWithLog(triangulator, sdf);
}
else
{
result = Triangulate(triangulator, sdf);
}
// Show result!
if (debugView)
{
if (!LaunchLogView(result))
{
Export(result);
}
}
else
{
if (!LaunchView(result))
{
Export(result);
}
}
return(!AskUser("Restart the application?"));
}
public static DTConvexPolygroup TriangulateAll(List <DTPolygon> polygonList, ITriangulator triangulator)
{
var triangleList = new List <List <Vector2> >();
foreach (var poly in polygonList)
{
triangleList.AddRange(triangulator.PolygonToTriangleList(poly));
}
return(new DTConvexPolygroup(triangleList));
}
public static ITriangulator bindTo_ITriangulator(IComponentIntrospect component)
{
global::System.IntPtr cPtr = solarPINVOKE.bindTo_ITriangulator(IComponentIntrospect.getCPtr(component));
ITriangulator ret = (cPtr == global::System.IntPtr.Zero) ? null : new ITriangulator(cPtr, true);
if (solarPINVOKE.SWIGPendingException.Pending)
{
throw solarPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static void Triangulate(this SpriteMeshData spriteMeshData, ITriangulator triangulator)
{
Debug.Assert(triangulator != null);
m_VerticesTemp.Clear();
for (int i = 0; i < spriteMeshData.vertices.Count; ++i)
{
m_VerticesTemp.Add(spriteMeshData.vertices[i].position);
}
triangulator.Triangulate(m_VerticesTemp, spriteMeshData.edges, spriteMeshData.indices);
}
public void Triangulate(ITriangulator triangulator)
{
Debug.Assert(spriteMeshData != null);
Debug.Assert(triangulator != null);
m_VerticesTemp.Clear();
for (int i = 0; i < spriteMeshData.vertexCount; ++i)
{
m_VerticesTemp.Add(spriteMeshData.GetPosition(i));
}
triangulator.Triangulate(m_VerticesTemp, spriteMeshData.edges, spriteMeshData.indices);
}
public void TriangulatorTestLine()
{
ITriangulator triangulator = CreateDefaultTriangulator();
Vector3[] vertices =
{
new Vector3(-1.3f, 0, 1.3f),
new Vector3(-0.3f, 0, 1.3f),
new Vector3(0.3f, 0, 1.3f),
new Vector3(1.3f, 0, 1.3f),
new Vector3(2.0f, 0, 1.3f),
new Vector3(3.0f, 0, 1.3f),
new Vector3(4.0f, 0, 1.3f)
};
triangulator.Add(vertices);
Interpolant interp;
for (int i = 0; i < vertices.Length; ++i)
{
interp = triangulator.Find(vertices[i]);
CheckWeight(interp, i, 1.0f);
CheckWeightsZero(interp, AllButOne(vertices.Length, i));
}
for (int i = 0; i < vertices.Length; ++i)
{
interp = triangulator.Find(vertices[i] + new Vector3(0.0f, 0.0f, -1.7f));
CheckWeight(interp, i, 1.0f);
CheckWeightsZero(interp, AllButOne(vertices.Length, i));
}
for (int i = 1; i < vertices.Length; ++i)
{
Vector3 midPoint = (vertices[i] + vertices[i - 1]) * 0.5f;
interp = triangulator.Find(midPoint);
CheckWeight(interp, i, 0.5f);
CheckWeight(interp, i - 1, 0.5f);
}
for (int i = 1; i < vertices.Length; ++i)
{
Vector3 midPoint = (vertices[i] + vertices[i - 1]) * 0.5f + new Vector3(0.0f, 0.0f, 1.1f);
interp = triangulator.Find(midPoint);
CheckWeight(interp, i, 0.5f);
CheckWeight(interp, i - 1, 0.5f);
}
}
public void TriangulatorTestTriangulationTime()
{
List <Vector3> vertices = new List <Vector3>();
float maxX = 50.0f;
float maxZ = 50.0f;
for (float x = 0; x <= maxX; ++x)
{
for (float z = 0; z <= maxZ; ++z)
{
vertices.Add(new Vector3(x, 0.0f, z));
}
}
int reduction = 3;
List <long> buildTimes = new List <long>();
List <long> findTimes = new List <long>();
int maxMsPerVertBuild = 4;
float maxMsFind = 1.5f;
Stopwatch stopwatch = new Stopwatch();
Interpolant triIter;
int minVertices = reduction * 2;
Vector3[] vertArray = vertices.ToArray();
while (vertArray.Length >= minVertices)
{
ITriangulator triangulator = CreateDefaultTriangulator();
vertArray = vertices.ToArray();
stopwatch.Restart();
triangulator.Add(vertArray);
stopwatch.Stop();
UnityEngine.Debug.Log($"Processed {vertices.Count} vertices: {stopwatch.ElapsedMilliseconds}ms");
buildTimes.Add(stopwatch.ElapsedMilliseconds);
Assert.IsTrue(stopwatch.ElapsedMilliseconds < vertices.Count * maxMsPerVertBuild, $"Test proc {vertArray.Length} verts took {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Restart();
triIter = triangulator.Find(new Vector3(maxX * 0.33f, 0, maxZ * 0.33f));
stopwatch.Stop();
UnityEngine.Debug.Log($"Searched {vertices.Count} vertices: {stopwatch.ElapsedMilliseconds}ms");
findTimes.Add(stopwatch.ElapsedMilliseconds);
Assert.IsTrue(stopwatch.ElapsedMilliseconds <= maxMsFind, $"Test find {vertArray.Length} verts took {stopwatch.ElapsedMilliseconds} ms");
vertices.RemoveRange(vertices.Count / reduction, vertices.Count - vertices.Count / reduction);
}
}
/// <summary>
/// Check trivial interpolation at vertices and on edges connecting vertices.
/// </summary>
/// <param name="triangulator"></param>
/// <param name="vertices"></param>
private void CheckVertices(ITriangulator triangulator, Vector3[] vertices)
{
Interpolant interp;
for (int i = 0; i < vertices.Length; ++i)
{
interp = triangulator.Find(vertices[i]);
CheckWeight(interp, i, 1);
CheckWeightsZero(interp, AllButOne(vertices.Length, i));
int next = (i + 1) % vertices.Length;
Vector3 midPoint = (vertices[i] + vertices[next]) * 0.5f;
interp = triangulator.Find(midPoint);
CheckWeight(interp, i, 0.5f);
CheckWeight(interp, next, 0.5f);
}
}
public void TriangulatorTestSquare()
{
ITriangulator triangulator = CreateDefaultTriangulator();
Vector3[] vertices =
{
new Vector3(-1, 0, -1),
new Vector3(1, 0, -1),
new Vector3(1, 0, 1),
new Vector3(-1, 0, 1)
};
triangulator.Add(vertices);
CheckVertices(triangulator, vertices);
Interpolant interp;
Vector3 center = Vector3.zero;
for (int i = 0; i < vertices.Length; ++i)
{
center += vertices[i];
}
center *= 1.0f / vertices.Length;
interp = triangulator.Find(center);
// Check that the interpolation is the center of either the diagonal formed by vert[0]-vert[2]
// or the diagonal vert[1]-vert[3].
float[] wgts = new float[vertices.Length];
for (int i = 0; i < interp.idx.Length; ++i)
{
if (interp.weights[i] > 0)
{
wgts[interp.idx[i]] = interp.weights[i];
}
}
float eps = 1.0e-4f;
bool diag02 = FloatCompare(wgts[0], 0.5f, eps) && FloatCompare(wgts[1], 0, eps) && FloatCompare(wgts[2], 0.5f, eps) && FloatCompare(wgts[3], 0, eps);
bool diag13 = FloatCompare(wgts[0], 0, eps) && FloatCompare(wgts[1], 0.5f, eps) && FloatCompare(wgts[2], 0, eps) && FloatCompare(wgts[3], 0.5f, eps);
UnityEngine.Debug.Log($"diag02 {diag02}, diag13 {diag13}");
UnityEngine.Debug.Log($"w0={wgts[0]}, w1={wgts[1]}, w2={wgts[2]}, w3={wgts[3]}");
Assert.IsTrue((diag02 || diag13) && !(diag02 && diag13));
}
public void Setup()
{
m_MousePosition = Vector2.zero;
m_HoveredVertex = -1;
m_HoveredEdge = -1;
m_ClosestEdge = -1;
m_View = Substitute.For <ISpriteMeshView>();
m_View.mouseWorldPosition.Returns(x => m_MousePosition);
m_View.hoveredVertex.Returns(x => m_HoveredVertex);
m_View.hoveredEdge.Returns(x => m_HoveredEdge);
m_View.closestEdge.Returns(x => m_ClosestEdge);
m_View.WorldToScreen(Arg.Any <Vector2>()).Returns(x => ((Vector2)x[0] * 100f));
m_View.IsActionTriggered(Arg.Any <MeshEditorAction>()).Returns(true);
m_SelectedVertices = new List <int>();
m_Selection = Substitute.For <ISelection <int> >();
m_Selection.Count.Returns(x => m_SelectedVertices.Count);
m_Selection.Contains(Arg.Any <int>()).Returns(x => m_SelectedVertices.Contains((int)x[0]));
m_Selection.elements.Returns(x => m_SelectedVertices.ToArray());
m_Selection.activeElement.Returns(x =>
{
if (m_SelectedVertices.Count == 0)
{
return(-1);
}
return(m_SelectedVertices[0]);
});
m_CacheUndo = Substitute.For <ICacheUndo>();
m_Triangulator = Substitute.For <ITriangulator>();
m_SpriteMeshData = new SpriteMeshData();
m_SpriteMeshData.frame = new Rect(0f, 0f, 100f, 100f);
m_SpriteMeshController = new SpriteMeshController();
m_SpriteMeshController.frame = m_SpriteMeshData.frame;
m_SpriteMeshController.spriteMeshData = m_SpriteMeshData;
m_SpriteMeshController.spriteMeshView = m_View;
m_SpriteMeshController.selection = m_Selection;
m_SpriteMeshController.cacheUndo = m_CacheUndo;
m_SpriteMeshController.triangulator = m_Triangulator;
m_SpriteMeshDataController.spriteMeshData = m_SpriteMeshData;
}
public static void Subdivide(this SpriteMeshData spriteMeshData, ITriangulator triangulator, float largestAreaFactor)
{
Debug.Assert(triangulator != null);
m_VerticesTemp.Clear();
for (int i = 0; i < spriteMeshData.vertices.Count; ++i)
{
m_VerticesTemp.Add(spriteMeshData.vertices[i].position);
}
triangulator.Tessellate(0f, 0f, 0f, largestAreaFactor, 100, m_VerticesTemp, spriteMeshData.edges, spriteMeshData.indices);
spriteMeshData.vertices.Clear();
for (int i = 0; i < m_VerticesTemp.Count; ++i)
{
spriteMeshData.vertices.Add(new Vertex2D(m_VerticesTemp[i]));
}
}
public void Triangulate(ITriangulator triangulator)
{
Debug.Assert(spriteMeshData != null);
Debug.Assert(triangulator != null);
FillMeshDataContainers(ref m_VerticesTemp, ref m_EdgesTemp, out var weightData, out var hasWeightData);
var indices = new List <int>();
triangulator.Triangulate(m_VerticesTemp, m_EdgesTemp, indices);
if (m_VerticesTemp.Count == 0)
{
spriteMeshData.Clear();
CreateQuad();
FillMeshDataContainers(ref m_VerticesTemp, ref m_EdgesTemp, out weightData, out hasWeightData);
indices.Clear();
triangulator.Triangulate(m_VerticesTemp, m_EdgesTemp, indices);
}
spriteMeshData.Clear();
spriteMeshData.edges.AddRange(m_EdgesTemp);
spriteMeshData.indices.AddRange(indices);
var hasNewVertices = m_VerticesTemp.Count != weightData.Count;
for (var i = 0; i < m_VerticesTemp.Count; ++i)
{
var boneWeight = default(BoneWeight);
if (!hasNewVertices)
{
boneWeight = weightData[i].ToBoneWeight(true);
}
spriteMeshData.AddVertex(m_VerticesTemp[i], boneWeight);
}
if (hasNewVertices && hasWeightData)
{
CalculateWeights(new BoundedBiharmonicWeightsGenerator(), null, 0.01f);
}
}
public void Setup()
{
m_MousePosition = Vector2.zero;
m_HoveredVertex = -1;
m_HoveredEdge = -1;
m_ClosestEdge = -1;
m_View = Substitute.For <ISpriteMeshView>();
m_View.mouseWorldPosition.Returns(x => m_MousePosition);
m_View.hoveredVertex.Returns(x => m_HoveredVertex);
m_View.hoveredEdge.Returns(x => m_HoveredEdge);
m_View.closestEdge.Returns(x => m_ClosestEdge);
m_View.WorldToScreen(Arg.Any <Vector2>()).Returns(x => ((Vector2)x[0] * 100f));
m_SelectedVertices = new List <int>();
m_Selection = Substitute.For <ISelection>();
m_Selection.Count.Returns(x => m_SelectedVertices.Count);
m_Selection.IsSelected(Arg.Any <int>()).Returns(x => m_SelectedVertices.Contains((int)x[0]));
m_Selection.GetEnumerator().Returns(x => m_SelectedVertices.GetEnumerator());
m_Selection.single.Returns(x =>
{
if (m_SelectedVertices.Count == 1)
{
return(m_SelectedVertices[0]);
}
return(-1);
});
m_UndoObject = Substitute.For <IUndoObject>();
m_Triangulator = Substitute.For <ITriangulator>();
m_SpriteMeshData = new SpriteMeshData();
m_SpriteMeshData.frame = new Rect(0f, 0f, 100f, 100f);
m_SpriteMeshController = new SpriteMeshController();
m_SpriteMeshController.spriteMeshData = m_SpriteMeshData;
m_SpriteMeshController.spriteMeshView = m_View;
m_SpriteMeshController.selection = m_Selection;
m_SpriteMeshController.undoObject = m_UndoObject;
m_SpriteMeshController.triangulator = m_Triangulator;
}
public GenericMesher(ITriangulator triangulator)
: this(triangulator, RobustPredicates.Default)
{
}
public GenericMesher()
{
this.predicates = new RobustPredicates();
this.triangulator = new Dwyer(this.predicates);
}
public ModelSurfaceAreaCalculator(ITriangulator triangulator) => _triangulator = triangulator;
internal override void OnCreate()
{
m_Triangulator = new Triangulator();
m_OutlineGenerator = new OutlineGenerator();
m_WeightGenerator = new BoundedBiharmonicWeightsGenerator();
}
public GenericMesher(ITriangulator triangulator)
: this(triangulator, new Configuration())
{
}
internal override void OnCreate()
{
m_SpriteMeshController = new SpriteMeshController();
m_SpriteMeshView = new SpriteMeshView(new GUIWrapper());
m_Triangulator = new Triangulator();
}
public bool Run()
{
// Start up!
Program.PrintTitle("EXPRESSION TRIANGULATION");
Console.WriteLine("This launcher run all the following algorithms:\n");
ITriangulator[] t = new ITriangulator[] { Program.UserInstantiation <ITriangulator>("triangulation method") };
// Equation
Console.WriteLine("Please enter equation containing x, y and z:");
var values = new HashSet <char>(new[] { 'x', 'y', 'z' });
IExpression expr = null;
bool parsed = false;
while (!parsed)
{
try {
expr = ExpressionParser.Parse(Console.ReadLine());
if (expr.CanCompute(values))
{
parsed = true;
}
else
{
Console.WriteLine("\nInvalid input! The only valid variables are x, y and z");
}
} catch (ArgumentException) {
Console.WriteLine("\nInvalid input! Please enter a valid expression");
}
}
Console.WriteLine("Understood that as:");
Console.WriteLine(expr.ToString());
SDF[] sdf = new SDF[] { new ParsedExpression(expr) };
// Debug?
var debugView = AskUser("Enable step visualizer triangulation?");
// Triangulate!
Tuple <Log, IPolygon, string, long>[] result;
if (debugView)
{
result = TriangulateWithLog(t, sdf);
}
else
{
result = Triangulate(t, sdf);
}
// Show result!
if (debugView)
{
if (!LaunchLogView(result))
{
Export(result);
}
}
else
{
if (!LaunchView(result))
{
Export(result);
}
}
return(!AskUser("Restart the application?"));
}
private void OnNewTriangulationWasBuilt(object sender, ITriangulator triangulation)
{
Initialize(triangulation);
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericMesher" /> class.
/// </summary>
/// <param name="triangulator">The <see cref="ITriangulator" /> algorithm implementation.</param>
public GenericMesher(ITriangulator triangulator)
: this(triangulator, new Configuration())
{
}
public GenericMesher(ITriangulator triangulator, Configuration config)
{
this.config = config;
this.triangulator = triangulator;
}
public bool Run()
{
Program.PrintTitle("SETUP - FIGURE BUILDER");
Console.WriteLine("This launcher let's you create a SDF operator tree");
SDF figure = userSDF();
Program.PrintTitle("FIGURE BUILDER");
Console.WriteLine("You choose to create:");
Console.WriteLine(figure.ToString());
Console.WriteLine("Nice choice!");
// # of triangulations?
Console.WriteLine("\nNumber of simultaneous triangulations?");
Console.Write("> ");
var n = 1;
int.TryParse(Console.ReadLine(), out n);
// Setup...
var triangulator = new ITriangulator[n];
var sdf = new SDF[n];
for (int i = 0; i < n; i++)
{
Program.PrintTitle($"PERFORM SETUP {i + 1} of {n}");
triangulator[i] = Program.UserInstantiation <ITriangulator>("triangulation method");
sdf[i] = figure;
}
// Debug?
var debugView = AskUser("Enable step visualizer triangulation?");
// Triangulate!
Tuple <Log, IPolygon, string, long>[] result;
if (debugView)
{
result = TriangulateWithLog(triangulator, sdf);
}
else
{
result = Triangulate(triangulator, sdf);
}
// Show result!
if (debugView)
{
if (!LaunchLogView(result))
{
Export(result);
}
}
else
{
if (!LaunchView(result))
{
Export(result);
}
}
return(!AskUser("Restart the application?"));
}
public PointIsInsideMesh(ITriangulator triangulator, Vector3 point)
{
_triangulator = triangulator;
_point = point;
}
public GenericMesher(ITriangulator triangulator, IPredicates predicates)
{
this.predicates = predicates;
this.triangulator = triangulator;
}
/// <summary>
/// Triangulates a polygon, applying quality and constraint options.
/// </summary>
/// <param name="options">Constraint options.</param>
/// <param name="quality">Quality options.</param>
/// <param name="triangulator">The triangulation algorithm.</param>
public static IMesh Triangulate(this IPolygon polygon, ConstraintOptions options, QualityOptions quality,
ITriangulator triangulator)
{
return (new GenericMesher(triangulator)).Triangulate(polygon, options, quality);
}
/// <summary>
/// Triangulates a polygon, applying quality and constraint options.
/// </summary>
/// <param name="polygon">Polygon instance.</param>
/// <param name="options">Constraint options.</param>
/// <param name="quality">Quality options.</param>
/// <param name="triangulator">The triangulation algorithm.</param>
public static IMesh Triangulate(this IPolygon polygon, ConstraintOptions options, QualityOptions quality,
ITriangulator triangulator)
{
return((new GenericMesher(triangulator)).Triangulate(polygon, options, quality));
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericMesher" /> class.
/// </summary>
/// <param name="triangulator">The <see cref="ITriangulator" /> algorithm implementation.</param>
/// <param name="config">The <see cref="Configuration" />.</param>
public GenericMesher(ITriangulator triangulator, Configuration config)
{
this.config = config;
this.triangulator = triangulator;
}
public TriangleExtractor(ITriangulator triangulator) => _triangulator = triangulator;
