add function for removing duplicate faces

Author: ffreyer

src/basic_types.jl

@@ -81,6 +81,53 @@ function Base.show(io::IO, x::NgonFace{N, T}) where {N, T}
     return print(io, name, "(", join(value.(x), ", "), ")")
 end
 
+# two faces are the same if they match or they just cycle indices
+function Base.:(==)(f1::FT, f2::FT) where {N, FT <: AbstractFace{N}}
+    _, min_i1 = findmin(f1.data)
+    _, min_i2 = findmin(f2.data)
+    @inbounds for i in 1:N
+        if f1[mod1(min_i1 + i, end)] !== f2[mod1(min_i2 + i, end)]
+            return false
+        end
+    end
+    return true
+end
+function Base.hash(f::AbstractFace{N}, h::UInt) where {N}
+    _, min_i = findmin(f.data)
+    @inbounds for i in min_i:N
+        h = hash(f[i], h)
+    end
+    @inbounds for i in 1:min_i-1
+        h = hash(f[i], h)
+    end
+    return h
+end
+Base.isequal(f1::AbstractFace, f2::AbstractFace) = ==(f1, f2)
+
+# Fastpaths
+Base.:(==)(f1::FT, f2::FT) where {FT <: AbstractFace{2}} = minmax(f1.data...) == minmax(f2.data...)
+Base.hash(f::AbstractFace{2}, h::UInt) = hash(minmax(f.data...), h)
+
+function Base.:(==)(f1::FT, f2::FT) where {FT <: AbstractFace{3}}
+    return (f1.data == f2.data) || (f1.data == (f2[2], f2[3], f2[1])) || 
+        (f1.data == (f2[3], f2[1], f2[2]))
+end
+function Base.hash(f::AbstractFace{3}, h::UInt)
+    if f[1] < f[2]
+        if f[1] < f[3]
+            return hash(f.data, h)
+        else
+            return hash((f[3], f[1], f[2]), h)
+        end
+    else
+        if f[2] < f[3]
+            return hash((f[2], f[3], f[1]), h)
+        else
+            return hash((f[3], f[1], f[2]), h)
+        end
+    end
+end
+
 Face(::Type{<:NgonFace{N}}, ::Type{T}) where {N,T} = NgonFace{N,T}
 Face(F::Type{NgonFace{N,FT}}, ::Type{T}) where {FT,N,T} = F
 

src/meshes.jl

@@ -461,6 +461,17 @@ function split_mesh(mesh::Mesh, views::Vector{UnitRange{Int}} = mesh.views)
     end
 end
 
+"""
+    remove_duplicates(faces)
+
+Uses a Dict to remove duplicates from the given `faces`.
+"""
+function remove_duplicates(fs::AbstractVector{FT}) where {FT <: AbstractFace}
+    hashmap = Dict{FT, Nothing}()
+    foreach(k -> setindex!(hashmap, nothing, k), fs)
+    return collect(keys(hashmap))
+end
+
 
 function map_coordinates(f, mesh::Mesh)
     result = copy(mesh)

src/primitives/rectangles.jl

@@ -308,13 +308,13 @@ function Base.to_indices(A::AbstractMatrix{T}, I::Tuple{Rect2{IT}}) where {T,IT<
     return ((mini[1] + 1):(mini[1] + wh[1]), (mini[2] + 1):(mini[2] + wh[2]))
 end
 
-function minmax(p::StaticVector, vmin, vmax)
+function Base.minmax(p::StaticVector, vmin, vmax)
     any(isnan, p) && return (vmin, vmax)
     return min.(p, vmin), max.(p, vmax)
 end
 
 # Annoying special case for view(Vector{Point}, Vector{Face})
-function minmax(tup::Tuple, vmin, vmax)
+function Base.minmax(tup::Tuple, vmin, vmax)
     for p in tup
         any(isnan, p) && continue
         vmin = min.(p, vmin)