public static void flip_tests(bool bTestBoundary, int N = 100) { System.Console.WriteLine("DMesh3:flip_tests() starting"); DMesh3 mesh = TestUtil.MakeCappedCylinder(bTestBoundary); mesh.CheckValidity(); Random r = new Random(31377); for (int k = 0; k < N; ++k) { int eid = r.Next() % mesh.EdgeCount; if (!mesh.IsEdge(eid)) { continue; } bool bBoundary = mesh.IsBoundaryEdge(eid); DMesh3.EdgeFlipInfo flipInfo; MeshResult result = mesh.FlipEdge(eid, out flipInfo); if (bBoundary) { Debug.Assert(result == MeshResult.Failed_IsBoundaryEdge); } else { Debug.Assert(result == MeshResult.Ok || result == MeshResult.Failed_FlippedEdgeExists); } mesh.CheckValidity(); } System.Console.WriteLine("flips ok"); }
public static void poke_test() { DMesh3 mesh = TestUtil.LoadTestInputMesh("plane_250v.obj"); //DMesh3 mesh = TestUtil.LoadTestInputMesh("sphere_bowtie_groups.obj"); mesh.CheckValidity(); int NT = mesh.TriangleCount; for (int i = 0; i < NT; i += 5) { Vector3d n = mesh.GetTriNormal(i); DMesh3.PokeTriangleInfo pokeinfo; MeshResult result = mesh.PokeTriangle(i, out pokeinfo); Vector3d v = mesh.GetVertex(pokeinfo.new_vid); v += 0.25f * n; mesh.SetVertex(pokeinfo.new_vid, v); mesh.CheckValidity(); } //TestUtil.WriteTestOutputMesh(mesh, "poke_test_result.obj"); }
public DMesh3 remesh_region(int iterations, DMesh3 mesh, double min, double max, double angle) { int[] tris = GetTrisOnPositiveSide(mesh, new Frame3f(Vector3F.Zero, Vector3F.AxisY)); RegionRemesher r = new RegionRemesher(mesh, tris); r.Region.SubMesh.CheckValidity(true); r.Precompute(); r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = min; r.MaxEdgeLength = max; r.EnableSmoothing = true; r.SmoothSpeedT = 1.0f; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.BackPropropagate(); for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.BackPropropagate(); return(mesh); }
public static void split_tests(bool bTestBoundary, int N = 100) { System.Console.WriteLine("DMesh3:split_tests() starting"); DMesh3 mesh = TestUtil.MakeCappedCylinder(bTestBoundary); mesh.CheckValidity(); Random r = new Random(31377); for (int k = 0; k < N; ++k) { int eid = r.Next() % mesh.EdgeCount; if (!mesh.IsEdge(eid)) { continue; } DMesh3.EdgeSplitInfo splitInfo; MeshResult result = mesh.SplitEdge(eid, out splitInfo); Debug.Assert(result == MeshResult.Ok); mesh.CheckValidity(); } System.Console.WriteLine("splits ok"); }
public static DMesh3 make_good_cylinder(float fResScale = 1.0f) { DMesh3 mesh = TestUtil.MakeCappedCylinder(false); MeshUtil.ScaleMesh(mesh, Frame3f.Identity, new Vector3f(1, 2, 1)); mesh.CheckValidity(); Remesher r = new Remesher(mesh); r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = 0.1f * fResScale; r.MaxEdgeLength = 0.2f * fResScale; r.EnableSmoothing = true; r.SmoothSpeedT = 0.1f; r.EnableFlips = r.EnableSmoothing = false; r.MinEdgeLength = 0.05f * fResScale; for (int k = 0; k < 10; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.MinEdgeLength = 0.1f * fResScale; r.MaxEdgeLength = 0.2f * fResScale; r.EnableFlips = r.EnableCollapses = r.EnableSmoothing = true; for (int k = 0; k < 10; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } return(mesh); }
public static void collapse_tests(bool bTestBoundary, int N = 100) { bool write_debug_meshes = false; DMesh3 mesh = TestUtil.MakeCappedCylinder(bTestBoundary); mesh.CheckValidity(); System.Console.WriteLine(string.Format("DMesh3:collapse_tests() starting - test bdry {2}, verts {0} tris {1}", mesh.VertexCount, mesh.TriangleCount, bTestBoundary)); if (write_debug_meshes) { TestUtil.WriteDebugMesh(mesh, string.Format("before_collapse_{0}.obj", ((bTestBoundary)?"boundary":"noboundary"))); } Random r = new Random(31377); for (int k = 0; k < N; ++k) { int eid = r.Next() % mesh.EdgeCount; if (!mesh.IsEdge(eid)) { continue; } //bool bBoundary = mesh.IsBoundaryEdge(eid); //if (bTestBoundary && bBoundary == false) // continue; Index2i ev = mesh.GetEdgeV(eid); DMesh3.EdgeCollapseInfo collapseInfo; MeshResult result = mesh.CollapseEdge(ev[0], ev[1], out collapseInfo); Debug.Assert( result != MeshResult.Failed_NotAnEdge && result != MeshResult.Failed_FoundDuplicateTriangle); mesh.CheckValidity(); } System.Console.WriteLine(string.Format("random collapses ok - verts {0} tris {1}", mesh.VertexCount, mesh.TriangleCount)); collapse_to_convergence(mesh); System.Console.WriteLine(string.Format("all possible collapses ok - verts {0} tris {1}", mesh.VertexCount, mesh.TriangleCount)); if (write_debug_meshes) { TestUtil.WriteDebugMesh(mesh, string.Format("after_collapse_{0}.obj", ((bTestBoundary)?"boundary":"noboundary"))); } }
public static void test_basic_closed_remesh() { DMesh3 mesh = TestUtil.MakeCappedCylinder(false); MeshUtil.ScaleMesh(mesh, Frame3f.Identity, new Vector3f(1, 2, 1)); //DMesh3 mesh = TestUtil.MakeOpenCylinder(false); mesh.CheckValidity(); if (WriteDebugMeshes) { TestUtil.WriteDebugMesh(mesh, "basic_closed_remesh_before.obj"); } Remesher r = new Remesher(mesh); r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = 0.1f; r.MaxEdgeLength = 0.2f; r.EnableSmoothing = true; r.SmoothSpeedT = 0.1f; r.EnableFlips = r.EnableSmoothing = false; r.MinEdgeLength = 0.05f; for (int k = 0; k < 10; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.MinEdgeLength = 0.1f; r.MaxEdgeLength = 0.2f; r.EnableFlips = r.EnableCollapses = r.EnableSmoothing = true; for (int k = 0; k < 10; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.EnableSplits = r.EnableCollapses = false; for (int k = 0; k < 10; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } if (WriteDebugMeshes) { TestUtil.WriteDebugMesh(mesh, "basic_closed_remesh_after.obj"); } }
// closed mesh should collapse to a tetrahedron public static void collapse_test_closed_mesh() { DMesh3 mesh = TestUtil.MakeCappedCylinder(false); mesh.CheckValidity(); collapse_to_convergence(mesh); mesh.CheckValidity(); Util.gDevAssert(mesh.TriangleCount == 4); Util.gDevAssert(mesh.VertexCount == 4); foreach (int eid in mesh.EdgeIndices()) { Util.gDevAssert(mesh.IsBoundaryEdge(eid) == false); } }
public static void hard_test() { //DMesh3 mesh = TestUtil.LoadTestInputMesh("three_edge_crack.obj"); DMesh3 mesh = TestUtil.LoadTestMesh("c:\\scratch\\VTX_Scan_removeocc.obj"); //MeshEditor editor = new MeshEditor(mesh); //editor.DisconnectAllBowties(100); mesh.CheckValidity(true, FailMode.DebugAssert); MergeCoincidentEdges merge = new MergeCoincidentEdges(mesh); merge.Apply(); mesh.CheckValidity(true, FailMode.DebugAssert); TestUtil.WriteTestOutputMesh(mesh, "vtx_scan_merged.obj"); }
public static void test_remesh_region() { int Slices = 16; DMesh3 mesh = TestUtil.MakeCappedCylinder(false, Slices); MeshUtil.ScaleMesh(mesh, Frame3f.Identity, new Vector3f(1, 2, 1)); mesh.CheckValidity(); int[] tris = TestUtil.GetTrisOnPositiveSide(mesh, new Frame3f(Vector3f.Zero, Vector3f.AxisY)); RegionRemesher r = new RegionRemesher(mesh, tris); r.Region.SubMesh.CheckValidity(true); TestUtil.WriteTestOutputMesh(r.Region.SubMesh, "remesh_region_submesh.obj"); r.Precompute(); double fResScale = 0.5f; r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = 0.1f * fResScale; r.MaxEdgeLength = 0.2f * fResScale; r.EnableSmoothing = true; r.SmoothSpeedT = 1.0f; for (int k = 0; k < 5; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } TestUtil.WriteTestOutputMesh(r.Region.SubMesh, "remesh_region_submesh_refined.obj"); r.BackPropropagate(); TestUtil.WriteTestOutputMesh(mesh, "remesh_region_submesh_merged_1.obj"); for (int k = 0; k < 5; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.BackPropropagate(); TestUtil.WriteTestOutputMesh(mesh, "remesh_region_submesh_merged_2.obj"); }
public static void basic_tests() { DMesh3 mesh = TestUtil.LoadTestInputMesh("three_edge_crack.obj"); MergeCoincidentEdges merge = new MergeCoincidentEdges(mesh); merge.Apply(); Util.gDevAssert(mesh.BoundaryEdgeIndices().Count() == 0); mesh.CheckValidity(true, FailMode.DebugAssert); TestUtil.WriteTestOutputMesh(mesh, "three_edge_crack_merged.obj"); DMesh3 mesh2 = TestUtil.LoadTestInputMesh("crack_loop.obj"); MergeCoincidentEdges merge2 = new MergeCoincidentEdges(mesh2); merge2.Apply(); Util.gDevAssert(mesh2.BoundaryEdgeIndices().Count() == 0); mesh2.CheckValidity(true, FailMode.DebugAssert); TestUtil.WriteTestOutputMesh(mesh2, "crack_loop_merged.obj"); DMesh3 mesh3 = TestUtil.LoadTestInputMesh("cracks_many.obj"); MergeCoincidentEdges merge3 = new MergeCoincidentEdges(mesh3); merge3.Apply(); Util.gDevAssert(mesh3.BoundaryEdgeIndices().Count() == 0); mesh3.CheckValidity(true, FailMode.DebugAssert); TestUtil.WriteTestOutputMesh(mesh3, "cracks_many_merged.obj"); DMesh3 mesh4 = TestUtil.LoadTestInputMesh("cracks_duplicate_edge.obj"); MergeCoincidentEdges merge4 = new MergeCoincidentEdges(mesh4); merge4.Apply(); Util.gDevAssert(mesh4.BoundaryEdgeIndices().Count() == 0); mesh4.CheckValidity(true, FailMode.DebugAssert); TestUtil.WriteTestOutputMesh(mesh4, "cracks_duplicate_edge_merged.obj"); }
protected override void SolveInstance(IGH_DataAccess DA) { this.Message = modes.ToString() + " : " + steps.ToString() + " Steps"; Grid3f_goo goo = null; double val = 0; double exp = 0; DA.GetData(0, ref goo); DA.GetData(1, ref val); DA.GetData(2, ref exp); var iso = goo.Value; g3.MarchingCubes c = new g3.MarchingCubes(); c.Implicit = iso; c.Bounds = iso.Bounds(); c.RootMode = modes; c.RootModeSteps = steps; c.CubeSize = iso.CellSize; c.Bounds.Expand(3 * c.CubeSize); c.IsoValue = val; c.Generate(); DMesh3 outputMesh = c.Mesh; bool isValid = outputMesh.CheckValidity(); if (!isValid) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Mesh seems to be corrupted. Please check..."); } DA.SetData(0, outputMesh); }
// open cylinder (ie a tube) should collapse down to having two boundary loops with 3 verts/edges each public static void collapse_test_convergence_opencyl() { DMesh3 mesh = TestUtil.MakeOpenCylinder(false); mesh.CheckValidity(); collapse_to_convergence(mesh); int bdry_v = 0, bdry_t = 0, bdry_e = 0; foreach (int eid in mesh.EdgeIndices()) { if (mesh.IsBoundaryEdge(eid)) { bdry_e++; } } Util.gDevAssert(bdry_e == 6); foreach (int tid in mesh.TriangleIndices()) { if (mesh.tri_is_boundary(tid)) { bdry_t++; } } Util.gDevAssert(bdry_t == 6); foreach (int vid in mesh.VertexIndices()) { if (mesh.IsBoundaryVertex(vid)) { bdry_v++; } } Util.gDevAssert(bdry_v == 6); }
protected override void SolveInstance(IGH_DataAccess DA) { DMesh3_goo dMsh_goo = null; double w = 1; DA.GetData(0, ref dMsh_goo); DA.GetData(1, ref w); DMesh3 dMsh_copy = new DMesh3(dMsh_goo.Value, true); LaplacianMeshDeformer deformer = new LaplacianMeshDeformer(dMsh_copy); foreach (int vid in dMsh_copy.VertexIndices()) { if (deformer.IsConstrained(vid) == false) { deformer.SetConstraint(vid, dMsh_copy.GetVertex(vid), w); } } bool success = deformer.SolveAndUpdateMesh(); bool isValid = dMsh_copy.CheckValidity(); if (!success) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Laplacian deform seems to have failed. Please check..."); } if (!isValid) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Mesh seems to have been corrupted during smoothing. Please check..."); } DA.SetData(0, dMsh_copy); }
public static DMesh3 Reduce(this DMesh3 mesh, float percent, bool project = true) { if (!mesh.CheckValidity(eFailMode: FailMode.ReturnOnly)) { return(mesh); } var r = new Reducer(mesh); if (project) { var tree = mesh.AABBTree(); r.SetProjectionTarget(new MeshProjectionTarget(tree.Mesh, tree)); // http://www.gradientspace.com/tutorials/2017/8/30/mesh-simplification // r.ProjectionMode = Reducer.TargetProjectionMode.Inline; } var target = mesh.VertexCount * percent / 100.0f; r.ReduceToVertexCount((int)target); var newMesh = r.Mesh.Compact(); var g = newMesh.ToIGeometry(); Debug.Assert(g.AreAllIndicesValid()); //Debug.Assert(g.AreAllVerticesUsed()); return(newMesh); }
public static void test_basic_closed_reduce() { //DMesh3 mesh = TestUtil.MakeCappedCylinder(false); //DMesh3 mesh = TestUtil.LoadTestInputMesh("sphere_bowtie_groups.obj"); DMesh3 mesh = TestUtil.LoadTestInputMesh("bunny_solid.obj"); //MeshUtil.ScaleMesh(mesh, Frame3f.Identity, new Vector3f(1,2,1)); //DMesh3 mesh = TestUtil.MakeOpenCylinder(false); mesh.CheckValidity(); if (WriteDebugMeshes) { TestUtil.WriteTestOutputMesh(mesh, "basic_closed_reduce_before.obj"); } Reducer r = new Reducer(mesh); DMeshAABBTree3 tree = new DMeshAABBTree3(new DMesh3(mesh)); tree.Build(); //r.SetProjectionTarget(new MeshProjectionTarget() { Mesh = tree.Mesh, Spatial = tree }); r.ReduceToTriangleCount(3000); //r.ReduceToEdgeLength(2.0); double mine, maxe, avge; MeshQueries.EdgeLengthStats(mesh, out mine, out maxe, out avge); System.Console.WriteLine("Edge length stats: {0} {1} {2}", mine, maxe, avge); if (WriteDebugMeshes) { TestUtil.WriteTestOutputMesh(mesh, "basic_closed_reduce_after.obj"); } }
public static void set_triangle_tests() { DMesh3 mesh = TestUtil.LoadTestInputMesh("plane_250v.obj"); mesh.CheckValidity(); // ok todo }
public DMesh3 remesh_constraints_fixedverts(int iterations, DMesh3 mesh, double min, double max, double angle) { AxisAlignedBox3d bounds = mesh.CachedBounds; // construct mesh projection target DMesh3 meshCopy = new DMesh3(mesh); meshCopy.CheckValidity(); DMeshAABBTree3 tree = new DMeshAABBTree3(meshCopy); tree.Build(); MeshProjectionTarget target = new MeshProjectionTarget() { Mesh = meshCopy, Spatial = tree }; // construct constraint set MeshConstraints cons = new MeshConstraints(); //EdgeRefineFlags useFlags = EdgeRefineFlags.NoFlip | EdgeRefineFlags.NoCollapse; EdgeRefineFlags useFlags = EdgeRefineFlags.NoFlip; foreach (int eid in mesh.EdgeIndices()) { double fAngle = MeshUtil.OpeningAngleD(mesh, eid); if (fAngle > angle) { cons.SetOrUpdateEdgeConstraint(eid, new EdgeConstraint(useFlags)); Index2i ev = mesh.GetEdgeV(eid); int nSetID0 = (mesh.GetVertex(ev[0]).y > bounds.Center.y) ? 1 : 2; int nSetID1 = (mesh.GetVertex(ev[1]).y > bounds.Center.y) ? 1 : 2; cons.SetOrUpdateVertexConstraint(ev[0], new VertexConstraint(true, nSetID0)); cons.SetOrUpdateVertexConstraint(ev[1], new VertexConstraint(true, nSetID1)); } } Remesher r = new Remesher(mesh); r.Precompute(); r.SetExternalConstraints(cons); r.SetProjectionTarget(target); r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = min; r.MaxEdgeLength = max; r.EnableSmoothing = true; r.SmoothSpeedT = 1; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } return(mesh); }
public static DMesh3 MakeTrivialRect() { DMesh3 rectMesh = new DMesh3(); TrivialRectGenerator rgen = new TrivialRectGenerator(); rgen.Generate(); rgen.MakeMesh(rectMesh); rectMesh.CheckValidity(); return(rectMesh); }
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); }
public static void test_remove_change_apply() { DMesh3 testMesh = TestUtil.LoadTestInputMesh("bunny_solid.obj"); DMesh3 copy = new DMesh3(testMesh); Vector3d c = testMesh.CachedBounds.Center; MeshFaceSelection selection = new MeshFaceSelection(testMesh); foreach (int tid in testMesh.TriangleIndices()) { if (testMesh.GetTriCentroid(tid).x > c.x) { selection.Select(tid); } } RemoveTrianglesMeshChange change = new RemoveTrianglesMeshChange(); change.InitializeFromApply(testMesh, selection); testMesh.CheckValidity(true); change.Apply(copy); copy.CheckValidity(true); if (!copy.IsSameMesh(testMesh, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } change.Revert(testMesh); testMesh.CheckValidity(false); change.Revert(copy); copy.CheckValidity(false); if (!copy.IsSameMesh(testMesh, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } System.Console.WriteLine("test_remove_change_apply ok"); }
public static void test_remove_change_construct() { DMesh3 testMesh = TestUtil.LoadTestInputMesh("bunny_open_base.obj"); Random r = new Random(31337); //int N = 100; int N = 10; int[] indices = TestUtil.RandomIndices(N, r, testMesh.MaxVertexID); for (int ii = 0; ii < N; ++ii) { MeshFaceSelection selection = new MeshFaceSelection(testMesh); selection.SelectVertexOneRing(indices[ii]); selection.ExpandToOneRingNeighbours(8); RemoveTrianglesMeshChange change = new RemoveTrianglesMeshChange(); change.InitializeFromExisting(testMesh, selection); DMesh3 removed = new DMesh3(testMesh); MeshEditor.RemoveTriangles(removed, selection); DMesh3 changeCopy = new DMesh3(testMesh); change.Apply(changeCopy); changeCopy.CheckValidity(true); if (!changeCopy.IsSameMesh(removed, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } change.Revert(changeCopy); changeCopy.CheckValidity(false); if (!changeCopy.IsSameMesh(testMesh, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } } System.Console.WriteLine("test_remove_change_construct ok"); }
public static void test_add_change() { DMesh3 testMesh = TestUtil.LoadTestInputMesh("bunny_open_base.obj"); DMesh3 copy = new DMesh3(testMesh); MeshBoundaryLoops loops = new MeshBoundaryLoops(copy); foreach (var loop in loops) { SimpleHoleFiller filler = new SimpleHoleFiller(copy, loop); bool ok = filler.Fill(); Util.gDevAssert(ok); AddTrianglesMeshChange change = new AddTrianglesMeshChange(); change.InitializeFromExisting(copy, new List <int>() { filler.NewVertex }, filler.NewTriangles); DMesh3 tmp = new DMesh3(copy); change.Revert(copy); copy.CheckValidity(true); if (!copy.IsSameMesh(testMesh, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } change.Apply(copy); copy.CheckValidity(true); if (!copy.IsSameMesh(tmp, true)) { System.Console.WriteLine("FAILED copy.IsSameMesh() 1"); } } System.Console.WriteLine("test_add_change ok"); }
// cyl with no shared verts should collapse down to two triangles public static void collapse_test_convergence_cyl_noshared() { DMesh3 mesh = TestUtil.MakeCappedCylinder(true); mesh.CheckValidity(); collapse_to_convergence(mesh); Util.gDevAssert(mesh.TriangleCount == 3); Util.gDevAssert(mesh.VertexCount == 9); foreach (int tid in mesh.TriangleIndices()) { Util.gDevAssert(mesh.tri_is_boundary(tid)); } }
public static void basic_tests() { System.Console.WriteLine("DMesh3:basic_tests() starting"); DMesh3 tmp = new DMesh3(); CappedCylinderGenerator cylgen = new CappedCylinderGenerator(); cylgen.Generate(); cylgen.MakeMesh(tmp); tmp.CheckValidity(); System.Console.WriteLine("cylinder ok"); }
public DMesh3 remesh_basic_closed(int iterations, DMesh3 mesh, double min, double max, double angle) { Remesher r = new Remesher(mesh); r.EnableFlips = r.EnableSplits = r.EnableCollapses = true; r.MinEdgeLength = min; r.MaxEdgeLength = max; r.EnableSmoothing = true; r.SmoothSpeedT = 0.1f; r.EnableFlips = r.EnableSmoothing = false; r.MinEdgeLength = min; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.MinEdgeLength = min; r.MaxEdgeLength = max; r.EnableFlips = r.EnableCollapses = r.EnableSmoothing = true; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } r.EnableSplits = r.EnableCollapses = false; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } return(mesh); }
public static void test_compact_in_place() { DMesh3 testMesh = TestUtil.LoadTestInputMesh("bunny_solid.obj"); testMesh.CheckValidity(); int[] test_counts = new int[] { 16, 256, 1023, 1024, 1025, 2047, 2048, 2049, testMesh.TriangleCount - 1, testMesh.TriangleCount }; foreach (int count in test_counts) { DMesh3 mesh = new DMesh3(testMesh); Reducer r = new Reducer(mesh); r.ReduceToTriangleCount(count); mesh.CompactInPlace(); mesh.CheckValidity(false, FailMode.DebugAssert); Util.gDevAssert(mesh.IsCompact); } }
protected override void SolveInstance(IGH_DataAccess DA) { DMesh3_goo dMsh_goo = null; double targetL = 0; int numI = 0; bool fixB = false; bool projBack = false; DA.GetData(0, ref dMsh_goo); DA.GetData(1, ref targetL); DA.GetData(2, ref numI); DA.GetData(3, ref fixB); DA.GetData(4, ref projBack); DMesh3 dMsh_copy = new DMesh3(dMsh_goo.Value); Remesher r = new Remesher(dMsh_copy); r.PreventNormalFlips = true; r.SetTargetEdgeLength(targetL); r.SmoothSpeedT = 0.5; if (fixB) { MeshConstraintUtil.FixAllBoundaryEdges(r); } 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); }
public DMesh3 remesh_smoothing(int iterations, DMesh3 mesh) { Remesher r = new Remesher(mesh); r.EnableFlips = r.EnableSplits = r.EnableCollapses = false; r.EnableSmoothing = true; r.SmoothSpeedT = 0.5f; r.SmoothType = Remesher.SmoothTypes.MeanValue; for (int k = 0; k < iterations; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } return(mesh); }
public static void test_remesh_smoothing() { DMesh3 mesh = make_good_cylinder(1.0f); Remesher r = new Remesher(mesh); r.EnableFlips = r.EnableSplits = r.EnableCollapses = false; r.EnableSmoothing = true; r.SmoothSpeedT = 0.5f; r.SmoothType = Remesher.SmoothTypes.MeanValue; for (int k = 0; k < 100; ++k) { r.BasicRemeshPass(); mesh.CheckValidity(); } if (WriteDebugMeshes) { TestUtil.WriteDebugMesh(mesh, "remesh_smoothing_test_after.obj"); } }