test split_mesh

Author: ffreyer

src/basic_types.jl

@@ -641,6 +641,65 @@ function Base.:(==)(a::Mesh, b::Mesh)
            (faces(a) == faces(b)) && (a.views == b.views)
 end
 
+"""
+    strictly_equal_face_vertices(a::Mesh, b::Mesh)
+
+Checks whether mesh a and b are equal in terms of vertices used in their faces.
+This allows for vertex data and indices to be synchronously permuted. For
+example, this will recognize
+```
+a = Mesh([a, b, c], [GLTriangleFace(1,2,3)])
+b = Mesh([a, c, b], [GLTriangleFace(1,3,2)])
+```
+as equal, because while the positions and faces have different orders the vertices
+in the face are the same:
+```
+[a, c, b][[1, 3, 2]] == [a, b, c] == [a, b, c][[1,2,3]]
+```
+
+This still returns false if the order of faces is permuted, e.g.
+`Mesh(ps, [f1, f2]) != Mesh(ps, [f2, f1])`. It also returns false if vertices are
+cyclically permuted within a face, i.e. `ps[[1,2,3]] != ps[[2,3,1]]`.
+"""
+function strictly_equal_face_vertices(a::Mesh, b::Mesh)
+    # Quick checks
+    if propertynames(a) != propertynames(b) || length(faces(a)) != length(faces(b))
+        return false
+    end
+
+    N = length(faces(a))
+    # for views we want to ignore empty ranges (they don't represent geometry)
+    # and treat 1:N as no range (as that is used interchangeably)
+    views1 = filter(view -> length(view) > 0 && (minimum(view) > 1 || maximum(view) < N), a.views)
+    views2 = filter(view -> length(view) > 0 && (minimum(view) > 1 || maximum(view) < N), b.views)
+    views1 != views2 && return false
+
+    # TODO: Allow different face orders & cyclic permutation within faces.
+    # E.g. use hash.(data[face]), cyclically permute min to front, hash result
+    # and add them to heaps (or sets?) so we can compare them at the end
+    # That should probably be another function as it's probably a significant
+    # step up in overhead?
+    for (attrib1, attrib2) in zip(vertex_attributes(a), vertex_attributes(b))
+        if attrib1 isa FaceView
+            if !(attrib2 isa FaceView) || length(faces(attrib1)) != length(faces(attrib2))
+                return false
+            end
+            for (f1, f2) in zip(faces(attrib1), faces(attrib2))
+                values(attrib1)[f1] == values(attrib2)[f2] || return false
+            end
+        else
+            if attrib2 isa FaceView
+                return false
+            end
+            for (f1, f2) in zip(faces(a), faces(b))
+                attrib1[f1] == attrib2[f2] || return false
+            end
+        end
+    end
+
+    return true
+end
+
 function Base.iterate(mesh::Mesh, i=1)
     return i - 1 < length(mesh) ? (mesh[i], i + 1) : nothing
 end

test/meshes.jl

@@ -70,6 +70,9 @@ end
     @test !allunique([idx for f in faces(dm) for idx in f])
     @test !allunique([idx for f in faces(dm.normal) for idx in f])
 
+    split_meshes = split_mesh(dm)
+    @test all(GeometryBasics.strictly_equal_face_vertices.(split_meshes, direct_meshes))
+
     indirect_meshes = map(rects) do r
         m = GeometryBasics.mesh(coordinates(r), faces(r), normal = normals(r), facetype = QuadFace{Int64})
         # Also testing merge of meshes with views
@@ -81,6 +84,9 @@ end
     @test im == dm
     @test GeometryBasics.facetype(im) == QuadFace{Int64}
 
+    split_meshes = split_mesh(im)
+    @test all(GeometryBasics.strictly_equal_face_vertices.(split_meshes, indirect_meshes))
+
     converted_meshes = map(rects) do r
         m = GeometryBasics.Mesh(coordinates(r), faces(r), normal = normals(r))
         GeometryBasics.expand_faceviews(m)
@@ -95,6 +101,8 @@ end
     @test coordinates(cm) isa Vector
     @test allunique([idx for f in faces(cm) for idx in f])
 
+    split_meshes = split_mesh(cm)
+    @test all(GeometryBasics.strictly_equal_face_vertices.(split_meshes, converted_meshes))
 
     mixed_meshes = map(direct_meshes, indirect_meshes, converted_meshes) do dm, im, cm
         rand((dm, im, cm)) # (with FaceView, with mesh.views & FaceView, w/o FaceView)