#include "geometries/geometries.hpp"SEXP make_geometries()When one thinks of geometries in R, one of the most common data structures is the matrix. For example, in the sf world, an POINT is a single-row matrix (i.e, a vector)
sf::st_point( 1:2 )
POINT (1 2)A LINESTRING is a matrix
sf::st_linestring( matrix( c(1,1,1,2,2,2,2,1,1,1), ncol = 2, byrow = T) )
LINESTRING (1 1, 1 2, 2 2, 2 1, 1 1)and a POLYGON is a list of matrices
sf::st_polygon( list( matrix( c(1,1,1,2,2,2,2,1,1,1), ncol = 2, byrow = T) ) )
POLYGON ((1 1, 1 2, 2 2, 2 1, 1 1))And to group these into a collection you would put each geometry inside a list
sf::st_sfc(
list(
sf::st_linestring( matrix( c(1,1,1,2,2,2,2,1,1,1), ncol = 2, byrow = T) )
, sf::st_polygon( list( matrix( c(1,1,1,2,2,2,2,1,1,1), ncol = 2, byrow = T) ) )
)
)
Geometry set for 2 features
geometry type: GEOMETRY
dimension: XY
bbox: xmin: 1 ymin: 1 xmax: 2 ymax: 2
CRS: NA
LINESTRING (1 1, 1 2, 2 2, 2 1, 1 1)
POLYGON ((1 1, 1 2, 2 2, 2 1, 1 1))From my limited research (i.e., practically none), I estimate most users will have a data.frame and will want to convert it into a collection of geometries.
For example, take a data.frame of x and y coordinates, and two id columns.
df <- data.frame(
id1 = c( rep(1,12), rep(2, 12) )
, id2 = c( rep(1:4, each = 3), rep(1:4, each = 3) )
, x = 1:24
, y = 24:1
)
df
# id1 id2 x y
# 1 1 1 1 24
# 2 1 1 2 23
# 3 1 1 3 22
# 4 1 2 4 21
# 5 1 2 5 20
# 6 1 2 6 19
# 7 1 3 7 18
# 8 1 3 8 17
# 9 1 3 9 16
# 10 1 4 10 15
# 11 1 4 11 14
# 12 1 4 12 13
# 13 2 1 13 12
# 14 2 1 14 11
# 15 2 1 15 10
# 16 2 2 16 9
# 17 2 2 17 8
# 18 2 2 18 7
# 19 2 3 19 6
# 20 2 3 20 5
# 21 2 3 21 4
# 22 2 4 22 3
# 23 2 4 23 2
# 24 2 4 24 1You can think of the ID columns in this example as
id1 defines a polygonid2 is each ring inside the polygonCalling geometries::make_geometries() will split this data.frame by these ID columns and put the resulting matrices inside list elements.
cppFunction(
depends = "geometries"
, includes = '#include "geometries/geometries.hpp"'
, code = '
SEXP my_shape( SEXP df, SEXP id_cols, SEXP geometry_cols ) {
return geometries::make_geometries( df, id_cols, geometry_cols );
}
'
, plugins = "cpp11"
)
my_shape( df, c(0L,1L), c(2L,3L) )
# [[1]]
# [[1]][[1]]
# [,1] [,2]
# [1,] 1 24
# [2,] 2 23
# [3,] 3 22
#
# [[1]][[2]]
# [,1] [,2]
# [1,] 4 21
# [2,] 5 20
# [3,] 6 19
#
# [[1]][[3]]
# [,1] [,2]
# [1,] 7 18
# [2,] 8 17
# [3,] 9 16
#
# [[1]][[4]]
# [,1] [,2]
# [1,] 10 15
# [2,] 11 14
# [3,] 12 13
#
#
# [[2]]
# [[2]][[1]]
# [,1] [,2]
# [1,] 13 12
# [2,] 14 11
# [3,] 15 10
#
# [[2]][[2]]
# [,1] [,2]
# [1,] 16 9
# [2,] 17 8
# [3,] 18 7
#
# [[2]][[3]]
# [,1] [,2]
# [1,] 19 6
# [2,] 20 5
# [3,] 21 4
#
# [[2]][[4]]
# [,1] [,2]
# [1,] 22 3
# [2,] 23 2
# [3,] 24 1Notice here there are no class attributes on the shapes. In {geometries} I only want to provide the tools to build these structures, then each user can define what they mean.
For example, if you want to define a class for each geometry you can supply a list containing a “class” vector as the 4th argument
cppFunction(
depends = "geometries"
, includes = '#include "geometries/geometries.hpp"'
, code = '
SEXP my_shape( Rcpp::DataFrame df, Rcpp::IntegerVector id_cols, Rcpp::IntegerVector geometry_cols, Rcpp::List class_attributes ) {
return geometries::make_geometries( df, id_cols, geometry_cols, class_attributes );
}
'
, plugins = "cpp11"
)
my_shape( df, c(0,1), c(2,3), list(class = "my_polygon") )
# [[1]]
# [[1]]
# [,1] [,2]
# [1,] 1 24
# [2,] 2 23
# [3,] 3 22
#
# [[2]]
# [,1] [,2]
# [1,] 4 21
# [2,] 5 20
# [3,] 6 19
#
# [[3]]
# [,1] [,2]
# [1,] 7 18
# [2,] 8 17
# [3,] 9 16
#
# [[4]]
# [,1] [,2]
# [1,] 10 15
# [2,] 11 14
# [3,] 12 13
#
# attr(,"class")
# [1] "my_polygon"
#
# [[2]]
# [[1]]
# [,1] [,2]
# [1,] 13 12
# [2,] 14 11
# [3,] 15 10
#
# [[2]]
# [,1] [,2]
# [1,] 16 9
# [2,] 17 8
# [3,] 18 7
#
# [[3]]
# [,1] [,2]
# [1,] 19 6
# [2,] 20 5
# [3,] 21 4
#
# [[4]]
# [,1] [,2]
# [1,] 22 3
# [2,] 23 2
# [3,] 24 1
#
# attr(,"class")
# [1] "my_polygon"Notice here that each list element now has a "my_polygon" class.
And if you have library(sf) loaded, setting the class as sfg POLYGON, you should see each element printed in the usual sf way
library(sf)
my_shape( df, c(0,1), c(2,3), list( class = c("XY", "POLYGON","sfg") ) )
# [[1]]
# POLYGON ((1 24, 2 23, 3 22), (4 21, 5 20, 6 19), (7 18, 8 17, 9 16), (10 15, 11 14, 12 13))
#
# [[2]]
# POLYGON ((13 12, 14 11, 15 10), (16 9, 17 8, 18 7), (19 6, 20 5, 21 4), (22 3, 23 2, 24 1))
You can use this function to define any shape you want. The number of id columns you supply will determine how deeply nested the matrices are. If I add two more id columns, this will nest each matrix 2-levels deeper
df$id0 <- 1
df$id00 <- 1
head( df )
my_shape( df, c(0,1,4,5), c(2,3), list(class = "my_new_shape") )
# [[1]]
# [[1]]
# [[1]][[1]]
# [[1]][[1]][[1]]
# [,1] [,2]
# [1,] 1 24
# [2,] 2 23
# [3,] 3 22
#
#
#
# [[2]]
# [[2]][[1]]
# [[2]][[1]][[1]]
# [,1] [,2]
# [1,] 4 21
# [2,] 5 20
# [3,] 6 19
#
#
#
# [[3]]
# [[3]][[1]]
# [[3]][[1]][[1]]
# [,1] [,2]
# [1,] 7 18
# [2,] 8 17
# [3,] 9 16
#
#
#
# [[4]]
# [[4]][[1]]
# [[4]][[1]][[1]]
# [,1] [,2]
# [1,] 10 15
# [2,] 11 14
# [3,] 12 13
#
#
#
# attr(,"class")
# [1] "my_new_shape"
#
# [[2]]
# [[1]]
# [[1]][[1]]
# [[1]][[1]][[1]]
# [,1] [,2]
# [1,] 13 12
# [2,] 14 11
# [3,] 15 10
#
#
#
# [[2]]
# [[2]][[1]]
# [[2]][[1]][[1]]
# [,1] [,2]
# [1,] 16 9
# [2,] 17 8
# [3,] 18 7
#
#
#
# [[3]]
# [[3]][[1]]
# [[3]][[1]][[1]]
# [,1] [,2]
# [1,] 19 6
# [2,] 20 5
# [3,] 21 4
#
#
#
# [[4]]
# [[4]][[1]]
# [[4]][[1]][[1]]
# [,1] [,2]
# [1,] 22 3
# [2,] 23 2
# [3,] 24 1
#
#
#
# attr(,"class")
# [1] "my_new_shape"