public static void Triangulate(TriangulationAlgorithm algorithm, Triangulatable t) {
TriangulationContext tcx;
// long time = System.nanoTime();
tcx = CreateContext(algorithm);
tcx.PrepareTriangulation(t);
Triangulate(tcx);
// logger.info( "Triangulation of {} points [{}ms]", tcx.getPoints().size(), ( System.nanoTime() - time ) / 1e6 );
}
public override void PrepareTriangulation(Triangulatable t)
{
base.PrepareTriangulation(t);
double xmax, xmin;
double ymax, ymin;
xmax = xmin = Points[0].X;
ymax = ymin = Points[0].Y;
// Calculate bounds. Should be combined with the sorting
foreach (TriangulationPoint p in Points)
{
if (p.X > xmax)
{
xmax = p.X;
}
if (p.X < xmin)
{
xmin = p.X;
}
if (p.Y > ymax)
{
ymax = p.Y;
}
if (p.Y < ymin)
{
ymin = p.Y;
}
}
double deltaX = ALPHA * (xmax - xmin);
double deltaY = ALPHA * (ymax - ymin);
TriangulationPoint p1 = new TriangulationPoint(xmax + deltaX, ymin - deltaY);
TriangulationPoint p2 = new TriangulationPoint(xmin - deltaX, ymin - deltaY);
Head = p1;
Tail = p2;
// long time = System.nanoTime();
// Sort the points along y-axis
Points.Sort(_comparator);
// logger.info( "Triangulation setup [{}ms]", ( System.nanoTime() - time ) / 1e6 );
}
private void MeshCleanReq(DelaunayTriangle triangle, Queue <DelaunayTriangle> trianglesToClean)
{
if (triangle != null && !triangle.IsInterior)
{
triangle.IsInterior = true;
Triangulatable.AddTriangle(triangle);
for (int i = 0; i < 3; i++)
{
if (!triangle.EdgeIsConstrained[i])
{
var neighbor = triangle.Neighbors[i];
if (neighbor != null && !neighbor.HasBeenCleaned)
{
trianglesToClean.Enqueue(neighbor);
}
}
}
}
}
public override void PrepareTriangulation(Triangulatable t)
{
base.PrepareTriangulation(t);
FP x;
FP fP = x = this.Points[0].X;
FP y;
FP fP2 = y = this.Points[0].Y;
foreach (TriangulationPoint current in this.Points)
{
bool flag = current.X > x;
if (flag)
{
x = current.X;
}
bool flag2 = current.X < fP;
if (flag2)
{
fP = current.X;
}
bool flag3 = current.Y > y;
if (flag3)
{
y = current.Y;
}
bool flag4 = current.Y < fP2;
if (flag4)
{
fP2 = current.Y;
}
}
FP y2 = DTSweepContext.ALPHA * (x - fP);
FP y3 = DTSweepContext.ALPHA * (y - fP2);
TriangulationPoint head = new TriangulationPoint(x + y2, fP2 - y3);
TriangulationPoint tail = new TriangulationPoint(fP - y2, fP2 - y3);
this.Head = head;
this.Tail = tail;
this.Points.Sort(this._comparator);
}
public override void PrepareTriangulation(Triangulatable t)
{
double num2;
double num4;
base.PrepareTriangulation(t);
double x = num2 = base.Points[0].X;
double y = num4 = base.Points[0].Y;
foreach (TriangulationPoint point in base.Points)
{
if (point.X > x)
{
x = point.X;
}
if (point.X < num2)
{
num2 = point.X;
}
if (point.Y > y)
{
y = point.Y;
}
if (point.Y < num4)
{
num4 = point.Y;
}
}
double num5 = this.ALPHA * (x - num2);
double num6 = this.ALPHA * (y - num4);
TriangulationPoint point2 = new TriangulationPoint(x + num5, num4 - num6);
TriangulationPoint point3 = new TriangulationPoint(num2 - num5, num4 - num6);
this.Head = point2;
this.Tail = point3;
base.Points.Sort(this._comparator);
}
private void MeshCleanReq(DelaunayTriangle triangle)
{
// if (triangle != null && !triangle.IsInterior) {
// triangle.IsInterior = true;
// Triangulatable.AddTriangle (triangle);
//
// for (int i = 0; i < 3; i++) {
// if (!triangle.EdgeIsConstrained [i]) {
// MeshCleanReq (triangle.Neighbors [i]);
// }
// }
// }
List <DelaunayTriangle> tris = new List <DelaunayTriangle>(Triangles.Count);
tris.Add(triangle);
while (tris.Count > 0)
{
DelaunayTriangle t = tris[tris.Count - 1];
tris.RemoveAt(tris.Count - 1);
if (t != null && !t.IsInterior)
{
t.IsInterior = true;
Triangulatable.AddTriangle(t);
for (int i = 0; i < 3; i++)
{
if (!t.EdgeIsConstrained[i])
{
tris.Add(t.Neighbors[i]);
}
}
}
}
}
public virtual void PrepareTriangulation(Triangulatable t)
{
Triangulatable = t;
TriangulationMode = t.TriangulationMode;
t.PrepareTriangulation(this);
}
public virtual void PrepareTriangulation(Triangulatable t)
{
Triangulatable = t;
TriangulationMode = t.TriangulationMode;
t.PrepareTriangulation(this);
}
public void FinalizeTriangulation()
{
Triangulatable.AddTriangles(Triangles);
Triangles.Clear();
}
public override void PrepareTriangulation(Triangulatable t)
{
base.PrepareTriangulation(t);
double xmax, xmin;
double ymax, ymin;
xmax = xmin = Points[0].x;
ymax = ymin = Points[0].y;
// Calculate bounds. Should be combined with the sorting
foreach (TriangulationPoint p in Points)
{
if (p.x > xmax)
xmax = p.x;
if (p.x < xmin)
xmin = p.x;
if (p.y > ymax)
ymax = p.y;
if (p.y < ymin)
ymin = p.y;
}
double deltaX = ALPHA*(xmax - xmin);
double deltaY = ALPHA*(ymax - ymin);
TriangulationPoint p1 = new TriangulationPoint(xmax + deltaX, ymin - deltaY);
TriangulationPoint p2 = new TriangulationPoint(xmin - deltaX, ymin - deltaY);
Head = p1;
Tail = p2;
// long time = System.nanoTime();
// Sort the points along y-axis
Points.Sort(_comparator);
// logger.info( "Triangulation setup [{}ms]", ( System.nanoTime() - time ) / 1e6 );
}
public override void PrepareTriangulation(Triangulatable t)
{
//--------------------
//initialization phase:
//all points are sorted regarding y coordinate,
//regardless of whether they define an edge or not.
//those points havingthe same y coordinates are also sorted
//in the x direction.
//Each point is associated with the information wheter nor not
//it is the upper ending point of one or more edge e^i
//--------------------
//the following creates 'initial triangle',
//max bounds,
//p1 and p2=> artificial points
//-------------------
//during the fininalization phase,
//all triangles, having at least one vertex among the
//artificial points, are erased.
base.PrepareTriangulation(t);
double xmax, xmin;
double ymax, ymin;
xmax = xmin = Points[0].X;
ymax = ymin = Points[0].Y;
// Calculate bounds. Should be combined with the sorting
var tmp_points = this.Points;
for (int i = tmp_points.Count - 1; i >= 0; --i)
{
var p = tmp_points[i];
if (p.X > xmax)
{
xmax = p.X;
}
if (p.X < xmin)
{
xmin = p.X;
}
if (p.Y > ymax)
{
ymax = p.Y;
}
if (p.Y < ymin)
{
ymin = p.Y;
}
}
double deltaX = ALPHA * (xmax - xmin);
double deltaY = ALPHA * (ymax - ymin);
TriangulationPoint p1 = new TriangulationPoint(xmax + deltaX, ymin - deltaY);
TriangulationPoint p2 = new TriangulationPoint(xmin - deltaX, ymin - deltaY);
Head = p1;
Tail = p2;
//long time = System.nanoTime();
//Sort the points along y-axis
Points.Sort(Compare);
//logger.info( "Triangulation setup [{}ms]", ( System.nanoTime() - time ) / 1e6 );
}
public override void PrepareTriangulation( Triangulatable t ) {
base.PrepareTriangulation(t);
double xmax, xmin;
double ymax, ymin;
int indexmax = 0, indexmin = 0;
xmax = xmin = Points[0].X;
ymax = ymin = Points[0].Y;
// Calculate bounds. Should be combined with the sorting
for (int i = 0; i < Points.Count; i++)
{
TriangulationPoint p = Points[i];
if (p.X > xmax)
{
xmax = p.X;
indexmax = i;
}
if (p.X < xmin)
{
xmin = p.X;
indexmin = i;
}
if (p.Y > ymax)
{
ymax = p.Y;
indexmax = i;
}
if (p.Y < ymin)
{
ymin = p.Y;
indexmin = i;
}
}
//foreach (TriangulationPoint p in Points) {
// if (p.X > xmax) xmax = p.X;
// if (p.X < xmin) xmin = p.X;
// if (p.Y > ymax) ymax = p.Y;
// if (p.Y < ymin) ymin = p.Y;
//}
double deltaX = ALPHA * (xmax - xmin);
double deltaY = ALPHA * (ymax - ymin);
TriangulationPoint p1 = new TriangulationPoint(xmax + deltaX, ymin - deltaY);
TriangulationPoint p2 = new TriangulationPoint(xmin - deltaX, ymin - deltaY);
Head = p1;
Head.index = indexmax;
Tail = p2;
Tail.index = indexmin;
// long time = System.nanoTime();
// Sort the points along y-axis
Points.Sort(_comparator);
// logger.info( "Triangulation setup [{}ms]", ( System.nanoTime() - time ) / 1e6 );
}
public static void Triangulate(TriangulationAlgorithm algorithm, Triangulatable t)
{
TriangulationContext tcx = CreateContext(algorithm);
tcx.PrepareTriangulation(t);
Triangulate(tcx);
}
public override void PrepareTriangulation(Triangulatable t)
{
base.PrepareTriangulation(t);
double xmax, xmin;
double ymax, ymin;
xmax = xmin = this.Points[0].X;
ymax = ymin = this.Points[0].Y;
// Calculate bounds. Should be combined with the sorting
foreach (TriangulationPoint p in this.Points)
{
if (p.X > xmax)
{
xmax = p.X;
}
if (p.X < xmin)
{
xmin = p.X;
}
if (p.Y > ymax)
{
ymax = p.Y;
}
if (p.Y < ymin)
{
ymin = p.Y;
}
}
double deltaX = this.ALPHA * (xmax - xmin);
double deltaY = this.ALPHA * (ymax - ymin);
TriangulationPoint p1 = new TriangulationPoint(xmax + deltaX, ymin - deltaY);
TriangulationPoint p2 = new TriangulationPoint(xmin - deltaX, ymin - deltaY);
this.Head = p1;
this.Tail = p2;
// long time = System.nanoTime();
// Sort the points along y-axis
this.Points.Sort(this._comparator);
// logger.info( "Triangulation setup [{}ms]", ( System.nanoTime() - time ) / 1e6 );
}
