DMesh3 BuildPlanarMesh(bool bPreservePolygon)
{
DMesh3 planarMesh = new DMesh3();
Vector2d center = CurveUtils2.CentroidVtx(Loop.Vertices);
int center_id = planarMesh.AppendVertex(new Vector3d(center.x, center.y, 0));
int prev_id = -1;
int first_id = -1;
foreach (Vector2d v in Loop.Vertices)
{
int next_id = planarMesh.AppendVertex(new Vector3d(v.x, v.y, Thickness));
if (prev_id > 0)
{
planarMesh.AppendTriangle(center_id, prev_id, next_id);
prev_id = next_id;
}
else
{
first_id = next_id;
prev_id = next_id;
}
}
planarMesh.AppendTriangle(center_id, prev_id, first_id);
if (ReverseOrientation)
{
planarMesh.ReverseOrientation();
}
Debug.Assert(planarMesh.CheckValidity());
double edge_len = (TargetEdgeLength == 0) ? Loop.AverageEdgeLength : TargetEdgeLength;
Remesher r = new Remesher(planarMesh);
r.SetTargetEdgeLength(edge_len);
r.SmoothSpeedT = 1.0f;
if (bPreservePolygon)
{
MeshConstraintUtil.FixAllBoundaryEdges(r);
}
else
{
MeshConstraintUtil.PreserveBoundaryLoops(r);
}
for (int k = 0; k < 20; ++k)
{
r.BasicRemeshPass();
}
return(planarMesh);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
DMesh3_goo dMsh_goo = null;
int numF = 0;
bool fixB = false;
bool projBack = false;
DA.GetData(0, ref dMsh_goo);
DA.GetData(1, ref numF);
DA.GetData(2, ref fixB);
DA.GetData(3, ref projBack);
DMesh3 dMsh_copy = new DMesh3(dMsh_goo.Value);
Reducer r = new Reducer(dMsh_copy);
if (fixB)
{
r.SetExternalConstraints(new MeshConstraints());
MeshConstraintUtil.PreserveBoundaryLoops(r.Constraints, dMsh_copy);
}
if (projBack)
{
DMeshAABBTree3 tree = new DMeshAABBTree3(new DMesh3(dMsh_copy));
tree.Build();
MeshProjectionTarget target = new MeshProjectionTarget(tree.Mesh, tree);
r.SetProjectionTarget(target);
}
r.ReduceToTriangleCount(numF);
bool isValid = dMsh_copy.CheckValidity();
if (!isValid)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Mesh seems to have been corrupted during reduction. Please check...");
}
DA.SetData(0, dMsh_copy);
}
protected virtual DMesh3 compute_standard()
{
DMesh3 sourceMesh = MeshSource.GetDMeshUnsafe();
ISpatial sourceSpatial = MeshSource.GetSpatial();
DMesh3 meshIn = new DMesh3(sourceMesh);
RemesherPro remesh = new RemesherPro(meshIn);
//Remesher remesh = new Remesher(meshIn);
remesh.SetTargetEdgeLength(TargetEdgeLength);
remesh.PreventNormalFlips = this.PreventNormalFlips;
remesh.EnableFlips = this.EnableFlips;
remesh.EnableSplits = this.EnableSplits;
remesh.EnableCollapses = this.EnableCollapses;
remesh.EnableSmoothing = this.EnableSmoothing;
remesh.SmoothSpeedT = this.SmoothingSpeed;
if (ReprojectToInput)
{
MeshProjectionTarget target = new MeshProjectionTarget(sourceMesh, sourceSpatial);
remesh.SetProjectionTarget(target);
}
// if we are preserving creases, this will also automatically constrain boundary
// edges boundary loops/spans.
if (preserve_creases)
{
if (remesh.Constraints == null)
{
remesh.SetExternalConstraints(new MeshConstraints());
}
MeshTopology topo = new MeshTopology(meshIn);
topo.CreaseAngle = this.CreaseAngle;
topo.AddRemeshConstraints(remesh.Constraints);
// replace boundary edge constraints if we want other behaviors
if (BoundaryMode == BoundaryModes.FixedBoundaries)
{
MeshConstraintUtil.FixEdges(remesh.Constraints, meshIn, topo.BoundaryEdges);
}
}
else if (sourceMesh.CachedIsClosed == false)
{
if (remesh.Constraints == null)
{
remesh.SetExternalConstraints(new MeshConstraints());
}
if (BoundaryMode == BoundaryModes.FreeBoundaries)
{
MeshConstraintUtil.PreserveBoundaryLoops(remesh.Constraints, meshIn);
}
else if (BoundaryMode == BoundaryModes.FixedBoundaries)
{
MeshConstraintUtil.FixAllBoundaryEdges(remesh.Constraints, meshIn);
}
else if (BoundaryMode == BoundaryModes.ConstrainedBoundaries)
{
MeshConstraintUtil.FixAllBoundaryEdges_AllowSplit(remesh.Constraints, meshIn, 0);
}
}
remesh.Progress = new ProgressCancel(is_invalidated);
remesh.FastestRemesh(RemeshRounds, true);
//for (int k = 0; k < RemeshRounds; ++k)
// remesh.BasicRemeshPass();
// free boundary remesh can leave sliver triangles around the border. clean that up.
if (sourceMesh.CachedIsClosed == false && BoundaryMode == BoundaryModes.FreeBoundaries)
{
MeshEditor.RemoveFinTriangles(meshIn, (mesh, tid) => {
Index3i tv = mesh.GetTriangle(tid);
return(MathUtil.AspectRatio(mesh.GetVertex(tv.a), mesh.GetVertex(tv.b), mesh.GetVertex(tv.c)) > 2);
});
}
if (is_invalidated())
{
return(null);
}
return(meshIn);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
DMesh3_goo dMsh_goo = null;
List <Point3d> points = new List <Point3d>();
double targetL = 0;
int numI = 0;
int fixB = 0;
bool projBack = false;
double smooth = 0;
DA.GetData(0, ref dMsh_goo);
DA.GetDataList(2, points);
DA.GetData(1, ref targetL);
DA.GetData(6, ref numI);
DA.GetData(3, ref fixB);
DA.GetData(5, ref projBack);
DA.GetData(7, ref smooth);
List <EdgeConstraint_goo> edgeC = new List <EdgeConstraint_goo>();
DA.GetDataList(4, edgeC);
DMesh3 dMsh_copy = new DMesh3(dMsh_goo.Value);
Remesher r = new Remesher(dMsh_copy);
r.PreventNormalFlips = true;
r.SetTargetEdgeLength(targetL);
r.SmoothSpeedT = smooth;
if (fixB == 2)
{
MeshConstraintUtil.FixAllBoundaryEdges(r);
}
else if (fixB == 1)
{
MeshConstraintUtil.PreserveBoundaryLoops(r);
}
else
{
r.SetExternalConstraints(new MeshConstraints());
}
if (edgeC.Count > 0)
{
for (int i = 0; i < edgeC.Count; i++)
{
var tempEC = edgeC[i];
IProjectionTarget target = new DCurveProjectionTarget(tempEC.crv);
for (int j = 0; j < tempEC.edges.Length; j++)
{
tempEC.constraint.Target = target;
r.Constraints.SetOrUpdateEdgeConstraint(tempEC.edges[j], tempEC.constraint);
}
for (int j = 0; j < tempEC.vertices.Length; j++)
{
if (tempEC.PinVerts)
{
r.Constraints.SetOrUpdateVertexConstraint(tempEC.vertices[j], VertexConstraint.Pinned);
}
else
{
r.Constraints.SetOrUpdateVertexConstraint(tempEC.vertices[j], new VertexConstraint(target));
}
}
}
}
if (points.Count > 0)
{
DMeshAABBTree3 mshAABB = new DMeshAABBTree3(dMsh_copy, true);
var v3pts = points.Select(pt => pt.ToVec3d());
foreach (var p in v3pts)
{
int id = mshAABB.FindNearestVertex(p, 0.1);
if (id != -1)
{
r.Constraints.SetOrUpdateVertexConstraint(id, VertexConstraint.Pinned);
}
}
}
if (projBack)
{
r.SetProjectionTarget(MeshProjectionTarget.Auto(dMsh_goo.Value));
}
for (int k = 0; k < numI; ++k)
{
r.BasicRemeshPass();
}
bool isValid = dMsh_copy.CheckValidity();
if (!isValid)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Mesh seems to have been corrupted during remeshing. Please check...");
}
DA.SetData(0, dMsh_copy);
}
protected virtual DMesh3 compute_sharp_edge_flow()
{
DMesh3 sourceMesh = MeshSource.GetDMeshUnsafe();
ISpatial inputSpatial = MeshSource.GetSpatial();
DMesh3 targetMesh = TargetSource.GetDMeshUnsafe();
ISpatial targetSpatial = TargetSource.GetSpatial();
DMesh3 meshIn = new DMesh3(sourceMesh);
if (is_invalidated())
{
return(null);
}
RemesherPro remesher = new RemesherPro(meshIn);
remesher.SetTargetEdgeLength(TargetEdgeLength);
remesher.PreventNormalFlips = this.PreventNormalFlips;
remesher.EnableFlips = this.EnableFlips;
remesher.EnableSplits = this.EnableSplits;
remesher.EnableCollapses = this.EnableCollapses;
remesher.EnableSmoothing = this.EnableSmoothing;
remesher.SmoothSpeedT = this.SmoothingSpeed;
TransformedMeshProjectionTarget target =
new TransformedMeshProjectionTarget(targetMesh, targetSpatial)
{
SourceToTargetXForm = source_to_target,
TargetToSourceXForm = target_to_source
};
remesher.SetProjectionTarget(target);
if (sourceMesh.CachedIsClosed == false)
{
if (remesher.Constraints == null)
{
remesher.SetExternalConstraints(new MeshConstraints());
}
if (BoundaryMode == BoundaryModes.FreeBoundaries)
{
MeshConstraintUtil.PreserveBoundaryLoops(remesher.Constraints, meshIn);
}
else if (BoundaryMode == BoundaryModes.FixedBoundaries)
{
MeshConstraintUtil.FixAllBoundaryEdges(remesher.Constraints, meshIn);
}
else if (BoundaryMode == BoundaryModes.ConstrainedBoundaries)
{
MeshConstraintUtil.FixAllBoundaryEdges_AllowSplit(remesher.Constraints, meshIn, 0);
}
}
if (is_invalidated())
{
return(null);
}
remesher.Progress = new ProgressCancel(is_invalidated);
remesher.SharpEdgeReprojectionRemesh(RemeshRounds, ProjectionRounds);
if (is_invalidated())
{
return(null);
}
return(meshIn);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Mesh m = DA.Fetch <Mesh>("Mesh");
bool fixEdges = DA.Fetch <bool>("FixEdges");
double l = DA.Fetch <double>("EdgeLength");
int iterations = DA.Fetch <int>("Iterations");
List <Point3d> fixPt = DA.FetchList <Point3d>("FixPt");
bool project = DA.Fetch <bool>("Project");
bool loops = DA.Fetch <bool>("Loops");
Mesh mesh = m.DuplicateMesh();
mesh.Faces.ConvertQuadsToTriangles();
double len = (l == 0) ? mesh.GetBoundingBox(false).Diagonal.Length * 0.1 : l;
//r.PreventNormalFlips = true;
List <int> ids = new List <int>();
Point3d[] pts = mesh.Vertices.ToPoint3dArray();
foreach (Point3d p in fixPt)
{
ids.Add(NGonsCore.PointUtil.ClosestPoint(p, pts));
}
DMesh3 dmesh = mesh.ToDMesh3();
Remesher r = new Remesher(dmesh);
r.Precompute();
r.SetTargetEdgeLength(len);
r.SmoothSpeedT = 0.5;
if (project)
{
r.SetProjectionTarget(MeshProjectionTarget.Auto(dmesh));
}
r.EnableFlips = r.EnableSplits = r.EnableCollapses = true;
r.EnableSmoothing = true;
MeshConstraints cons = new MeshConstraints();
if (ids.Count > 0)
{
foreach (int id in ids)
{
//cons.SetOrUpdateVertexConstraint(id, new VertexConstraint(true, 1));
cons.SetOrUpdateVertexConstraint(id, VertexConstraint.Pinned);
}
}
r.SetExternalConstraints(cons);
r.Precompute();
if (fixEdges)
{
//r.SetExternalConstraints(new MeshConstraints());
MeshConstraintUtil.FixAllBoundaryEdges(r);
MeshConstraintUtil.FixAllBoundaryEdges_AllowSplit(cons, dmesh, 0);
//MeshConstraintUtil.FixAllBoundaryEdges_AllowCollapse(cons, dmesh, 0);
}
if (loops)
{
MeshConstraintUtil.PreserveBoundaryLoops(r); //project to edge
//MeshConstraintUtil.PreserveBoundaryLoops(cons,dmesh);//project to edge
}
r.SetExternalConstraints(cons);
for (int k = 0; k < iterations; ++k)
{
r.BasicRemeshPass();
}
//output
if (ids.Count > 0 && !fixEdges)
{
this.Message = "Vertices";
}
else if (ids.Count == 0 && fixEdges)
{
this.Message = "Edges";
}
else if (ids.Count > 0 && fixEdges)
{
this.Message = "Vertices + Edges";
}
else
{
this.Message = "";
}
dmesh = new DMesh3(dmesh, true);
Mesh rmesh = dmesh.ToRhinoMesh();
if (loops)
{
Mesh mesh_ = rmesh.DuplicateMesh();
Rhino.IndexPair[] closestEdges = new Rhino.IndexPair[fixPt.Count];
int counter = 0;
foreach (Point3d p in fixPt)
{
double[] d = new double[rmesh.TopologyEdges.Count];
int[] eid = new int[rmesh.TopologyEdges.Count];
for (int i = 0; i < rmesh.TopologyEdges.Count; i++)
{
if (rmesh.TopologyEdges.GetConnectedFaces(i).Length == 1)
{
Line line = rmesh.TopologyEdges.EdgeLine(i);
line.ClosestPoint(p, true);
d[i] = line.ClosestPoint(p, true).DistanceToSquared(p); //line.From.DistanceToSquared(p) + line.To.DistanceToSquared(p);
}
else
{
d[i] = 99999;
}
eid[i] = i;
}
Array.Sort(d, eid);
closestEdges[counter++] = rmesh.TopologyEdges.GetTopologyVertices(eid[0]);
}
for (int i = 0; i < fixPt.Count; i++)
{
mesh_.Vertices.Add(fixPt[i]);
mesh_.Faces.AddFace(rmesh.Vertices.Count + i, closestEdges[i].I, closestEdges[i].J);
}
rmesh = mesh_;
}
rmesh.UnifyNormals();
rmesh.RebuildNormals();
// rmesh.UnifyNormals();
DA.SetData(0, rmesh);
}
