add more tests

Author: SimonDanisch

src/basic_types.jl

@@ -29,8 +29,8 @@ Face index, connecting points to form a simplex
 
 @fixed_vector SimplexFace AbstractSimplexFace
 const LineFace{T} = SimplexFace{2, T}
+const TetrahedronFace{T} = SimplexFace{4, T}
 Face(::Type{<: SimplexFace{N}}, ::Type{T}) where {N, T} = SimplexFace{N, T}
-Face(::Type{<: NSimplex{N}}, ::Type{T}) where {N, T} = SimplexFace{N, T}
 
 
 
@@ -40,7 +40,6 @@ Face index, connecting points to form an Ngon
 
 @fixed_vector NgonFace AbstractNgonFace
 const TriangleFace{T} = NgonFace{3, T}
-
 const QuadFace{T} = NgonFace{4, T}
 
 Base.show(io::IO, x::TriangleFace{T}) where T = print(io, "TriangleFace(", join(x, ", "), ")")
@@ -172,15 +171,14 @@ struct LineString{
         Dim, T <: Real,
         P <: AbstractPoint,
         V <: AbstractVector{<: LineP{Dim, T, P}}
-    } <: AbstractVector{LineP{Dim, T}}
+    } <: AbstractVector{LineP{Dim, T, P}}
     points::V
 end
 coordinates(x::LineString) = x.points
 
 Base.size(x::LineString) = size(coordinates(x))
 Base.getindex(x::LineString, i) = getindex(coordinates(x), i)
 
-
 function LineString(points::AbstractVector{LineP{Dim, T, P}}) where {Dim, T, P}
     LineString{Dim, T, P, typeof(points)}(points)
 end
@@ -244,8 +242,8 @@ end
 
 Base.:(==)(a::Polygon, b::Polygon) = (a.exterior == b.exterior) && (a.interiors == b.interiors)
 
-function Polygon(exterior::AbstractVector{LineP{Dim, T, P}}, interiors::V) where {Dim, T, P, V <: AbstractVector{<: AbstractVector{LineP{Dim, T, P}}}}
-    Polygon{Dim, T, typeof(exterior), V}(exterior, interiors)
+function Polygon(exterior::E, interiors::AbstractVector{E}) where E <: AbstractVector{LineP{Dim, T, P}} where {Dim, T, P}
+    Polygon{Dim, T, P, typeof(exterior), typeof(interiors)}(exterior, interiors)
 end
 
 Polygon(exterior::L) where L <: AbstractVector{<: LineP} = Polygon(exterior, L[])
@@ -268,18 +266,13 @@ struct MultiPolygon{
         Element <: AbstractPolygon{Dim, T},
         A <: AbstractVector{Element}
     } <: AbstractVector{Element}
-
     polygons::A
 end
 
-function MultiPolygon(polygons::AbstractVector{P}; meta...) where P <: AbstractPolygon{Dim, T} where {Dim, T}
-    nt = values(meta)
-    n = keys(nt)
-    typs = Tuple{eltype.(values(nt))...}
-    m = StructArray(nt)
-    PType = MetaPolygon{Dim, T, P, n, typs}
-    mpolys = StructArray{PType}((polygons, m))
-    MultiPolygon{Dim, T, PType, typeof(mpolys)}(mpolys)
+
+
+function MultiPolygon(polygons::AbstractVector{P}; kw...) where P <: AbstractPolygon{Dim, T} where {Dim, T}
+    MultiPolygon(meta(polygons; kw...))
 end
 
 Base.getindex(mp::MultiPolygon, i) = mp.polygons[i]

src/metadata.jl

@@ -65,7 +65,7 @@ macro meta_type(name, mainfield, supertype, params...)
         const $NoParams{Typ, Names, Types} = $MetaName{$(params...), Typ, Names, Types} where {$(params...)}
 
         function Base.getproperty(x::$MetaName{$(params...), Typ, Names, Types}, field::Symbol) where {$(params...), Typ, Names, Types}
-            field === $field && return getfield(x, $field)
+            field === $field && return getfield(x, :main)
             field === :main && return getfield(x, :main)
             Base.sym_in(field, Names) && return getfield(getfield(x, :meta), field)
             error("Field $field not part of Element")
@@ -120,3 +120,8 @@ Base.getindex(x::PointMeta, idx::Int) = getindex(metafree(x), idx)
 
 @meta_type(NgonFace, ngon, AbstractNgonFace, N, T)
 Base.getindex(x::NgonFaceMeta, idx::Int) = getindex(metafree(x), idx)
+
+@meta_type(SimplexFace, simplex, AbstractSimplexFace, N, T)
+Base.getindex(x::SimplexFaceMeta, idx::Int) = getindex(metafree(x), idx)
+
+@meta_type(Polygon, polygon, AbstractPolygon, N, T)

src/viewtypes.jl

@@ -76,6 +76,21 @@ end
     reinterpret(Face(P, T), TupleView{N, skip}(points))
 end
 
+
+@inline function connect(points::AbstractMatrix{T}, P::Type{<: AbstractPoint{N}}) where {T <: Real, N}
+    if size(points, 1) === N
+        return reinterpret(Point{N, T}, points)
+    elseif size(points, 2) === N
+        seglen = size(points, 1)
+        columns = ntuple(N) do i
+            view(points, ((i-1) * seglen + 1):(i * seglen))
+        end
+        return StructArray{Point{N, T}}((StructArray{NTuple{N, T}}(columns),))
+    else
+        error("Dim 1 or 2 must be equal to the point dimension!")
+    end
+end
+
 """
 FaceView enables to link one array of points via a face array, to generate one
 abstract array of elements.

test/REQUIRE

@@ -0,0 +1 @@
+Query

test/runtests.jl

@@ -1,23 +1,89 @@
 using GeometryBasics
-using GeometryBasics: Polygon, MultiPolygon, Point, LineFace, Polytope, Line, Simplex, connect, Triangle, NSimplex, Tetrahedron, TupleView, TriangleFace, SimplexFace, LineString, Mesh
-using Test, Random
-
-
-@testset "polygon with metadata" begin
-    polys = [Polygon(rand(Point{2, Float32}, 20)) for i in 1:10]
-    pnames = [randstring(4) for i in 1:10]
-    numbers = rand(10)
-    bin = rand(Bool, 10)
-    x = MultiPolygon(polys, name = pnames, value = numbers, category = bin)
-    for (mp, p, n, num, b) in zip(x, polys, pnames, numbers, bin)
-        @test mp.polygon == p
-        @test mp.name == n
-        @test mp.value == num
-        @test mp.category == b
+using GeometryBasics: Polygon, MultiPolygon, Point, LineFace, Polytope, Line
+using GeometryBasics: Simplex, connect, Triangle, NSimplex, Tetrahedron
+using GeometryBasics: QuadFace, hascolumn, getcolumn, metafree, coordinates, TetrahedronFace
+using GeometryBasics: TupleView, TriangleFace, SimplexFace, LineString, Mesh, meta
+using Test, Random, Query, StructArrays, Tables
+using StaticArrays
+
+
+@testset "embedding metadata" begin
+    @testset "Meshes" begin
+
+        @testset "per vertex attributes" begin
+            points = rand(Point{3, Float64}, 8)
+            tfaces = TetrahedronFace{Int}[(1, 2, 3, 4), (5, 6, 7, 8)]
+            normals = rand(SVector{3, Float64}, 8)
+            stress = LinRange(0, 1, 8)
+            mesh = Mesh(meta(points, normals = normals, stress = stress), tfaces)
+
+            @test hascolumn(coordinates(mesh), :stress)
+            @test hascolumn(coordinates(mesh), :normals)
+            @test coordinates(mesh).stress === stress
+            @test coordinates(mesh).normals === normals
+            @test coordinates(mesh).normals === normals
+            @test GeometryBasics.faces(mesh) === tfaces
+
+        end
+
+        @testset "per face attributes" begin
+
+            # Construct a cube out of Quads
+            points = Point{3, Float64}[
+                (0.0, 0.0, 0.0), (2.0, 0.0, 0.0),
+                (2.0, 2.0, 0.0), (0.0, 2.0, 0.0),
+                (0.0, 0.0, 12.0), (2.0, 0.0, 12.0),
+                (2.0, 2.0, 12.0), (0.0, 2.0, 12.0)
+            ]
+
+            facets = QuadFace{Cint}[
+                1:4,
+                5:8,
+                [1,5,6,2],
+                [2,6,7,3],
+                [3, 7, 8, 4],
+                [4, 8, 5, 1]
+            ]
+
+            markers = Cint[-1, -2, 0, 0, 0, 0]
+            # attach some additional information to our faces!
+            mesh = Mesh(points, meta(facets, markers = markers))
+            @test hascolumn(GeometryBasics.faces(mesh), :markers)
+            # test with === to assert we're not doing any copies
+            @test getcolumn(GeometryBasics.faces(mesh), :markers) === markers
+            @test coordinates(mesh) === points
+            @test metafree(GeometryBasics.faces(mesh)) === facets
+
+        end
+
+    end
+    @testset "polygon with metadata" begin
+        polys = [Polygon(rand(Point{2, Float32}, 20)) for i in 1:10]
+        pnames = [randstring(4) for i in 1:10]
+        numbers = LinRange(0.0, 1.0, 10)
+        bin = rand(Bool, 10)
+        # create just an array
+        plain = meta(polys, name = pnames, value = numbers, category = bin)
+        # create a MultiPolygon with the right type & meta information!
+        multipoly = MultiPolygon(polys; name = pnames, value = numbers, category = bin)
+        for x in (plain, multipoly)
+            for (mp, p, n, num, b) in zip(x, polys, pnames, numbers, bin)
+                @test mp.polygon == p
+                @test mp.name == n
+                @test mp.value == num
+                @test mp.category == b
+            end
+
+            filtered = @from i in x begin
+                @where i.value < 0.7
+                @select i
+                @collect
+            end
+            @test length(filtered) == 7
+        end
     end
 end
 
-
 @testset "view" begin
     @testset "TupleView" begin
         x = [1, 2, 3, 4, 5, 6]
@@ -48,8 +114,20 @@ end
 
         triangles = connect(x, Triangle)
         @test triangles == [Triangle(Point(1, 2), Point(3, 4), Point(5, 6))]
-        tetrahedra = connect(x, NSimplex{3})
-        @test tetrahedra == [Tetrahedron(x[1], x[2], x[3])]
+        x = connect([1, 2, 3, 4, 5, 6, 7, 8], Point{2})
+        tetrahedra = connect(x, NSimplex{4})
+        @test tetrahedra == [Tetrahedron(x[1], x[2], x[3], x[4])]
+
+        @testset "matrix non-copy point views" begin
+            # point in row
+            points = [1 2; 1 4; 66 77]
+            comparison = [Point(1, 2), Point(1, 4), Point(66, 77)]
+            @test connect(points, Point{2}) == comparison
+            # point in column
+            points = [1 1 66; 2 4 77]
+            # huh, reinterpret array doesn't seem to like `==`
+            @test all(((a,b),)-> a==b, zip(connect(points, Point{2}), comparison))
+        end
     end
 
     @testset "face views" begin
@@ -61,8 +139,8 @@ end
         x = Point{3}(1.0)
         triangles = connect([x], [TriangleFace(1, 1, 1)])
         @test triangles == [Triangle(x, x, x)]
-
-        faces = connect([1, 2, 3], SimplexFace{3})
+        points = connect([1, 2, 3, 4, 5, 6, 7, 8], Point{2})
+        faces = connect([1, 2, 3, 4], SimplexFace{4})
         triangles = connect(points, faces)
         @test triangles == [Tetrahedron(points...)]
     end
@@ -133,7 +211,8 @@ end
         mesh = Mesh([x], [TriangleFace(1, 1, 1)])
         @test mesh == [Triangle(x, x, x)]
 
-        faces = connect([1, 2, 3], SimplexFace{3})
+        points = connect([1, 2, 3, 4, 5, 6, 7, 8], Point{2})
+        faces = connect([1, 2, 3, 4], SimplexFace{4})
         mesh = Mesh(points, faces)
         @test mesh == [Tetrahedron(points...)]