easy conversion for GeoJSON as R list to sf #185

timelyportfolio · 2017-01-20T17:50:05Z

As discussed in #39 (comment), easily converting GeoJSON as an R list to sf would be really helpful. @ateucher has already done all the hard work for the reverse sf -> GeoJSON ropensci/geojsonio#95.

The text was updated successfully, but these errors were encountered:

edzer · 2017-01-20T19:09:15Z

If someone can provide me with examples of each of the seven types, as R data, I'll take a look.

timelyportfolio · 2017-01-20T19:10:17Z

Would it be safe to assume that character data is GeoJSON? I know geojsonio::geojson_json uses classes json and geo_json.

timelyportfolio · 2017-01-20T19:11:27Z

@edzer, fortunately with the work done by @ateucher, this should be easy. I'll try to do at least a couple quick examples unless someone else wants to :)

edzer · 2017-01-20T19:11:29Z

sf assumes that character data is WKT; I may hope the R lists with GeoJSON have a class?

timelyportfolio · 2017-01-20T19:23:56Z

@edzer, this will provide a pretty thorough start using your examples in sf.

library(sf)
# use newest geojsonio from Github
# devtools::install_github("ropensci/geojsonio")
library(geojsonio)
library(magrittr)

# use sf examples
p1 = st_point(c(1,2))
geojsonio::geojson_list(p1)

(p2 = st_point(c(1,2,3)))
geojsonio::geojson_list(p2)

p3 = st_point(c(1,2,3), "XYM")
geojsonio::geojson_list(p3)

pts = matrix(1:10, , 2)
(mp1 = st_multipoint(pts))
geojsonio::geojson_list(mp1)

pts = matrix(1:15, , 3)
(mp2 = st_multipoint(pts))
geojsonio::geojson_list(mp2)

(mp3 = st_multipoint(pts, "XYM"))
geojsonio::geojson_list(mp3)

pts = matrix(1:20, , 4)
(mp4 = st_multipoint(pts))
geojsonio::geojson_list(mp4)

pts = matrix(1:10, , 2)
(ls1 = st_linestring(pts))
geojsonio::geojson_list(ls1)

pts = matrix(1:15, , 3)
(ls2 = st_linestring(pts))
geojsonio::geojson_list(ls2)

(ls3 = st_linestring(pts, "XYM"))
pts = matrix(1:20, , 4)
geojsonio::geojson_list(ls3)

(ls4 = st_linestring(pts))
geojsonio::geojson_list(ls4)


outer = matrix(c(0,0,10,0,10,10,0,10,0,0),ncol=2, byrow=TRUE)
hole1 = matrix(c(1,1,1,2,2,2,2,1,1,1),ncol=2, byrow=TRUE)
hole2 = matrix(c(5,5,5,6,6,6,6,5,5,5),ncol=2, byrow=TRUE)
pts = list(outer, hole1, hole2)
(ml1 = st_multilinestring(pts))
geojsonio::geojson_list(ml1)

pts3 = lapply(pts, function(x) cbind(x, 0))
(ml2 = st_multilinestring(pts3))
geojsonio::geojson_list(ml2)

(ml3 = st_multilinestring(pts3, "XYM"))
geojsonio::geojson_list(ml3)

pts4 = lapply(pts3, function(x) cbind(x, 0))
(ml4 = st_multilinestring(pts4))
geojsonio::geojson_list(ml4)

outer = matrix(c(0,0,10,0,10,10,0,10,0,0),ncol=2, byrow=TRUE)
hole1 = matrix(c(1,1,1,2,2,2,2,1,1,1),ncol=2, byrow=TRUE)
hole2 = matrix(c(5,5,5,6,6,6,6,5,5,5),ncol=2, byrow=TRUE)
pts = list(outer, hole1, hole2)
(pl1 = st_polygon(pts))
geojsonio::geojson_list(pl1)

pts3 = lapply(pts, function(x) cbind(x, 0))
(pl2 = st_polygon(pts3))
geojsonio::geojson_list(pl2)

(pl3 = st_polygon(pts3, "XYM"))
geojsonio::geojson_list(pl3)

pts4 = lapply(pts3, function(x) cbind(x, 0))
(pl4 = st_polygon(pts4))
geojsonio::geojson_list(pl4)

pol1 = list(outer, hole1, hole2)
pol2 = list(outer + 12, hole1 + 12)
pol3 = list(outer + 24)
mp = list(pol1,pol2,pol3)
(mp1 = st_multipolygon(mp))
geojsonio::geojson_list(mp1)

pts3 = lapply(mp, function(x) lapply(x, function(y) cbind(y, 0)))
(mp2 = st_multipolygon(pts3))
geojsonio::geojson_list(mp2)

(mp3 = st_multipolygon(pts3, "XYM"))
geojsonio::geojson_list(mp3)

pts4 = lapply(mp2, function(x) lapply(x, function(y) cbind(y, 0)))
(mp4 = st_multipolygon(pts4))
geojsonio::geojson_list(mp4)

(gc = st_geometrycollection(list(p1, ls1, pl1, mp1)))
geojsonio::geojson_list(gc)
st_geometrycollection() # empty geometry
c(st_point(1:2), st_point(5:6)) %>%
  geojsonio::geojson_list(mp4)

c(st_point(1:2), st_multipoint(matrix(5:8,2))) %>%
  geojsonio::geojson_list()

c(st_multipoint(matrix(1:4,2)), st_multipoint(matrix(5:8,2))) %>%
  geojsonio::geojson_list()
c(st_linestring(matrix(1:6,3)), st_linestring(matrix(11:16,3))) %>%
  geojsonio::geojson_list()

c(st_multilinestring(list(matrix(1:6,3))), st_multilinestring(list(matrix(11:16,3)))) %>%
  geojsonio::geojson_list()

pl = list(rbind(c(0,0), c(1,0), c(1,1), c(0,1), c(0,0)))
c(st_polygon(pl), st_polygon(pl)) %>%
  geojsonio::geojson_list()
c(st_polygon(pl), st_multipolygon(list(pl))) %>%
  geojsonio::geojson_list()

c(st_linestring(matrix(1:6,3)), st_point(1:2)) %>%
  geojsonio::geojson_list()

c(st_geometrycollection(list(st_point(1:2), st_linestring(matrix(1:6,3)))),
  st_geometrycollection(list(st_multilinestring(list(matrix(11:16,3)))))) %>%
  geojsonio::geojson_list()

c(st_geometrycollection(list(st_point(1:2), st_linestring(matrix(1:6,3)))),
  st_multilinestring(list(matrix(11:16,3))), st_point(5:6), 
  st_geometrycollection(list(st_point(10:11)))) %>%
  geojsonio::geojson_list()

edzer · 2017-01-20T20:15:37Z

Here's a a first shot at it. It returns sfc with one feature, as these have a crs. Alternatively, one could return single simple feature geometries, without crs (which must be 4326 anyway).

library(sf)
# use newest geojsonio from Github
# devtools::install_github("ropensci/geojsonio")
library(geojsonio)
library(magrittr)
library(testthat)

st_as_sfc.geo_list = function(x, ...) {
	x = switch(x$type,
		Point = st_point(x$coordinates),
		MultiPoint = st_multipoint(x$coordinates),
		LineString = st_linestring(x$coordinates),
		MultiLineString = st_multilinestring(x$coordinates),
		Polygon = st_polygon(x$coordinates),
		MultiPolygon = st_multipolygon(x$coordinates),
		GeometryCollection = st_geometrycollection(
			lapply(x$geometries, function(y) st_as_sfc.geo_list(y)[[1]])),
		stop("unkown class")
	)
	st_sfc(x, crs = st_crs(4326))
}

# use sf examples
p1 = st_point(c(1,2))
expect_equal(st_as_sfc(geojsonio::geojson_list(p1))[[1]], p1)

(p2 = st_point(c(1,2,3)))
expect_equal(st_as_sfc(geojsonio::geojson_list(p2))[[1]], p2)

pts = matrix(1:10, , 2)
(mp1 = st_multipoint(pts))
expect_equal(st_as_sfc(geojsonio::geojson_list(mp1))[[1]], mp1)

pts = matrix(1:15, , 3)
(mp2 = st_multipoint(pts))
expect_equal(st_as_sfc(geojsonio::geojson_list(mp2))[[1]], mp2)

pts = matrix(1:10, , 2)
(ls1 = st_linestring(pts))
expect_equal(st_as_sfc(geojsonio::geojson_list(ls1))[[1]], ls1)

pts = matrix(1:15, , 3)
(ls2 = st_linestring(pts))
expect_equal(st_as_sfc(geojsonio::geojson_list(ls2))[[1]], ls2)

outer = matrix(c(0,0,10,0,10,10,0,10,0,0),ncol=2, byrow=TRUE)
hole1 = matrix(c(1,1,1,2,2,2,2,1,1,1),ncol=2, byrow=TRUE)
hole2 = matrix(c(5,5,5,6,6,6,6,5,5,5),ncol=2, byrow=TRUE)
pts = list(outer, hole1, hole2)
(ml1 = st_multilinestring(pts))
expect_equal(st_as_sfc(geojsonio::geojson_list(ml1))[[1]], ml1)

pts3 = lapply(pts, function(x) cbind(x, 0))
(ml2 = st_multilinestring(pts3))
expect_equal(st_as_sfc(geojsonio::geojson_list(ml2))[[1]], ml2)

outer = matrix(c(0,0,10,0,10,10,0,10,0,0),ncol=2, byrow=TRUE)
hole1 = matrix(c(1,1,1,2,2,2,2,1,1,1),ncol=2, byrow=TRUE)
hole2 = matrix(c(5,5,5,6,6,6,6,5,5,5),ncol=2, byrow=TRUE)
pts = list(outer, hole1, hole2)
(pl1 = st_polygon(pts))
geojsonio::geojson_list(pl1)
st_as_sfc(geojsonio::geojson_list(pl1))[[1]]
expect_equal(st_as_sfc(geojsonio::geojson_list(pl1))[[1]], pl1)

pts3 = lapply(pts, function(x) cbind(x, 0))
(pl2 = st_polygon(pts3))
expect_equal(st_as_sfc(geojsonio::geojson_list(pl2))[[1]], pl2)

pol1 = list(outer, hole1, hole2)
pol2 = list(outer + 12, hole1 + 12)
pol3 = list(outer + 24)
mp = list(pol1,pol2,pol3)
(mp1 = st_multipolygon(mp))
expect_equal(st_as_sfc(geojsonio::geojson_list(mp1))[[1]], mp1)

pts3 = lapply(mp, function(x) lapply(x, function(y) cbind(y, 0)))
(mp2 = st_multipolygon(pts3))
expect_equal(st_as_sfc(geojsonio::geojson_list(mp2))[[1]], mp2)

(gc = st_geometrycollection(list(p1, ls1, pl1, mp1)))
# x = geojsonio::geojson_list(gc)
# lapply(x$geometries, st_as_sfc.geo_list)
expect_equal(st_as_sfc(geojsonio::geojson_list(gc))[[1]], gc)

gc = st_geometrycollection() # empty geometry
expect_equal(st_as_sfc(geojsonio::geojson_list(gc))[[1]], gc)

gc = st_geometrycollection(list(st_point(1:2), st_multipoint(matrix(5:8,2))) )
expect_equal(st_as_sfc(geojsonio::geojson_list(gc))[[1]], gc)

gc = st_geometrycollection(
	list(st_multilinestring(list(matrix(1:6,3))), 
	st_multilinestring(list(matrix(11:16,3)))))
expect_equal(st_as_sfc(geojsonio::geojson_list(gc))[[1]], gc)

edzer · 2017-02-05T17:00:09Z

Did this work out, and should we add it to sf?

edzer · 2017-03-07T10:24:04Z

Did anyone look at this?

tim-salabim · 2017-03-07T12:03:00Z

@edzer I'll have a look at these soon.
@timelyportfolio did you check these? I think these would be crucial for mapedit.

timelyportfolio · 2017-03-07T22:41:19Z

I should be able to test tomorrow. Sorry for the delay. Yes, these will be very important for mapedit.

timelyportfolio · 2017-03-08T22:51:42Z

What about FEATURE and FEATURECOLLECTION? I'll try to work through some code to handle these.

In some geojson, I get coordinates as a list which causes the conversion to fail.

structure(list(type = "Point", coordinates = list(-78.0080795288, 
    39.9357821415, 0L)), .Names = c("type", "coordinates"), class = "geo_list")

Work through geojsonio tests in reverse https://github.com/ropensci/geojsonio/blob/master/tests/testthat/test-sf_classes.R

edzer · 2017-03-09T13:38:52Z

I guess a FEATURECOLLECTION would map into an sf object, where non-geometry properties go into the non-geometry columns, and a FEATURE is a single row (record) of such a table.

AFAICS, coordinates in geojson should be a vector or array. Who created this geo_list?

timelyportfolio · 2017-03-09T14:04:23Z

Thanks @edzer. By no means did I intend to imply that coordinates as a list are correct (I have no idea :)). I just discovered as I randomly pulled every geojson example I could find. Here is the code.

library(geojsonio)

file <- system.file("examples", "norway_maple.kml", package = "geojsonio")
nwy_map <- geojson_read(as.location(file), what = "list")
listviewer::jsonedit(nwy_map)

pt <- nwy_map$features[[1]]$geometry
class(pt) <- "geo_list"

# test geojson conversion functions
library(sf)
st_as_sfc.geo_list = function(x, ...) {
  x = switch(x$type,
             Point = st_point(x$coordinates),
             MultiPoint = st_multipoint(x$coordinates),
             LineString = st_linestring(x$coordinates),
             MultiLineString = st_multilinestring(x$coordinates),
             Polygon = st_polygon(x$coordinates),
             MultiPolygon = st_multipolygon(x$coordinates),
             GeometryCollection = st_geometrycollection(
               lapply(x$geometries, function(y) st_as_sfc.geo_list(y)[[1]])),
             stop("unkown class")
  )
  st_sfc(x, crs = st_crs(4326))
}

timelyportfolio · 2017-03-09T14:09:23Z

I think this geojsonio test offers a good basis for FEATURECOLLECTION.

p_list <- lapply(list(c(3.2,4), c(3,4.6), c(3.8,4.4)), st_point)
pt_sfc <- st_sfc(p_list)
pt_sf <- st_sf(x = c("a", "b", "c"), pt_sfc)

st_as_sfc(geojson_list(pt_sfc))
st_as_sfc(geojson_list(pt_sf))

edzer · 2017-03-09T14:09:25Z

Do the geojsonio folks somewhere specify how they want to represent GeoJSON in R?

timelyportfolio · 2017-03-09T14:10:18Z

pinging @sckott and @ateucher. In the geojson_list tests, I only see coordinates as a list in this line. For reference, jsonlite treats an unnamed list and a vector equivalently as an array in JavaScript if auto_unbox=TRUE.

> jsonlite::toJSON(list(1,2,3))
[[1],[2],[3]] 
> jsonlite::toJSON(list(1,2,3), auto_unbox=TRUE)
[1,2,3] 
> jsonlite::toJSON(c(1,2,3), auto_unbox=TRUE)
[1,2,3] 
> jsonlite::toJSON(c(1,2,3))
[1,2,3]

sckott · 2017-03-09T18:39:02Z

@timelyportfolio i think geojson as a list or string both make sense - i'd like to soon depend on our geojson pkg to have a unified geojson representation with simple s3 print methods, see https://github.com/ropensci/geojson - the workflow and print methods in geojson only handle strings right now - but may add methods that handle lists in geojson - then we'd have similar s3 print methods for geojson as lists and strings

ateucher · 2017-03-09T18:52:02Z

@sckott correct me if I'm wrong, but because jsonlite is so clever and flexible (can just as easily handle coordinates as lists or vectors/matrices or combos thereof), we've been pretty lax about enforcing a strict structure on the geo_list. Probably something we should remedy...

sckott · 2017-03-09T19:17:55Z

@ateucher right, we should specify a structure for that type - i thin kit would make most sense to include list support in geojson - and have checker fxns and docs there for proper format - then that can be used elsewhere

edzer · 2017-03-09T19:41:57Z

Since your geometries are a constrained subset of simple features, you could as well follow the sf pattern (if you don't already): point is a vector, linestring/multipoint is matrix (with each point a row), multilinestring/polygon are a list of matrices, multipolygon is a list of list of matrices, geometrycollection is a list of any of the previous.

ateucher · 2017-03-09T20:15:37Z

I think that's a great idea @edzer

timelyportfolio · 2017-03-10T04:23:09Z

This is some ugly code, but I'll post as a starting point to converting FEATURECOLLECTION and FEATURE.

# test geojson conversion functions
library(sf)
st_as_sfc.geo_list = function(x, ...) {
  x = switch(x$type,
             Point = st_point(x$coordinates),
             MultiPoint = st_multipoint(x$coordinates),
             LineString = st_linestring(x$coordinates),
             MultiLineString = st_multilinestring(x$coordinates),
             Polygon = st_polygon(x$coordinates),
             MultiPolygon = st_multipolygon(x$coordinates),
             GeometryCollection = st_geometrycollection(
               lapply(x$geometries, function(y) st_as_sfc.geo_list(y)[[1]])),
             stop("unkown class")
  )
  st_sfc(x, crs = st_crs(4326))
}

p_list <- lapply(list(c(3.2,4), c(3,4.6), c(3.8,4.4)), st_point)
pt_sfc <- st_sfc(p_list)
pt_sf <- st_sf(x = c("a", "b", "c"), pt_sfc)

# use geojsonio to convert sf to geojson
gj_pt_sf <- geojsonio::geojson_list(pt_sf)

# start by trying to convert a single geojson feature to s
feat <- gj_pt_sf$features[[1]]

# manually translate one geojson feature
st_sf(
  feat$properties,
  st_as_sfc.geo_list(feat$geometry)
)


# now try to convert all of the geojson features
feats <- lapply(
  gj_pt_sf$features,
  function(ft) {
    st_sf(
      ft$properties,
      st_as_sfc.geo_list(ft$geometry)
    )
  }
)

do.call(sf::rbind.sf, feats)

etiennebr · 2017-04-13T13:04:03Z

I'm not very familiar with json, but it seems that multiple R representations could be valid?

Example with OSM data:

response = httr::GET("https://nominatim.openstreetmap.org/search?format=json&limit=1&polygon_geojson=1&q=hawai")

js_h <- httr::content(response, "parsed")[[1]]
js_l <- jsonlite::fromJSON(httr::content(response, as="text"))

str(js_h$geojson, 2)
#> List of 2
#> $ type       : chr "MultiPolygon"
#> $ coordinates:List of 17
#> ..$ :List of 1
#> ..$ :List of 1
#> ...
str(js_l$geojson, 3)
#> 'data.frame':	1 obs. of  2 variables:
#>   $ type       : chr "MultiPolygon"
#> $ coordinates:List of 1
#> ..$ :List of 17
#> .. ..$ : num [1, 1:248, 1:2] -157 -157 -157 -157 -157 ...
#> .. ..$ : num [1, 1:235, 1:2] -157 -157 -157 -157 -157 ...
#> .. ..$ : num [1, 1:192, 1:2] -171 -171 -171 -171 -171 ...
#> .. ..$ : num [1, 1:156, 1:2] -166 -166 -166 -166 -166 ...
#> .. ..$ : num [1, 1:134, 1:2] -156 -156 -156 -156 -156 ...
#> ...

I couldn't get either to work right of the bat with st_as_sfc.geo_list. As I said, I'm not very familiar with json, so is there a preferred way to cast it to an R object? R Nominatim package prefers the second approach.

timelyportfolio · 2017-04-13T13:14:27Z

Looks like you found one I have not discovered yet. Here is my first attempt at converting coordinates from json to the sf-expected https://github.com/timelyportfolio/mapedit/blob/3cb976875799ba1312b04bddc5d0fa959e5b8ab5/R/edit_map_return_sf.R#L43-L68.

edzer · 2017-05-25T13:37:01Z

Any reason to keep this issue open?

timelyportfolio · 2017-05-25T16:55:48Z

@edzer even though I opened the issue, I am probably the least qualified to answer "open or close?" Whether easy geojson -> sf belongs here or somewhere else like geojsonio, I am not sure, but I do think that this is an incredibly valuable gap missing currently in sf. While geojsonio does sf -> geojson, nothing fills this geojson->sf gap currently. Since it is not technically difficult with a little testing and a lot of work has already been done, I'd love to know that somewhere it gets addressed. @sckott, @ateucher, @tim-salabim any additional thoughts?

One concern I do have is that sf assumes character is WKT, and often geojson is just text with no additional class clues, so this might be difficult to plug into S3.

edzer · 2017-05-25T18:30:48Z

st_read can read geojson from text files, does that help?

If geojson comes as a text string, why wouldn't it have a class?

for wkt, sf has an st_as_sfc.character method, but there is no st_as_sf.character - we could use that for geojson?

ateucher · 2017-05-25T18:57:01Z

st_read can actually read geojson from a character string, as can readOGR. I don't think it's documented anywhere but it works:

library(sf)
#> Linking to GEOS 3.6.1, GDAL 2.1.3, proj.4 4.9.3

geojson_txt <- "{\"type\":\"MultiPoint\",\"coordinates\":[[3.2,4],[3,4.6],[3.8,4.4],[3.5,3.8],[3.4,3.6],[3.9,4.5]]}"

st_read(geojson_txt)
#> Reading layer `OGRGeoJSON' from data source `{"type":"MultiPoint","coordinates":[[3.2,4],[3,4.6],[3.8,4.4],[3.5,3.8],[3.4,3.6],[3.9,4.5]]}' using driver `GeoJSON'
#> converted into: MULTIPOINT
#> Simple feature collection with 1 feature and 0 fields
#> geometry type:  MULTIPOINT
#> dimension:      XY
#> bbox:           xmin: 3 ymin: 3.6 xmax: 3.9 ymax: 4.6
#> epsg (SRID):    4326
#> proj4string:    +proj=longlat +datum=WGS84 +no_defs

edzer · 2017-05-25T19:47:31Z

Super cool, didn't know that!

For this case, it pays off to use read_sf instead, which won't print the data source:

> x = read_sf(geojson_txt)
> x
Simple feature collection with 1 feature and 0 fields
geometry type:  MULTIPOINT
dimension:      XY
bbox:           xmin: 3 ymin: 3.6 xmax: 3.9 ymax: 4.6
epsg (SRID):    4326
proj4string:    +proj=longlat +datum=WGS84 +no_defs
                        geometry
1 MULTIPOINT(3.2 4, 3 4.6, 3....

at @timelyportfolio : I guess the geojson -> sf is now sufficiently answered, and only in need of better documentation?

timelyportfolio · 2017-05-25T19:49:56Z

Guess so :) Thanks @ateucher for answering from Runconf! Now I need to see if I should do this instead of my hacked conversion in mapedit.

mikoontz · 2017-11-29T23:12:58Z

What if the geoJSON character string is a column in a data.frame? I can read a single cell using st_read() or read_sf() as described above, but ultimately I'm trying to turn this data.frame into a sf object by converting the character column of geoJSONs to an sfc, which should then let me convert the data.frame with st_as_sf()?

Can the mechanics of read_sf() that allow it to handle character string geoJSON be used in st_as_sfc()?

edzer · 2017-11-30T09:27:53Z

Yes; a reprex would be helpful here! I'd try to unlist it, with recursive = FALSE. Maybe twice.

mikoontz · 2017-11-30T23:56:04Z

Okay! We know that read_sf() and st_read() can parse a character representation of a geoJSON:

library(sf)
#> Linking to GEOS 3.6.2, GDAL 2.2.3, proj.4 4.9.3

geo <- "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68152563269095,36.43764870908927]}"

read_sf(geo)
#> Simple feature collection with 1 feature and 0 fields
#> geometry type:  POINT
#> dimension:      XY
#> bbox:           xmin: -118.6815 ymin: 36.43765 xmax: -118.6815 ymax: 36.43765
#> epsg (SRID):    4326
#> proj4string:    +proj=longlat +datum=WGS84 +no_defs
#>                         geometry
#> 1 POINT (-118.681525632691 36...

But if we have a data.frame with a column that is a character representation of a geoJSON...

geo <- c("{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68152563269095,36.43764870908927]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67408758213843,36.43366018922779]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67708346361097,36.44208638659282]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67886661944996,36.44110273135671]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68089232041565,36.44173155205561]}")

test <- data.frame(numbers = 1:5, letters = letters[1:5], geometry = geo)

test
#>   numbers letters
#> 1       1       a
#> 2       2       b
#> 3       3       c
#> 4       4       d
#> 5       5       e
#>                                                                                 geometry
#> 1 {"geodesic":true,"type":"Point","coordinates":[-118.68152563269095,36.43764870908927]}
#> 2 {"geodesic":true,"type":"Point","coordinates":[-118.67408758213843,36.43366018922779]}
#> 3 {"geodesic":true,"type":"Point","coordinates":[-118.67708346361097,36.44208638659282]}
#> 4 {"geodesic":true,"type":"Point","coordinates":[-118.67886661944996,36.44110273135671]}
#> 5 {"geodesic":true,"type":"Point","coordinates":[-118.68089232041565,36.44173155205561]}

...we might like to be able to turn that whole data.frame into a simple feature by making the character column the geometry column of the simple feature with st_as_sfc():

library(sf)
#> Linking to GEOS 3.6.2, GDAL 2.2.3, proj.4 4.9.3

geo <- c("{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68152563269095,36.43764870908927]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67408758213843,36.43366018922779]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67708346361097,36.44208638659282]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67886661944996,36.44110273135671]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68089232041565,36.44173155205561]}")

test <- data.frame(numbers = 1:5, letters = letters[1:5], geometry = geo)

test$geometry <- st_as_sfc(test$geometry)
#> OGR: Unsupported geometry type
#> Error in CPL_sfc_from_wkt(x): OGR error

test <- st_as_sf(test)
#> Error in st_sf(x, ..., agr = agr): no simple features geometry column present

edzer · 2017-12-01T09:34:57Z

Yeah, right now you have to do sth like

> do.call(rbind, lapply(as.character(test$geometry), read_sf))
Simple feature collection with 5 features and 0 fields
geometry type:  POINT
dimension:      XY
bbox:           xmin: -118.6815 ymin: 36.43366 xmax: -118.6741 ymax: 36.44209
epsg (SRID):    4326
proj4string:    +proj=longlat +datum=WGS84 +no_defs
                        geometry
1 POINT (-118.681525632691 36...
2 POINT (-118.674087582138 36...
3 POINT (-118.677083463611 36...
4 POINT (-118.67886661945 36....
5 POINT (-118.680892320416 36...

and it would be quite simple to modify the st_as_sfc method for character such that it not only takes WKT, but, with an option set, also GeoJSON.

edzer · 2017-12-01T10:59:31Z

We now have

> geo <- c("{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68152563269095,36.43764870908927]}",
+          "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67408758213843,36.43366018922779]}",
+          "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67708346361097,36.44208638659282]}",
+          "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67886661944996,36.44110273135671]}",
+          "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68089232041565,36.44173155205561]}")
> st_as_sfc(geo, GeoJSON=TRUE)
Geometry set for 5 features 
geometry type:  POINT
dimension:      XY
bbox:           xmin: -118.6815 ymin: 36.43366 xmax: -118.6741 ymax: 36.44209
epsg (SRID):    4326
proj4string:    +proj=longlat +datum=WGS84 +no_defs
POINT (-118.681525632691 36.4376487090893)
POINT (-118.674087582138 36.4336601892278)
POINT (-118.677083463611 36.4420863865928)
POINT (-118.67886661945 36.4411027313567)
POINT (-118.680892320416 36.4417315520556)

tim-salabim · 2017-12-01T16:42:49Z

FWIW, you can also use the wellknown package to achieve this.

library(sf)
library(wellknown)

geo <- c("{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68152563269095,36.43764870908927]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67408758213843,36.43366018922779]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67708346361097,36.44208638659282]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.67886661944996,36.44110273135671]}",
         "{\"geodesic\":true,\"type\":\"Point\",\"coordinates\":[-118.68089232041565,36.44173155205561]}")

wkt = sapply(geo, wellknown::geojson2wkt, USE.NAMES = FALSE)

test <- data.frame(numbers = 1:5, letters = letters[1:5], geometry = wkt)
st_as_sf(test, wkt = "geometry")

Simple feature collection with 5 features and 2 fields
geometry type:  POINT
dimension:      XY
bbox:           xmin: -118.6815 ymin: 36.43366 xmax: -118.6741 ymax: 36.44209
epsg (SRID):    NA
proj4string:    NA
  numbers letters                       geometry
1       1       a POINT (-118.681525632691 36...
2       2       b POINT (-118.674087582138 36...
3       3       c POINT (-118.677083463611 36...
4       4       d POINT (-118.67886661945 36....
5       5       e POINT (-118.680892320416 36...

Though it doesn't infer crs as @edzer 's new implementation.

edzer · 2017-12-01T16:48:54Z

"infer" is too much honour: the json doesn't contain it, but the GeoJSON rfc says it only can be 4326, GDAL adheres to that I suppose.

mikoontz · 2017-12-01T17:42:23Z

Thank you both! These are great and straightforward solutions.

denironyx · 2020-07-24T14:30:39Z

Hi @edzer , @timelyportfolio, and @tim-salabim.

I'm aware this issue has long been closed. I was wondering if I could get some assistance in converting this data to a spatial object.

https://gist.github.com/denironyx/9fa87a93c10ffa92608362ae770bd7bc

timelyportfolio · 2020-07-24T16:14:16Z

@denironyx looks like you are working on a very neat project. Here is one solution, but I am sure there are others.

 result$data$placesByName %>%
  # convert coordinates to a list of points
  mutate(geom.coordinates = lapply(geom.coordinates, function(x) list(list(matrix(x,ncol=2,byrow=FALSE))))) %>%
  mutate(geometry = mapply(
    function(type, points) {
      # don't know if this is a valid assumption
      #  but get st_* function based on type column
      get(paste0("st_",tolower(type)))(points)
    },
    geom.type,
    geom.coordinates,
    SIMPLIFY = FALSE
  )) %>%
  select(-contains("geom")) %>%
  mutate(geometry = geo$geometry) %>%
  st_sf(crs = "WGS84")

denironyx · 2020-07-25T05:14:09Z

Thanks @timelyportfolio for the assistance. It worked magic!

timelyportfolio mentioned this issue Mar 8, 2017

add class geojson_list to returned value ropensci-archive/randgeo#9

Closed

timelyportfolio mentioned this issue Apr 3, 2017

return sf from edit_map r-spatial/mapedit#18

Merged

tarakc02 mentioned this issue Apr 11, 2017

sf support tarakc02/rmapzen#8

Closed

edzer closed this as completed in 685da0b May 25, 2017

timelyportfolio mentioned this issue May 29, 2017

a list of use cases r-spatial/mapedit#19

Open

edzer added a commit that referenced this issue Dec 1, 2017

fixes #185 ; add a GeoJSON=TRUE option

a549342

SymbolixAU mentioned this issue Apr 2, 2018

MongoDB to sf r-spatial/discuss#19

Closed

florisvdh mentioned this issue Jan 31, 2020

A post and 2 tutorials on single-file open geospatial standards inbo/tutorials#150

Merged

easy conversion for GeoJSON as R list to sf #185

easy conversion for GeoJSON as R list to sf #185

Comments

timelyportfolio commented Jan 20, 2017 • edited

edzer commented Jan 20, 2017

timelyportfolio commented Jan 20, 2017

timelyportfolio commented Jan 20, 2017

edzer commented Jan 20, 2017

timelyportfolio commented Jan 20, 2017

edzer commented Jan 20, 2017

edzer commented Feb 5, 2017

edzer commented Mar 7, 2017

tim-salabim commented Mar 7, 2017

timelyportfolio commented Mar 7, 2017

timelyportfolio commented Mar 8, 2017 • edited

edzer commented Mar 9, 2017

timelyportfolio commented Mar 9, 2017

timelyportfolio commented Mar 9, 2017

edzer commented Mar 9, 2017

timelyportfolio commented Mar 9, 2017 • edited

sckott commented Mar 9, 2017

ateucher commented Mar 9, 2017

sckott commented Mar 9, 2017

edzer commented Mar 9, 2017

ateucher commented Mar 9, 2017

timelyportfolio commented Mar 10, 2017

etiennebr commented Apr 13, 2017

timelyportfolio commented Apr 13, 2017

edzer commented May 25, 2017

timelyportfolio commented May 25, 2017 • edited

edzer commented May 25, 2017

ateucher commented May 25, 2017

edzer commented May 25, 2017

timelyportfolio commented May 25, 2017

mikoontz commented Nov 29, 2017 • edited

edzer commented Nov 30, 2017

mikoontz commented Nov 30, 2017 • edited

edzer commented Dec 1, 2017

edzer commented Dec 1, 2017

tim-salabim commented Dec 1, 2017

edzer commented Dec 1, 2017

mikoontz commented Dec 1, 2017

denironyx commented Jul 24, 2020

timelyportfolio commented Jul 24, 2020 • edited

denironyx commented Jul 25, 2020

timelyportfolio commented Jan 20, 2017 •

edited

timelyportfolio commented Mar 8, 2017 •

edited

timelyportfolio commented Mar 9, 2017 •

edited

timelyportfolio commented May 25, 2017 •

edited

mikoontz commented Nov 29, 2017 •

edited

mikoontz commented Nov 30, 2017 •

edited

timelyportfolio commented Jul 24, 2020 •

edited