Table to FeatureCollection

src/features.jl

@@ -76,24 +76,48 @@ Base.:(==)(f1::Feature, f2::Feature) = object(f1) == object(f2)
 """
     FeatureCollection <: AbstractVector{Feature}
 
+    FeatureCollection(table; [geometrycolumn])
+    FeatureCollection(features::AstractVector; kw...)
+
 A feature collection wrapping a JSON object.
 
 Follows the julia `AbstractArray` interface as a lazy vector of `Feature`,
 and similarly the GeoInterface.jl interface.
+
+FeatureCollection can be constructed from an `AbstractVector` of
+`GeoJSON.Feature` or from any Tables.jl compatible table.
+
+The first `GeoInterface.geometrycolumns(table)` will be used for geometries
+(usually `:geometry`) but `:geometrycolumn` can be specified manually where
+this does not work and the column name is not `:geometry`.
 """
 struct FeatureCollection{T,O,A} <: AbstractVector{T}
     object::O
     features::A
     names::Vector{Symbol}
     types::Dict{Symbol,Type}
 end
-function FeatureCollection(object::O) where O
+function FeatureCollection(object::O; geometrycolumn::Union{Symbol,Nothing}=nothing) where O
+    # First check if object is a table
+    if Tables.istable(object)
+        names = Tables.columnnames(object)
+        geomcolname = isnothing(geometrycolumn) ? first(GI.geometrycolumns(object)) : geometrycolumn
+        colnames = Tables.columnnames(object)
+        geomcolname in colnames || throw(ArgumentError("Table does not contain a `:geometry` column. You may need to specify the column name with the `:geometrycolumn` keyword"))
+        othercolnames = Tuple(cn for cn in colnames if cn != geomcolname)
+        features = [_feature_from_row(row, geomcolname, othercolnames) for row in Tables.rowtable(object)]
+        return FeatureCollection(features)
+    end
+
+    # Otherwise construct a FeatureCollection from other objects
     features = object.features
     if isempty(features)
+        # FeatureCollection without features, get the type for an untyped feature without properties
         names = Symbol[:geometry]
         types = Dict{Symbol,Type}(:geometry => Union{Missing,Geometry})
         T = Feature{Any}
     else
+        # FeatureCollection with features, get the names and field types of all features
         names, types = property_schema(features)
         insert!(names, 1, :geometry)
         types[:geometry] = Union{Missing,Geometry}
@@ -118,6 +142,14 @@ FeatureCollection(features::AbstractVector; kwargs...) =
 names(fc::FeatureCollection) = getfield(fc, :names)
 types(fc::FeatureCollection) = getfield(fc, :types)
 
+function _feature_from_row(row, geomcolname::Symbol, othercolnames::Tuple)
+    geometry = Tables.getcolumn(row, geomcolname)
+    properties = map(othercolnames) do cn
+        cn => Tables.getcolumn(row, cn)
+    end |> NamedTuple
+    Feature(; geometry, properties)
+end
+
 """
     features(fc::FeatureCollection)
 

test/runtests.jl

@@ -121,15 +121,30 @@ include("geojson_samples.jl")
         @test iterate(p, 2) === (2.2, 3)
         @test iterate(p, 3) === nothing
 
+        # Mixed name vector
+        f2 = GeoJSON.Feature(p; properties = (a = 1, geometry = "g", b = 2, c = 3))
+        GeoJSON.FeatureCollection((type = "FeatureCollection", features = [f, f2]))
+    end
+
+    @testset "Tables" begin
+        p = GeoJSON.Point(coordinates = [1.1, 2.2])
+        f = GeoJSON.Feature(p; properties = (a = 1, geometry = "g", b = 2))
+        features = [f]
         # other constructors
         @test DataFrame([GeoJSON.Feature(geometry = p, properties = (a = 1, geometry = "g", b = 2))]) ==
               DataFrame([GeoJSON.Feature((geometry = p, properties = (a = 1, geometry = "g", b = 2)))]) ==
-              DataFrame(GeoJSON.FeatureCollection((type="FeatureCollection", features=[f]))) ==
+              DataFrame(GeoJSON.FeatureCollection((; type="FeatureCollection", features))) ==
               DataFrame(GeoJSON.FeatureCollection(; features))
 
-        # Mixed name vector
-        f2 = GeoJSON.Feature(p; properties = (a = 1, geometry = "g", b = 2, c = 3))
-        GeoJSON.FeatureCollection((type = "FeatureCollection", features = [f, f2]))
+        # Round trip DataFrame -> FeatureCollection -> DataFrame 
+        features = [GeoJSON.Feature(geometry = p, properties = (a = 1, b = 2)), GeoJSON.Feature(geometry = p, properties = (a = 5, b = 10))] 
+        df = DataFrame(GeoJSON.FeatureCollection(features))
+        @test df == DataFrame(GeoJSON.FeatureCollection(df))
+
+        df_custom_col = DataFrame(:points => [p, p], :x => [1, 2])
+        df_converted = DataFrame(GeoJSON.FeatureCollection(df_custom_col; geometrycolumn=:points))
+        @test df_custom_col.points == df_converted.geometry
+        @test df_custom_col.x == df_converted.x
     end
 
     @testset "extent" begin