Rename Feature to MetaT

Author: Sov-trotter

src/GeometryBasics.jl

@@ -35,7 +35,7 @@ module GeometryBasics
     export GLTriangleFace, GLNormalMesh3D, GLPlainTriangleMesh, GLUVMesh3D, GLUVNormalMesh3D
     export AbstractMesh, Mesh, TriangleMesh
     export GLNormalMesh2D, PlainTriangleMesh
-    export Feature, collect_feature
+    export MetaT, collect_MetaT
 
     # all the different predefined mesh types
     # Note: meshes can contain arbitrary meta information,

src/metadata.jl

@@ -196,57 +196,57 @@ Base.size(x::MeshMeta) = size(metafree(x))
 
 """
 
-    Feature(::type{T}, Names, Types)
+    MetaT(::type{T}, Names, Types)
     
-Returns a `Feature` that holds a geometry and it's metadata
+Returns a `MetaT` that holds a geometry and it's metadata
 
-`Feature` acts the same as `Meta` method.
+`MetaT` acts the same as `Meta` method.
 The difference lies in the fact that it is designed to handle
 geometries and metadata of different/heterogeneous types.
 
-eg: While a Point MetaGeometry is a `PointMeta`, the Feature representation is `Feature{Point}`
+eg: While a Point MetaGeometry is a `PointMeta`, the MetaT representation is `MetaT{Point}`
 The downside being it's not subtyped to `AbstractPoint` like a `PointMeta` is.
 
 Example:
 ```julia
-julia> Feature(Point(1, 2), city = "Mumbai")
-Feature{Point{2,Int64},(:city,),Tuple{String}}([1, 2], (city = "Mumbai",))
+julia> MetaT(Point(1, 2), city = "Mumbai")
+MetaT{Point{2,Int64},(:city,),Tuple{String}}([1, 2], (city = "Mumbai",))
 ```
 """
-struct Feature{T, Names, Types} 
+struct MetaT{T, Names, Types} 
     main::T
     meta::NamedTuple{Names, Types}
 end
 
-Feature(x; kwargs...) = Feature(x, values(kwargs))
+MetaT(x; kwargs...) = MetaT(x, values(kwargs))
 
 """
 
-    metafree(x::Feature)
-    metafree(x::Array{Feature})
+    metafree(x::MetaT)
+    metafree(x::Array{MetaT})
 
-Free the Feature from metadata
+Free the MetaT from metadata
 i.e. returns the geometry/array of geometries
 """
-function metafree(x::Feature)
+function metafree(x::MetaT)
     getfield(x, 1)
 end
-metafree(x::AbstractVector{<: Feature}) = map(metafree, x)
+metafree(x::AbstractVector{<: MetaT}) = map(metafree, x)
 
 """
 
-    meta(x::Feature)
-    meta(x::Array{Feature})
+    meta(x::MetaT)
+    meta(x::Array{MetaT})
     
-Returns the metadata of a `Feature`
+Returns the metadata of a `MetaT`
 """
-function meta(x::Feature)
+function meta(x::MetaT)
     getfield(x, 2)
 end
-meta(x::AbstractVector{<: Feature}) = map(meta, x)
+meta(x::AbstractVector{<: MetaT}) = map(meta, x)
 
 # helper methods
-function Base.getproperty(x::Feature, field::Symbol)
+function Base.getproperty(x::MetaT, field::Symbol)
     if field == :main 
         metafree(x)
     elseif field == :meta
@@ -256,34 +256,34 @@ function Base.getproperty(x::Feature, field::Symbol)
     end
 end
 
-Base.propertynames(x::Feature) = (:main, propertynames(meta(x))...)
-getnamestypes(::Type{Feature{T, Names, Types}}) where {T, Names, Types} = (T, Names, Types) 
+Base.propertynames(x::MetaT) = (:main, propertynames(meta(x))...)
+getnamestypes(::Type{MetaT{T, Names, Types}}) where {T, Names, Types} = (T, Names, Types) 
 
 # explicitly give the "schema" of the object to StructArrays
-function StructArrays.staticschema(::Type{F}) where {F<:Feature} 
+function StructArrays.staticschema(::Type{F}) where {F<:MetaT} 
     T, names, types = getnamestypes(F)
     NamedTuple{(:main, names...), Base.tuple_type_cons(T, types)}
 end
 
-# generate an instance of Feature type
-function StructArrays.createinstance(::Type{F}, x, args...) where {F<:Feature}  
+# generate an instance of MetaT type
+function StructArrays.createinstance(::Type{F}, x, args...) where {F<:MetaT}  
      T , names, types = getnamestypes(F)
-     Feature(x, NamedTuple{names, types}(args))
+     MetaT(x, NamedTuple{names, types}(args))
 end
 
 """
-Accepts an iterable of Features and put it into a StructArray 
+Accepts an iterable of MetaTs and put it into a StructArray 
 """
-function collect_feature(iter)
+function collect_MetaT(iter)
     cols = Tables.columntable(iter)
-    collect_feature(first(cols), Base.tail(cols)) 
+    collect_MetaT(first(cols), Base.tail(cols)) 
 end
 
-function collect_feature(main, meta::NamedTuple{names, types}) where {names, types}
-    F = Feature{eltype(main), names, StructArrays.eltypes(types)}
+function collect_MetaT(main, meta::NamedTuple{names, types}) where {names, types}
+    F = MetaT{eltype(main), names, StructArrays.eltypes(types)}
     return StructArray{F}(; main=main, meta...)
 end
 
-Base.getindex(x::Feature, idx::Int) = getindex(metafree(x), idx)
-Base.size(x::Feature) = size(metafree(x))
+Base.getindex(x::MetaT, idx::Int) = getindex(metafree(x), idx)
+Base.size(x::MetaT) = size(metafree(x))
 

test/runtests.jl

@@ -131,24 +131,24 @@ using GeometryBasics: attributes
    end
 end
 
-@testset "embedding Feature" begin
-    @testset "Feature{Polygon}" begin
+@testset "embedding MetaT" begin
+    @testset "MetaT{Polygon}" begin
         polys = [Polygon(rand(Point{2, Float32}, 20)) for i in 1:10]
         multipol = MultiPolygon(polys)
         pnames = [randstring(4) for i in 1:10]
         numbers = LinRange(0.0, 1.0, 10)
         bin = rand(Bool, 10)
         # create a polygon
-        poly = Feature(polys[1], name = pnames[1], value = numbers[1], category = bin[1])
+        poly = MetaT(polys[1], name = pnames[1], value = numbers[1], category = bin[1])
         # create a MultiPolygon with the right type & meta information!
-        multipoly = Feature(multipol, name = pnames, value = numbers, category = bin)
-        @test multipoly isa Feature
-        @test poly isa Feature
+        multipoly = MetaT(multipol, name = pnames, value = numbers, category = bin)
+        @test multipoly isa MetaT
+        @test poly isa MetaT
 
         @test GeometryBasics.getcolumn(poly, :name) == pnames[1]
         @test GeometryBasics.getcolumn(multipoly, :name) == pnames
 
-        meta_p = Feature(polys[1], boundingbox=Rect(0, 0, 2, 2))
+        meta_p = MetaT(polys[1], boundingbox=Rect(0, 0, 2, 2))
         @test meta_p.boundingbox === Rect(0, 0, 2, 2)
         @test GeometryBasics.metafree(meta_p) == polys[1]
         @test GeometryBasics.metafree(poly) == polys[1]
@@ -158,10 +158,10 @@ end
         @test GeometryBasics.meta(multipoly) == (name = pnames, value = numbers, category = bin)    
     end
 
-    @testset "Feature{Point}" begin
+    @testset "MetaT{Point}" begin
         p = Point(1.1, 2.2)
         @test p isa AbstractVector{Float64}
-        pm = Feature(Point(1.1, 2.2); a=1, b=2)
+        pm = MetaT(Point(1.1, 2.2); a=1, b=2)
         p1 = Point(2.2, 3.6)
         p2 = [p, p1]
         @test coordinates(p2) == p2
@@ -172,10 +172,10 @@ end
         @test GeometryBasics.meta(pm) == (a = 1, b = 2)
     end
 
-    @testset "Feature{MultiPoint}" begin
+    @testset "MetaT{MultiPoint}" begin
         p = collect(Point{2, Float64}(x, x+1) for x in 1:5)
         @test p isa AbstractVector
-        mpm = Feature(MultiPoint(p); a=1, b=2)
+        mpm = MetaT(MultiPoint(p); a=1, b=2)
         @test coordinates(mpm.main) == Point{2, Float64}[(x, x+1) for x in 1:5]
         @test mpm.meta === (a=1, b=2)
         @test mpm.main == p
@@ -184,21 +184,21 @@ end
         @test GeometryBasics.meta(mpm) == (a = 1, b = 2)
     end
 
-    @testset "Feature{LineString}" begin
-        linestring = Feature(LineString(Point{2, Int}[(10, 10), (20, 20), (10, 40)]), a = 1, b = 2)
-        @test linestring isa Feature
+    @testset "MetaT{LineString}" begin
+        linestring = MetaT(LineString(Point{2, Int}[(10, 10), (20, 20), (10, 40)]), a = 1, b = 2)
+        @test linestring isa MetaT
         @test linestring.meta === (a = 1, b = 2)
         @test propertynames(linestring) == (:main, :a, :b)
         @test GeometryBasics.metafree(linestring) == LineString(Point{2, Int}[(10, 10), (20, 20), (10, 40)])
         @test GeometryBasics.meta(linestring) == (a = 1, b = 2)
     end
 
-    @testset "Feature{MultiLineString}" begin
+    @testset "MetaT{MultiLineString}" begin
         linestring1 = LineString(Point{2, Int}[(10, 10), (20, 20), (10, 40)])
         linestring2 = LineString(Point{2, Int}[(40, 40), (30, 30), (40, 20), (30, 10)])
         multilinestring = MultiLineString([linestring1, linestring2])
-        multilinestringmeta = Feature(MultiLineString([linestring1, linestring2]); boundingbox = Rect(1.0, 1.0, 2.0, 2.0))
-        @test multilinestringmeta isa Feature
+        multilinestringmeta = MetaT(MultiLineString([linestring1, linestring2]); boundingbox = Rect(1.0, 1.0, 2.0, 2.0))
+        @test multilinestringmeta isa MetaT
         @test multilinestringmeta.meta === (boundingbox = Rect(1.0, 1.0, 2.0, 2.0),)
         @test multilinestringmeta.main == multilinestring
         @test propertynames(multilinestringmeta) == (:main, :boundingbox)
@@ -207,18 +207,18 @@ end
     end
 
     #=
-    So mesh works differently for Feature
-    since `Feature{Point}` not subtyped to `AbstractPoint`
+    So mesh works differently for MetaT
+    since `MetaT{Point}` not subtyped to `AbstractPoint`
     =#
 
-   @testset "Feature{Mesh}" begin
+   @testset "MetaT{Mesh}" 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_nometa = Mesh(points, tfaces)
-            mesh = Feature(mesh_nometa, normals = normals, stress = stress)
+            mesh = MetaT(mesh_nometa, normals = normals, stress = stress)
 
             @test hasproperty(mesh, :stress)
             @test hasproperty(mesh, :normals)
@@ -604,19 +604,19 @@ end
     @test <(x, x1)
 end
 
-@testset "Feature and heterogeneous data" begin
+@testset "MetaT and heterogeneous data" begin
     ls = [LineString([Point(i, (i+1)^2/6), Point(i*0.86,i+5), Point(i/3, i/7)]) for i in 1:10]
     mls = MultiLineString([LineString([Point(i+1, (i)^2/6), Point(i*0.75,i+8), Point(i/2.5, i/6.79)]) for i in 5:10]) 
     poly = Polygon(Point{2, Int}[(40, 40), (20, 45), (45, 30), (40, 40)])
     geom = [ls..., mls, poly]
     prop = Any[(country_states = "India$(i)", rainfall = (i*9)/2) for i in 1:11]
     push!(prop, (country_states = 12, rainfall = 1000))   # a pinch of heterogeneity
 
-    feat = [Feature(i, j) for (i,j) = zip(geom, prop)]
-    sa = collect_feature(feat)
+    feat = [MetaT(i, j) for (i,j) = zip(geom, prop)]
+    sa = collect_MetaT(feat)
 
-    @test nameof(eltype(feat)) == :Feature
-    @test eltype(sa) === Feature{Any,(:country_states, :rainfall),Tuple{Any,Float64}}
+    @test nameof(eltype(feat)) == :MetaT
+    @test eltype(sa) === MetaT{Any,(:country_states, :rainfall),Tuple{Any,Float64}}
     @test propertynames(sa) === (:main, :country_states, :rainfall)
     @test getproperty(sa, :country_states) isa Array{Any}
     @test getproperty(sa, :main) == geom