/// <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 static IMesh CreateMesh()
{
// Generate the input geometry.
var poly = Example3.CreatePolygon(h);
// Since we want to do CVT smoothing, ensure that the mesh
// is conforming Delaunay.
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
// Set maximum area quality option (we don't need to set a minimum
// angle, since smoothing will improve the triangle shapes).
var quality = new QualityOptions()
{
// Given the boundary segment size, we set a maximum
// area constraint assuming equilateral triangles. The
// relaxation parameter is chosen to reduce the deviation
// from this ideal value.
MaximumArea = (Math.Sqrt(3) / 4 * h * h) * relax
};
// Generate mesh using the polygons Triangulate extension method.
var mesh = poly.Triangulate(options, quality);
var smoother = new SimpleSmoother();
// Smooth mesh.
smoother.Smooth(mesh, 25, .05);
return(mesh);
}
public void Triangulate(Mesh m, List <Vector2> points, List <List <Vector2> > holes)
{
List <int> indices = null;
List <Vector3> vertices = null;
var options = new ConstraintOptions()
{
ConformingDelaunay = conformingDelaunay
};
var quality = new QualityOptions()
{
MinimumAngle = minimumAngle, MaximumArea = maximumArea
};
ConditionedTriangulator.triangulate(points, holes, out indices, out vertices, options, quality);
m.Clear();
m.vertices = vertices.ToArray();
m.triangles = indices.ToArray();
m.RecalculateNormals();
Vector2[] uvs = new Vector2[m.vertices.Length];
for (int i = 0; i < uvs.Length; i++)
{
uvs [i] = new Vector2(m.vertices[i].x, m.vertices[i].y);
}
m.uv = uvs;
}
private static Mesh CreateMesh()
{
// Generate the input geometry.
var polygon = Example2.CreateRingPolygon(4.0, 0.2);
// Since we want to do CVT smoothing, ensure that the mesh
// is conforming Delaunay.
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 25.0
};
// Generate mesh.
var mesh = (Mesh)polygon.Triangulate(options, quality);
// The boundary segments have a length of 0.2, so we set a
// maximum area constraint assuming equilateral triangles.
quality.MaximumArea = (Math.Sqrt(3) / 4 * 0.2 * 0.2) * 1.45;
mesh.Refine(quality);
// Do some smoothing.
(new SimpleSmoother()).Smooth(mesh, 100);
return(mesh);
}
public static Mesh GenerateTriangulatedMesh(int size, DistributionData data)
{
Polygon polygon = new Polygon();
switch (data.distributionType)
{
case DistributionType.Random:
polygon = PointSampling.GenerateRandomDistribution(size, data.pointDensity);
break;
case DistributionType.Poisson:
polygon = PointSampling.GeneratePoissonDistribution(data.radius, size, data.rejectionSamples);
break;
default:
throw new ArgumentOutOfRangeException();
}
ConstraintOptions constraintOptions = new ConstraintOptions();
constraintOptions.ConformingDelaunay = true;
TriangleNet.Mesh mesh = polygon.Triangulate(constraintOptions) as TriangleNet.Mesh;
return(mesh);
}
public static bool Run(bool print = false)
{
const int N = 50;
// Generate point set.
var points = Generate.RandomPoints(N, new Rectangle(0, 0, 100, 100));
// We use a polygon as input to enable segment insertion on the convex hull.
var poly = new Polygon(N);
poly.Points.AddRange(points);
// Set the 'convex' option to enclose the convex hull with segments.
var options = new ConstraintOptions()
{
Convex = true
};
// Generate mesh.
var mesh = poly.Triangulate(options);
if (print)
{
SvgImage.Save(mesh, "example-2.svg", 500);
}
return(CheckConvexHull(mesh.Segments));
}
public void TestSmoothWithDuplicate()
{
var poly = GetPolygon();
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 30.0
};
var mesh = poly.Triangulate(options, quality);
Assert.AreEqual(1, mesh.Vertices
.Where(v => v.Type == VertexType.UndeadVertex)
.Count());
quality.MaximumArea = 0.2;
mesh.Refine(quality, true);
Assert.AreEqual(1, mesh.Vertices
.Where(v => v.Type == VertexType.UndeadVertex)
.Count());
var smoother = new SimpleSmoother();
// Smooth mesh.
Assert.IsTrue(smoother.Smooth(mesh, 25) > 0);
}
// generate mesh
private TriangleNet.Mesh DxfMesh(Polygon poly)
{
// routine to generate a mesh from the contnet of poly
// Set quality and constraint options.
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 15.0, MaximumArea = mds.minimumMeshArea
};
// create the mesh
mesh = (TriangleNet.Mesh)poly.Triangulate(options, quality);
// make sure there are at least 1000 elements in the mesh
while (mesh.Triangles.Count < 1000)
{
mds.minimumMeshArea = mds.minimumMeshArea / 2;
quality.MaximumArea = mds.minimumMeshArea;
mesh = (TriangleNet.Mesh)poly.Triangulate(options, quality);
}
// smooth the mesh
var smoother = new SimpleSmoother();
smoother.Smooth(mesh);
return(mesh);
}
public static Mesh Triangulate(Polyline poly, List <Point3d> points, Plane plane, double min_angle = 0.436332, double max_angle = Math.PI, double max_area = double.MaxValue)
{
min_angle = Rhino.RhinoMath.ToDegrees(min_angle);
max_angle = Rhino.RhinoMath.ToDegrees(max_angle);
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = min_angle, MaximumAngle = max_angle, MaximumArea = max_area, VariableArea = true
};
Contour cnt = ToContour(poly, plane);
Polygon pgon = new Polygon();
pgon.Add(cnt);
foreach (Point3d pt in points)
{
pgon.Add(new Vertex(pt.X, pt.Y));
}
var tmesh = pgon.Triangulate(options, quality);
return(ToRhinoMesh(tmesh));
}
public static Mesh Triangulate(this SectionDefinition sec, Polygon polygon)
{
var options = new ConstraintOptions();
options.ConformingDelaunay = true;
var quality = new QualityOptions()
{
MinimumAngle = sec.SolutionSettings.MinimumAngle,
MaximumAngle = sec.SolutionSettings.MaximumAngle,
MaximumArea = sec.SolutionSettings.MaximumArea
};
//=======temp meshing to find some data
var dummyMesh = (Mesh)polygon.Triangulate();
if (sec.SolutionSettings.MaximumArea == 0.0)
{
//auto calc
var area = CalculateMeshArea(dummyMesh);
quality.MaximumArea = sec.SolutionSettings.Roughness * area;
}
//\=========
var mesh = (Mesh)polygon.Triangulate(options, quality);
return(mesh);
}
public void Initiate()
{
heights = new List <float>();
polygon = new Polygon();
if (randomPoints == true)
{
for (int i = 0; i < pointDensity; i++)
{
var x = Random.Range(.0f, sizeX);
var y = Random.Range(.0f, sizeY);
polygon.Add(new Vertex(x, y));
}
}
else
{
poissonPoints = PoissonDiscSampling.GeneratePoints(minDistancePerPoint, new Vector2(sizeX, sizeY), rejectionSamples);
for (int i = 0; i < poissonPoints.Count; i++)
{
polygon.Add(new Vertex(poissonPoints[i].x, poissonPoints[i].y));
}
}
ConstraintOptions constraints = new ConstraintOptions();
constraints.ConformingDelaunay = true;
mesh = polygon.Triangulate(constraints) as TriangleNet.Mesh;
ShapeTerrain();
GenerateMesh();
}
private void UpdateCaveBackground(Vector2[][] segments)
{
var outerSteps = Mathf.FloorToInt(outerRadius * Mathf.PI * 2 / 4);
var outerPolygon = Enumerable.Range(0, outerSteps).Select(i => {
var angle = 2f * Mathf.PI * i / outerSteps;
return(new Vector2(Mathf.Sin(angle), Mathf.Cos(angle)) * outerRadius);
});
var innerSteps = Mathf.FloorToInt(innerRadius * Mathf.PI * 2 / 4);
var innerPolygon = Enumerable.Range(0, innerSteps).Select(i => {
var angle = -2f * Mathf.PI * i / innerSteps;
return(new Vector2(Mathf.Sin(angle), Mathf.Cos(angle)) * innerRadius);
});
var area = new List <IEnumerable <Vector2> >(2);
area.Add(outerPolygon);
area.Add(innerPolygon);
var constraint = new ConstraintOptions();
constraint.ConformingDelaunay = true;
var quality = new QualityOptions();
quality.MaximumArea = 10;
var data = segments.AsParallel().Select(segment => {
var segmentPolygon = new PSPolygon(segment);
var doNotWrapUV = segmentPolygon.Bounds.center.x < 0 && segmentPolygon.Bounds.center.y < 0;
var poly = new Polygon();
foreach (var polygon in PSClipperHelper.intersection(area, segment))
{
poly.Add(createContour(polygon));
}
var imesh = poly.Triangulate(constraint, quality);
var vertices = new List <Vector2>();
var triangles = new List <int>();
getTriangles(imesh, ref vertices, ref triangles);
var uv = vertices.Select(v => getUV(v, doNotWrapUV)).ToList();
var colors = vertices.Select(v => (Color32)backgroundTintColor(v, doNotWrapUV)).ToList();
return(new { vertices, triangles, uv, colors });
}).ToList();
var currentIndex = 0;
var tris = new List <int>();
foreach (var d in data)
{
tris.AddRange(d.triangles.Select(i => currentIndex + i));
currentIndex += d.vertices.Count;
}
UpdateMesh(
caveBackground,
data.SelectMany(d => d.vertices).Select(v => (Vector3)v),
data.SelectMany(d => d.uv),
null,
data.SelectMany(d => d.colors),
tris);
}
internal void CalcDL(Structure str)
{
if (str == null || str.RedPlanning == null || str.RedPlanning.Count == 0)
{
return;
}
List <Vertex> vrtxs = new List <Vertex>();
Vertex vrtx;
int i = 1;
foreach (PlanningVertex item in str.RedPlanning)
{
vrtx = new Vertex(item.X, item.Y, item.Number, 2);
vrtx.Attributes[0] = item.Red;
vrtx.Attributes[1] = item.Black;
vrtxs.Add(vrtx);
i++;
}
Contour cnt = new Contour(vrtxs);
TriangleNet.Geometry.Polygon polygon = new TriangleNet.Geometry.Polygon();
polygon.Add(cnt);
GenericMesher mesher = new GenericMesher();
ConstraintOptions constraint = new ConstraintOptions();
constraint.Convex = true;
Mesh meshPlanning = (Mesh)mesher.Triangulate(polygon, constraint);
TriangleQuadTree meshTree = new TriangleQuadTree(meshPlanning);
TriangleNet.Topology.Triangle trgl = (TriangleNet.Topology.Triangle)meshTree.Query(X, Y);
if (trgl == null)
{
Dictionary <Vertex, double> valuePairs = new Dictionary <Vertex, double>();
Line2d ln;
foreach (Vertex item in meshPlanning.Vertices)
{
ln = new Line2d(new Point2d(X, Y), new Point2d(item.X, item.Y));
valuePairs.Add(item, ln.Length);
}
IOrderedEnumerable <KeyValuePair <Vertex, double> > selected = from v in valuePairs // определяем каждый объект как
orderby v.Value // упорядочиваем по возрастанию
select v; // выбираем объект
List <KeyValuePair <Vertex, double> > lst = selected.ToList();
foreach (TriangleNet.Topology.Triangle item in meshPlanning.Triangles)
{
if (item.Contains(lst[0].Key) && item.Contains(lst[1].Key))
{
trgl = item; break;
}
}
}
vrtx = new Vertex(X, Y, Number, 2);
Interpolation.InterpolateAttributes(vrtx, trgl, 1);
DL = Math.Round(vrtx.Attributes[0], 3);
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleSmoother" /> class.
/// </summary>
/// <param name="factory">Voronoi object factory.</param>
/// <param name="config">Configuration.</param>
public SimpleSmoother(IVoronoiFactory factory, Configuration config)
{
this.factory = factory;
this.config = config;
this.options = new ConstraintOptions()
{
ConformingDelaunay = true
};
}
private Mesh GenerateMesh()
{
var options = new ConstraintOptions();
var quality = new QualityOptions();
Mesh mesh = (Mesh)GeneratePolygon().Triangulate(options, quality);
UpdateOpenEdges(mesh);
return(mesh);
}
public static void ExtrudeText(this MeshBuilder builder, string text, string font, FontStyle fontStyle, FontWeight fontWeight, double fontSize, Vector3D textDirection, Point3D p0, Point3D p1)
{
var outlineList = GetTextOutlines(text, font, fontStyle, fontWeight, fontSize);
// Build the polygon to mesh (using Triangle.NET to triangulate)
var polygon = new TriangleNet.Geometry.Polygon();
int marker = 0;
foreach (var outlines in outlineList)
{
var outerOutline = outlines.OrderBy(x => x.AreaOfSegment()).Last();
for (int i = 0; i < outlines.Count; i++)
{
var outline = outlines[i];
var isHole = i != outlines.Count - 1 && IsPointInPolygon(outerOutline, outline[0]);
polygon.AddContour(outline.Select(p => new Vertex(p.X, p.Y)), marker++, isHole);
builder.AddExtrudedSegments(outline.ToSegments().Select(x => new SharpDX.Vector2((float)x.X, (float)x.Y)).ToList(),
textDirection, p0, p1);
}
}
var mesher = new GenericMesher();
var options = new ConstraintOptions();
var mesh = mesher.Triangulate(polygon, options);
var u = textDirection;
u.Normalize();
var z = p1 - p0;
z.Normalize();
var v = Vector3D.Cross(z, u);
// Convert the triangles
foreach (var t in mesh.Triangles)
{
var v0 = t.GetVertex(2);
var v1 = t.GetVertex(1);
var v2 = t.GetVertex(0);
// Add the top triangle.
// Project the X/Y vertices onto a plane defined by textdirection, p0 and p1.
builder.AddTriangle(v0.Project(p0, u, v, z, 1), v1.Project(p0, u, v, z, 1), v2.Project(p0, u, v, z, 1));
// Add the bottom triangle.
builder.AddTriangle(v2.Project(p0, u, v, z, 0), v1.Project(p0, u, v, z, 0), v0.Project(p0, u, v, z, 0));
}
if (builder.CreateNormals)
{
builder.Normals = null;
builder.ComputeNormalsAndTangents(MeshFaces.Default, builder.HasTangents);
}
}
public void OnEnable()
{
options = new ConstraintOptions()
{
ConformingDelaunay = true
};
quality = new QualityOptions()
{
MinimumAngle = 25.0
};
quality.MaximumArea = 100;
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleSmoother" /> class.
/// </summary>
public SimpleSmoother(IVoronoiFactory factory)
{
this.factory = factory;
this.pool = new TrianglePool();
this.config = new Configuration(
() => RobustPredicates.Default,
() => pool.Restart());
this.options = new ConstraintOptions()
{
ConformingDelaunay = true
};
}
private object _triangulateTerrain(object state)
{
var setupState = state as SetupState;
Debug.Assert(setupState != null, nameof(setupState) + " != null");
var options = new ConstraintOptions {
ConformingDelaunay = true
};
setupState.TriangulatedMesh = setupState.Polygon.Triangulate(options);
return(setupState);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var polygon = GetPolygone();
textBox1.Text = textBox1.Text != String.Empty ? textBox1.Text.Replace('.', ',') : "1";
if (Math.Abs(Convert.ToDouble(textBox1.Text)) > 0)
{
var area = Math.Abs(Convert.ToDouble(textBox1.Text));
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 30, MaximumArea = area
};
this.mesh = polygon.Triangulate(options, quality);
DrawLines(this.mesh.Vertices.ToArray());
DrawVertexs();
var nt = this.mesh.Triangles.Select(el => new List <Vertex>()
{
el.GetVertex(0),
el.GetVertex(1),
el.GetVertex(2)
});
var ct = this.mesh.Vertices;
var ntg = GetSegments();
JsonParser.Write(nt.ToList(), "NT.json"); //трикутники
JsonParser.Write(ct.ToList(), "CT.json"); //точки
JsonParser.Write(ntg.ToList(), "NTG.json"); //сегменти
}
else
{
throw new Exception();
}
}
catch
{
textBox1.Text = "Wrong input data";
}
}
public static Mesh GetMeshFromMesh(UnityEngine.Mesh m)
{
Polygon polygon = new Polygon();
foreach (Vector3 meshVertex in m.vertices)
{
polygon.Add(new Vertex(meshVertex.x, meshVertex.z));
}
ConstraintOptions constraintOptions = new ConstraintOptions();
constraintOptions.ConformingDelaunay = true;
TriangleNet.Mesh mesh = polygon.Triangulate(constraintOptions) as TriangleNet.Mesh;
return(mesh);
}
public void BuildShapeCache()
{
if (shapecache)
{
return;
}
shapecache = true;
foreach (var a in OutlineShapes)
{
if (a.Hole == false)
{
var polygon = new Polygon();
List <Vertex> V = new List <Vertex>();
for (int i = 0; i < a.Count(); i++)
{
V.Add(new Vertex(a.Vertices[i].X, a.Vertices[i].Y));
}
polygon.AddContour(V);
var options = new ConstraintOptions()
{
ConformingDelaunay = false
};
var quality = new QualityOptions()
{
};
var mesh = polygon.Triangulate(options, quality);
foreach (var t in mesh.Triangles)
{
var A = t.GetVertex(0);
var B = t.GetVertex(1);
var C = t.GetVertex(2);
ShapeCacheTriangles.Add(new Triangle()
{
A = new PointD(A.X, A.Y),
B = new PointD(B.X, B.Y),
C = new PointD(C.X, C.Y)
});
}
}
}
}
public void FillShape(SolidBrush P, PolyLine Shape)
{
// GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
if (P.Color.A < 255)
{
GL.Enable(EnableCap.Blend);
}
var polygon = new Polygon();
List <Vertex> V = new List <Vertex>();
for (int i = 0; i < Shape.Count(); i++)
{
V.Add(new Vertex(Shape.Vertices[i].X, Shape.Vertices[i].Y));
}
polygon.AddContour(V);
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 25
};
var mesh = polygon.Triangulate(options, quality);
GL.Begin(BeginMode.Triangles);
GL.Color4(P.Color.R, P.Color.G, P.Color.B, P.Color.A);
foreach (var t in mesh.Triangles)
{
var A = t.GetVertex(0);
var B = t.GetVertex(1);
var C = t.GetVertex(2);
GL.Vertex2(A.X, A.Y);
GL.Vertex2(B.X, B.Y);
GL.Vertex2(C.X, C.Y);
}
GL.End();
}
public void FillPath(Color c, GraphicsPath path)
{
GraphicsPathIterator pathIterator = new GraphicsPathIterator(path);
var polygon = new Polygon();
for (int i = 0; i < pathIterator.SubpathCount; i++)
{
int strIdx, endIdx;
bool bClosedCurve;
pathIterator.NextSubpath(out strIdx, out endIdx, out bClosedCurve);
List <TriangleNet.Geometry.Vertex> V = new List <TriangleNet.Geometry.Vertex>();
for (int j = strIdx; j <= endIdx; j++)
{
V.Add(new TriangleNet.Geometry.Vertex(path.PathPoints[j].X, path.PathPoints[j].Y));
}
polygon.AddContour(V);
}
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 25
};
var mesh = polygon.Triangulate(options, quality);
foreach (var t in mesh.Triangles)
{
var A = t.GetVertex(0);
var B = t.GetVertex(1);
var C = t.GetVertex(2);
AddTriangle((float)A.X, (float)A.Y, (float)B.X, (float)B.Y, (float)C.X, (float)C.Y, c);
}
}
void SetMesh(Polygon polygon, out List <Vector3> vertices, out List <int> triangles)
{
var options = new ConstraintOptions()
{
};
var quality = new QualityOptions()
{
// MinimumAngle = 25,
// MaximumArea = 0.01d
};
// Triangulate the polygon
var polyMesh = polygon.Triangulate(options, quality);
var polyVertices = polyMesh.Vertices;
var polyTriangles = polyMesh.Triangles;
vertices = new List <Vector3> ();
triangles = getTriangles(polyTriangles, vertices);
}
public static TriangleNet.Mesh GetTriangleMesh(this IPolygonEntity polyEntity, float segmentLength = 0.1F)
{
int count = polyEntity.Points.Count;
var triPolygon = new Polygon();
for (int i = 0, j = 1; i < count; i++, j = (i + 1) % count)
{
var curPoint = polyEntity.Points[i];
var nextPoint = polyEntity.Points[j];
var dis = curPoint.DistanceTo(nextPoint);
var num = (int)(dis / segmentLength);
int id = i + 1;
var segments = curPoint.SplitToSegments(nextPoint, num).Select(p => new Vertex(p.x, p.y, id)).ToArray();
for (int m = 0, n = 1; m < segments.Count( ) - 1; m++, n = m + 1)
{
triPolygon.Add(new Segment(segments [m], segments [n], id), 0);
}
}
//等边三角形面积公式 ： S=√3a²/4; √3/4 = 0.443F;
var area = 0.443F * segmentLength * segmentLength;// * 1.25F;
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 30F, MaximumArea = area
}; // 0.2F };
var triMesh = (TriangleNet.Mesh)triPolygon.Triangulate(options, quality);
triMesh.Renumber( );
return(triMesh);
}
public Graph(MainWindow window)
{
myGui = window;
renderManager = new RenderManager();
control = new TriangleNet.Rendering.GDI.RenderControl();
Options = new ConstraintOptions();
Options.ConformingDelaunay = false;
Options.SegmentSplitting = 0;
if (control != null)
{
InitializeRenderControl((Control)control);
renderManager.Initialize(control);
control.Refresh();
}
else
{
MessageBox.Show("Error", "Failed to initialize renderer.");
}
}
public void GenerateMeshData(ConstraintOptions options)
{
var polygon = new TriangleNet.Geometry.Polygon();
vertices = surroundingCorners
.Where(corner => isFaceBorderCorner | corner != borderCorner)
.Select(corner => corner.vertex - vertex)
.OrderBy(difference => difference.GetAngle())
.ToArray();
normals = new Vertex[vertices.Length];
for (int q = 0; q < vertices.Length; q++)
{
Vertex v0 = vertices[q];
Vertex v1 = vertices[(q + 1) % vertices.Length];
normals[q] = (v1 - v0).Perpendicular().Normalize();
}
foreach (Vertex vertex in vertices)
{
polygon.Add(vertex);
}
Mesh mesh = (Mesh)polygon.Triangulate(options);
triangles = new int[mesh.triangles.Count * 3];
int index = 0;
// if conforming delauny is off Id should eqaul index
// if not I will have to develop a work around
foreach (var triangle in mesh.triangles)
{
var vertices = triangle.vertices;
triangles[index * 3] = vertices[2].id;
triangles[index * 3 + 1] = vertices[1].id;
triangles[index * 3 + 2] = vertices[0].id;
index++;
}
}
public Region(RegionRule x, int[,] biomeMap)
{
Id = regionCount++;
biome = x.biome;
foreach (var edge in x.edges)
{
foreach (int direction in startDirections(edge.touchPoint, biomeMap))
{
calculateBounds(edge, direction, biomeMap);
}
}
Simplify();
if (holes.Count == 0)
{
foreach (var edge in x.edges)
{
foreach (int direction in startDirections(edge.touchPoint, biomeMap))
{
calculateBounds(edge, direction, biomeMap);
}
}
}
outerEdge = holes.First().Border;
holes.RemoveAt(0);
//holes.ForEach(hole => hole.Border.Reverse());
var options = new ConstraintOptions()
{
ConformingDelaunay = true
};
var quality = new QualityOptions()
{
MinimumAngle = 25
};
var polygon = getPolygon();
pathMesh = polygon.Triangulate(options, quality);
graphicsMesh = polygon.Triangulate();
}
public void FillPath(Color c, PointF [] path)
{
var polygon = new Polygon();
List <TriangleNet.Geometry.Vertex> V = new List <TriangleNet.Geometry.Vertex>();
for (int j = 0; j < path.Length; j++)
{
V.Add(new TriangleNet.Geometry.Vertex(path[j].X, path[j].Y));
}
polygon.AddContour(V);
if (V.Count >= 3)
{
try
{
var options = new ConstraintOptions()
{
};
var quality = new QualityOptions()
{
};
var mesh = polygon.Triangulate(options, quality);
foreach (var t in mesh.Triangles)
{
var A = t.GetVertex(0);
var B = t.GetVertex(1);
var C = t.GetVertex(2);
AddTriangle((float)A.X, (float)A.Y, (float)B.X, (float)B.Y, (float)C.X, (float)C.Y, c);
}
}
catch (Exception)
{
}
}
}
