Refine a bit

Author: DanielVandH

src/algorithms/triangulation/basic_operations/delete_ghost_triangles.jl

@@ -26,7 +26,6 @@ function delete_ghost_triangles!(tri::Triangulation)
             delete_triangle!(T, u, v, g)
         end
     end
-    # Clear the boundary_vertex_to_ghost map since ghost triangles are deleted
     empty!(get_boundary_vertex_to_ghost(tri))
     set_has_ghosts!(tri, false)
     return tri

src/algorithms/triangulation/basic_operations/lock_convex_hull.jl

@@ -45,7 +45,7 @@ function lock_convex_hull!(tri::Triangulation; rng::Random.AbstractRNG = Random.
             add_edge!(interior_segments_on_hull, e)
         end
     end
-    # Also add the last vertex (which equals the first in a closed boundary)
+    # Add the last vertex (closed boundary)
     u = get_boundary_nodes(bn, ne + 1)
     add_boundary_vertex_to_ghost!(tri, u, ghost_vertex)
     for e in keys(bnn_map)

src/algorithms/triangulation/triangulate_convex.jl

@@ -187,9 +187,7 @@ function postprocess_triangulate_convex!(tri::Triangulation, S; delete_ghosts, d
         add_adjacent2vertex!(tri, ghost_vertex, v, u)
         add_adjacent!(tri, v, u, ghost_vertex)
     end
-    # Add the last boundary vertex to ghost mapping only for constrained boundaries
     populate_map && add_boundary_vertex_to_ghost!(tri, u, ghost_vertex)
-    # Set has_ghosts flag based on whether we added ghost triangles
     set_has_ghosts!(tri, !delete_ghosts)
     delete_empty_features && clear_empty_features!(tri)
     empty_representative_points!(tri)

src/data_structures/triangulation/methods/boundary_nodes.jl

@@ -160,7 +160,6 @@ function merge_boundary_edge!(tri::Triangulation, i, j, node)
     node_pos = (pos[1], pos[2] + 1)
     bnn = get_boundary_edge_map(tri)
     delete_boundary_node!(tri, node_pos)
-    # Remove the merged node from boundary_vertex_to_ghost map
     delete_boundary_vertex_from_ghost_map!(tri, node)
     E = edge_type(tri)
     delete!(bnn, construct_edge(E, i, node))

test/data_structures/triangulation.jl

@@ -1669,51 +1669,32 @@ end
     @test DT.has_ghosts(tri)
 end
 
-@testset "Triangulation fields are const (except has_ghosts)" begin
+@testset "Mutating has_ghosts" begin
     points = [(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)]
     tri = DT.Triangulation(points)
-
-    # Test that has_ghosts can be modified (is not const)
     @test !DT.has_ghosts(tri)
     DT.set_has_ghosts!(tri, true)
     @test DT.has_ghosts(tri)
-
-    # Test that trying to reassign const fields should error
-    # Note: We can't easily test this at runtime since const fields are checked at compile time
-    # But we can verify that the struct is mutable
     @test ismutable(tri)
-
-    # Verify the field can be directly accessed (for the getter implementation)
     @test tri.has_ghosts == DT.has_ghosts(tri)
-
-    # Verify we can modify has_ghosts but the struct itself is the same object
-    old_tri = tri
-    DT.set_has_ghosts!(tri, false)
-    @test old_tri === tri # Same object
-    @test !DT.has_ghosts(tri)
 end
 
-@testset "has_ghosts with Base.copy" begin
+@testset "has_ghosts with copy" begin
     points = [(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)]
     tri = DT.Triangulation(points)
 
-    # Set has_ghosts to true
     DT.set_has_ghosts!(tri, true)
     @test DT.has_ghosts(tri)
 
-    # Copy the triangulation
     tri_copy = Base.copy(tri)
 
-    # Verify the copy has the same has_ghosts value
     @test DT.has_ghosts(tri_copy) == DT.has_ghosts(tri)
     @test DT.has_ghosts(tri_copy) == true
 
-    # Modify the original
     DT.set_has_ghosts!(tri, false)
     @test !DT.has_ghosts(tri)
-    @test DT.has_ghosts(tri_copy) # Copy should still be true
+    @test DT.has_ghosts(tri_copy)
 
-    # Test with has_ghosts = false
     tri2 = DT.Triangulation(points)
     @test !DT.has_ghosts(tri2)
     tri2_copy = Base.copy(tri2)
@@ -1725,24 +1706,20 @@ end
     tri1 = DT.Triangulation(points)
     tri2 = DT.Triangulation(points)
 
-    # Both have has_ghosts = false initially
     @test !DT.has_ghosts(tri1)
     @test !DT.has_ghosts(tri2)
     @test tri1 == tri2
 
-    # Set one to true
     DT.set_has_ghosts!(tri1, true)
     @test DT.has_ghosts(tri1)
     @test !DT.has_ghosts(tri2)
-    @test tri1 != tri2 # Should not be equal
+    @test tri1 != tri2 
 
-    # Set both to true
     DT.set_has_ghosts!(tri2, true)
     @test DT.has_ghosts(tri1)
     @test DT.has_ghosts(tri2)
-    @test tri1 == tri2 # Should be equal again
+    @test tri1 == tri2
 
-    # Set both to false
     DT.set_has_ghosts!(tri1, false)
     DT.set_has_ghosts!(tri2, false)
     @test !DT.has_ghosts(tri1)

test/operations/add_ghost_triangles.jl

@@ -6,13 +6,11 @@ using StaticArrays
 @testset "Adding ghost triangles" begin
     tri, label_map, index_map = simple_geometry()
 
-    # Test that has_ghosts is initially false
     @test !DT.has_ghosts(tri)
     @test !DT.has_ghost_triangles(tri)
 
     DT.add_ghost_triangles!(tri)
 
-    # Test that has_ghosts is now true after adding ghost triangles
     @test DT.has_ghosts(tri)
     @test DT.has_ghost_triangles(tri)
     outer_edges = [

test/operations/delete_ghost_triangles.jl

@@ -9,19 +9,16 @@ using StaticArrays
     tri, label_map, index_map = simple_geometry()
     _tri = deepcopy(tri)
 
-    # Test initial state
     @test !DT.has_ghosts(tri)
     @test !DT.has_ghost_triangles(tri)
 
     DT.add_ghost_triangles!(tri)
 
-    # Test after adding ghost triangles
     @test DT.has_ghosts(tri)
     @test DT.has_ghost_triangles(tri)
 
     DT.delete_ghost_triangles!(tri)
 
-    # Test after deleting ghost triangles
     @test !DT.has_ghosts(tri)
     @test !DT.has_ghost_triangles(tri)
 

test/predicates/boundaries_and_ghosts.jl

@@ -15,9 +15,6 @@ A = get_area(tri)
 refine!(tri; max_area = 1.0e-2A, rng, use_circumcenter = true)
 
 tri2, label_map, index_map = simple_geometry()
-# Manually repopulate boundary_vertex_to_ghost after simple_geometry() which uses delete_ghosts=true
-# This is needed because add_boundary_information! clears the map but the package code changes
-# may not be loaded in the current session
 let bn = get_boundary_nodes(tri2)
     bv_map = DT.get_boundary_vertex_to_ghost(tri2)
     ghost = DT.𝒢
@@ -309,12 +306,11 @@ end
         end
     end
 
-    # Test that boundary_vertex_to_ghost map is correctly maintained
     @testset "boundary_vertex_to_ghost consistency" begin
         # Test with complicated geometry (multiple curves and sections)
-        # Note: For junction nodes (nodes shared between sections), the map will only
-        # contain ONE ghost vertex, whichever was set last during processing.
-        # So we check that each boundary node IS in the map and maps to a VALID
+        # Note: For junction nodes, the map will only
+        # contain one ghost vertex, whichever was set last during processing.
+        # So we check that each boundary node is in the map and maps to a valid
         # ghost vertex (one that is in the ghost vertex range for that curve).
         bv_map = DT.get_boundary_vertex_to_ghost(tri)
         for (ghost_vertex, segment_index) in get_ghost_vertex_map(tri)
@@ -350,12 +346,10 @@ end
 @testset "boundary_vertex_to_ghost getter and setters" begin
     tri, label_map, index_map = simple_geometry()
 
-    # Test initial state - empty map for unconstrained tri before boundary info added
     bv_map = DT.get_boundary_vertex_to_ghost(tri)
     @test bv_map isa Dict
     @test isempty(bv_map)
 
-    # Manually add some mappings for testing
     I = DT.integer_type(tri)
     test_vertex = I(5)
     test_ghost = I(-2)
@@ -364,56 +358,47 @@ end
     @test haskey(DT.get_boundary_vertex_to_ghost(tri), test_vertex)
     @test DT.get_boundary_vertex_to_ghost(tri)[test_vertex] == test_ghost
 
-    # Test deletion
     DT.delete_boundary_vertex_from_ghost_map!(tri, test_vertex)
     @test !haskey(DT.get_boundary_vertex_to_ghost(tri), test_vertex)
 
-    # Test with actual triangulation with boundaries
     x, y = complicated_geometry()
     rng = StableRNG(99988)
     boundary_nodes, points = convert_boundary_points_to_indices(x, y)
     tri_with_boundary = triangulate(points; rng, boundary_nodes, delete_ghosts = false)
 
-    # Verify map is populated
     bv_map = DT.get_boundary_vertex_to_ghost(tri_with_boundary)
     @test !isempty(bv_map)
 
-    # Verify all boundary nodes are in the map
     all_boundary_nodes = reduce(vcat, reduce(vcat, get_boundary_nodes(tri_with_boundary)))
     for bn in all_boundary_nodes
         @test haskey(bv_map, bn)
     end
 
-    # Verify non-boundary nodes are not in the map
     for v in each_vertex(tri_with_boundary)
         if v ∉ all_boundary_nodes
             @test !haskey(bv_map, v)
         end
     end
 end
 
-@testset "boundary_vertex_to_ghost with Base.copy and ==" begin
+@testset "boundary_vertex_to_ghost with copy and ==" begin
     x, y = complicated_geometry()
     rng = StableRNG(99988)
     boundary_nodes, points = convert_boundary_points_to_indices(x, y)
     tri = triangulate(points; rng, boundary_nodes, delete_ghosts = false)
 
-    # Test Base.copy preserves the map
     tri_copy = copy(tri)
     @test DT.get_boundary_vertex_to_ghost(tri) == DT.get_boundary_vertex_to_ghost(tri_copy)
     @test DT.get_boundary_vertex_to_ghost(tri) !== DT.get_boundary_vertex_to_ghost(tri_copy)  # Different objects
 
-    # Test Base.== compares the map
     @test tri == tri_copy
 
-    # Modify the copy's map and verify inequality
     I = DT.integer_type(tri_copy)
     fake_vertex = I(999999)
     fake_ghost = I(-999)
     DT.add_boundary_vertex_to_ghost!(tri_copy, fake_vertex, fake_ghost)
     @test tri != tri_copy
 
-    # Remove it and verify equality again
     DT.delete_boundary_vertex_from_ghost_map!(tri_copy, fake_vertex)
     @test tri == tri_copy
 end