An R package providing access to the awesome mapshaper tool by Matthew Bloch, which has both a Node.js command-line tool as well as an interactive web tool.
I started this package so that I could use mapshaper's Visvalingam simplification method in R. There is, as far as I know, no other R package that performs topologically-aware multi-polygon simplification. (This means that shared boundaries between adjacent polygons are always kept intact, with no gaps or overlaps, even at high levels of simplification).
But mapshaper does much more than simplification, so I am working on wrapping most of the core functionality of mapshaper into R functions.
So far, rmapshaper
provides the following functions:
ms_simplify
- simplify polygons or linesms_clip
- clip an area out of a layer using a polygon layer or a bounding box. Works on polygons, lines, and pointsms_erase
- erase an area from a layer using a polygon layer or a bounding box. Works on polygons, lines, and pointsms_dissolve
- aggregate polygon features, optionally specifying a field to aggregate on. If no field is specified, will merge all polygons into one.ms_explode
- convert multipart shapes to single part. Works with polygons, lines, and points in geojson format, but currently only with polygons and lines in theSpatial
classes (notSpatialMultiPoints
andSpatialMultiPointsDataFrame
).ms_lines
- convert polygons to topological boundaries (lines)ms_innerlines
- convert polygons to shared inner boundaries (lines)ms_points
- create points from a polygon layerms_filter_fields
- Remove fields from the attributesms_filter_islands
- Remove small detached polygons
If you run into any bugs or have any feature requests, please file an issue
rmapshaper
is on CRAN. Install the current version with:
install.packages("rmapshaper")
You can install the development version from github with devtools
:
## install.packages("devtools")
library(devtools)
install_github("ropensci/geojsonio")
install_github("ateucher/rmapshaper")
rmapshaper works with geojson strings (character objects of class geo_json
) and list
geojson objects of class geo_list
. These classes are defined in the geojsonio
package. It also works with Spatial
classes from the sp
package.
We will use the states
dataset from the geojsonio
package and first turn it into a geo_json
object:
library(geojsonio)
#>
#> We recommend using rgdal v1.1-1 or greater, but we don't require it
#> rgdal::writeOGR in previous versions didn't write
#> multipolygon objects to geojson correctly.
#> See https://stat.ethz.ch/pipermail/r-sig-geo/2015-October/023609.html
#>
#> Attaching package: 'geojsonio'
#> The following object is masked from 'package:base':
#>
#> pretty
library(rmapshaper)
library(sp)
## First convert to json
states_json <- geojson_json(states, geometry = "polygon", group = "group")
#> Assuming 'long' and 'lat' are longitude and latitude, respectively
## For ease of illustration via plotting, we will convert to a `SpatialPolygonsDataFrame`:
states_sp <- geojson_sp(states_json)
## Plot the original
plot(states_sp)
## Now simplify using default parameters, then plot the simplified states
states_simp <- ms_simplify(states_sp)
plot(states_simp)
You can see that even at very high levels of simplification, the mapshaper simplification algorithm preserves the topology, including shared boudaries:
states_very_simp <- ms_simplify(states_sp, keep = 0.001)
plot(states_very_simp)
Compare this to the output using rgeos::gSimplify
, where overlaps and gaps are evident:
library(rgeos)
#> rgeos version: 0.3-19, (SVN revision 524)
#> GEOS runtime version: 3.5.0-CAPI-1.9.0 r4084
#> Linking to sp version: 1.2-3
#> Polygon checking: TRUE
states_gsimp <- gSimplify(states_sp, tol = 1, topologyPreserve = TRUE)
plot(states_gsimp)
All of the functions are quite fast with geo_json
character objects and geo_list
list objects. They are slower with the Spatial
classes due to internal conversion to/from json. If you are going to do multiple operations on large Spatial
objects, it's recommended to first convert to json using geojson_list
or geojson_json
from the geojsonio
package. All of the functions have the input object as the first argument, and return the same class of object as the input. As such, they can be chained together. For a totally contrived example, using states_sp
as created above:
library(geojsonio)
library(rmapshaper)
library(sp)
library(magrittr)
## First convert 'states' dataframe from geojsonio pkg to json
states_json <- geojson_json(states, lat = "lat", lon = "long", group = "group",
geometry = "polygon")
states_json %>%
ms_erase(bbox = c(-107, 36, -101, 42)) %>% # Cut a big hole in the middle
ms_dissolve() %>% # Dissolve state borders
ms_simplify(keep_shapes = TRUE, explode = TRUE) %>% # Simplify polygon
geojson_sp() %>% # Convert to SpatialPolygonsDataFrame
plot(col = "blue") # plot
This package uses the V8 package to provide an environment in which to run mapshaper's javascript code in R. It relies heavily on all of the great spatial packages that already exist (especially sp
and rgdal
), the geojsonio
package for converting between geo_list, geo_json, and sp
objects, and the jsonlite
package for converting between json strings and R objects.
Thanks to timelyportfolio for helping me wrangle the javascript to the point where it works in V8. He also wrote the mapshaper htmlwidget, which provides access to the mapshaper web inteface, right in your R session. We have plans to combine the two in the future.
Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.
MIT