fix Cylinder tests

src/GeometryBasics.jl

@@ -55,7 +55,7 @@ export uv_mesh, normal_mesh, uv_normal_mesh
 
 export height, origin, radius, width, widths
 export HyperSphere, Circle, Sphere
-export Cylinder, Cylinder2, Cylinder3, Pyramid, extremity
+export Cylinder, Pyramid, extremity
 export HyperRectangle, Rect, Rect2, Rect3, Recti, Rect2i, Rect3i, Rectf, Rect2f, Rect3f, Rectd, Rect2d, Rect3d
 export before, during, meets, overlaps, intersects, finishes
 export centered, direction, area, volume, update

src/basic_types.jl

@@ -141,6 +141,8 @@ function Base.show(io::IO, ::MIME"text/plain", f::MultiFace)
     show(io, getfield(f, :faces))
 end
 
+Base.:(==)(f1::MultiFace, f2::MultiFace) = getfield(f1, :faces) == getfield(f2, :faces)
+
 @propagate_inbounds Base.getindex(x::Polytope, i::Integer) = coordinates(x)[i]
 @propagate_inbounds Base.iterate(x::Polytope) = iterate(coordinates(x))
 @propagate_inbounds Base.iterate(x::Polytope, i) = iterate(coordinates(x), i)

src/interfaces.jl

@@ -104,7 +104,7 @@ function decompose(::Type{F}, primitive::AbstractGeometry) where {F<:AbstractVer
             return nothing
         end
     end
-    return collect_with_eltype(F, f)
+    return decompose(F, f)
 end
 
 function decompose(::Type{F}, f::AbstractVector) where {F<:AbstractVertexFace}

test/geometrytypes.jl

@@ -2,24 +2,11 @@ using Test, GeometryBasics
 
 @testset "Cylinder" begin
     @testset "constructors" begin
-        o, extr, r = Point2f(1, 2), Point2f(3, 4), 5.0f0
-        s = Cylinder(o, extr, r)
-        @test typeof(s) == Cylinder{2,Float32}
-        @test typeof(s) == Cylinder2{Float32}
-        @test origin(s) == o
-        @test extremity(s) == extr
-        @test radius(s) == r
-        #@test abs(height(s)- norm([1,2]-[3,4]))<1e-5
-        h = norm(o - extr)
-        @test isapprox(height(s), h)
-        #@test norm(direction(s) - Point{2,Float32}([2,2]./norm([1,2]-[3,4])))<1e-5
-        @test isapprox(direction(s), Point2f(2, 2) ./ h)
         v1 = rand(Point{3,Float64})
         v2 = rand(Point{3,Float64})
         R = rand()
         s = Cylinder(v1, v2, R)
-        @test typeof(s) == Cylinder{3,Float64}
-        @test typeof(s) == Cylinder3{Float64}
+        @test typeof(s) == Cylinder{Float64}
         @test origin(s) == v1
         @test extremity(s) == v2
         @test radius(s) == R
@@ -29,57 +16,60 @@ using Test, GeometryBasics
     end
 
     @testset "decompose" begin
-
-        m = GeometryBasics.normal_mesh(Sphere(Point3f(0), 1f0))
-        @test decompose_uv(m) isa Vector{Vec2f}
-
-        o, extr, r = Point2f(1, 2), Point2f(3, 4), 5.0f0
-        s = Cylinder(o, extr, r)
-        positions = Point{3,Float32}[(-0.7677671, 3.767767, 0.0),
-                                     (2.767767, 0.23223293, 0.0),
-                                     (0.23223293, 4.767767, 0.0),
-                                     (3.767767, 1.2322329, 0.0), (1.2322329, 5.767767, 0.0),
-                                     (4.767767, 2.232233, 0.0)]
-        @test decompose(Point3f, Tesselation(s, (2, 3))) ≈ positions
-
-        FT = TriangleFace{Int}
-        faces = FT[(1, 2, 4), (1, 4, 3), (3, 4, 6), (3, 6, 5)]
-        @test faces == decompose(FT, Tesselation(s, (2, 3)))
-
         v1 = Point{3,Float64}(1, 2, 3)
         v2 = Point{3,Float64}(4, 5, 6)
         R = 5.0
         s = Cylinder(v1, v2, R)
-        positions = Point{3,Float64}[(4.535533905932738, -1.5355339059327373, 3.0),
-                                     (7.535533905932738, 1.4644660940672627, 6.0),
-                                     (3.0412414523193148, 4.041241452319315,
-                                      -1.0824829046386295),
-                                     (6.041241452319315, 7.041241452319315,
-                                      1.9175170953613705),
-                                     (-2.535533905932737, 5.535533905932738,
-                                      2.9999999999999996),
-                                     (0.46446609406726314, 8.535533905932738, 6.0),
-                                     (-1.0412414523193152, -0.04124145231931431,
-                                      7.0824829046386295),
-                                     (1.9587585476806848, 2.9587585476806857,
-                                      10.08248290463863), (1, 2, 3), (4, 5, 6)]
+        positions = Point{3,Float64}[
+            (4.535533905932738, -1.5355339059327373, 3.0),
+            (3.0412414523193148, 4.041241452319315, -1.0824829046386295),
+            (-2.535533905932737, 5.535533905932738, 2.9999999999999996),
+            (-1.0412414523193152, -0.04124145231931431, 7.0824829046386295),
+            (7.535533905932738, 1.4644660940672627, 6.0),
+            (6.041241452319315, 7.041241452319315, 1.9175170953613705),
+            (0.46446609406726314, 8.535533905932738, 6.0),
+            (1.9587585476806848, 2.9587585476806857, 10.08248290463863), 
+            (1, 2, 3), 
+            (4, 5, 6)
+        ]
 
         @test decompose(Point3{Float64}, Tesselation(s, 8)) ≈ positions
 
-        faces = TriangleFace{Int}[(3, 2, 1), (4, 2, 3), (5, 4, 3), (6, 4, 5), (7, 6, 5),
-                                  (8, 6, 7), (1, 8, 7), (2, 8, 1), (3, 1, 9), (2, 4, 10),
-                                  (5, 3, 9), (4, 6, 10), (7, 5, 9), (6, 8, 10), (1, 7, 9),
-                                  (8, 2, 10)]
-        @test faces == decompose(TriangleFace{Int}, Tesselation(s, 8))
+        _faces = [
+            MultiFace(position = TriangleFace(9, 1, 2), normal = TriangleFace(5, 5, 5)),
+            MultiFace(position = TriangleFace(9, 2, 3), normal = TriangleFace(5, 5, 5)),
+            MultiFace(position = TriangleFace(9, 3, 4), normal = TriangleFace(5, 5, 5)),
+            MultiFace(position = TriangleFace(9, 4, 1), normal = TriangleFace(5, 5, 5)),
+            MultiFace(position = TriangleFace(1, 5, 6), normal = TriangleFace(1, 1, 2)),
+            MultiFace(position = TriangleFace(1, 6, 2), normal = TriangleFace(1, 2, 2)),
+            MultiFace(position = TriangleFace(2, 6, 7), normal = TriangleFace(2, 2, 3)),
+            MultiFace(position = TriangleFace(2, 7, 3), normal = TriangleFace(2, 3, 3)),
+            MultiFace(position = TriangleFace(3, 7, 8), normal = TriangleFace(3, 3, 4)),
+            MultiFace(position = TriangleFace(3, 8, 4), normal = TriangleFace(3, 4, 4)),
+            MultiFace(position = TriangleFace(4, 8, 5), normal = TriangleFace(4, 4, 1)),
+            MultiFace(position = TriangleFace(4, 5, 1), normal = TriangleFace(4, 1, 1)),
+            MultiFace(position = TriangleFace(10, 5, 6), normal = TriangleFace(6, 6, 6)),
+            MultiFace(position = TriangleFace(10, 6, 7), normal = TriangleFace(6, 6, 6)),
+            MultiFace(position = TriangleFace(10, 7, 8), normal = TriangleFace(6, 6, 6)),
+            MultiFace(position = TriangleFace(10, 8, 5), normal = TriangleFace(6, 6, 6)),
+        ]
+
+        @test _faces == decompose(TriangleFace{Int}, Tesselation(s, 8))
 
         m = triangle_mesh(Tesselation(s, 8))
         @test m === triangle_mesh(m)
-        @test GeometryBasics.faces(m) == faces
-        @test GeometryBasics.coordinates(m) ≈ positions
-        m = normal_mesh(s)# just test that it works without explicit resolution parameter
+        fs, maps = GeometryBasics.merge_vertex_indices(GeometryBasics.simplify_faces((:position,), _faces))
+        @test GeometryBasics.faces(m) == decompose(GLTriangleFace, fs)
+        @test GeometryBasics.coordinates(m) ≈ positions[maps[1]]
+
+        m = normal_mesh(s) # just test that it works without explicit resolution parameter
+        @test hasproperty(m, :position)
+        @test hasproperty(m, :normal)
+        @test length(m.position) == length(m.normal)
+        @test faces(m) isa AbstractVector{GLTriangleFace}
 
         muv = uv_mesh(s)
-        @test Rect(Point.(texturecoordinates(muv))) == Rect2f(Vec2f(0), Vec2f(1.0))
+        @test !hasproperty(muv, :uv) # not defined yet
     end
 end