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 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 ); }