GeoPackage (GPKG) is an open and non-proprietary data format that allows different layers, both spatial and non-spatial, to be stored within the same file.
These layers can include:

• Spatial Layers with vector data such as points, lines, and polygons representing geographic features; Raster Data with gridded data representing continuous phenomena like elevation, land cover, or satellite imagery.
• Non-Spatial Layers such as tabular data: Attribute tables associated with spatial features, containing information such as attribute values, metadata, or statistical data or metadata: Descriptive information about the dataset, including authorship, data sources, coordinate reference systems, and data quality indicators.

GeoPackage’s ability to accommodate various types of spatial and non-spatial data in a single file makes it a versatile and efficient format for storing geospatial information. In this blog post, we are going to read and save geopackage’s layers using python and R.

Let’s download a simple Geopackage file. The following file comprises a GeoPackage file containing two building layers corresponding to two small cities in Italy: Grosseto and Sinalunga. First, you have to put the geopackage into your working directory. Then, you can run the code below to import the Grosseto layer and print the first rows of the dataset.

#Load the sf library
library(sf)

# Read the Grosseto layer of buildings
Grosseto = st_read("Italian_cities.gpkg", layer = "Grosseto")

# Print the first rows
head(Grosseto)

 

Let’s create another layer by doing a simple buffer over the buildings of Grosseto. The st_buffer function from the sf package allows doing buffer quickly. In addition, the code belows perform a buffer of 10 meters around the buildings of Grosseto. Then, the newly created layer is saved as an additional layer into the original geopackage using the st_write function.

# Perform a buffer of 10 meters
Grosseto_10B <- st_buffer(Grosseto, 10)

# Save the newly created layer
st_write(Grosseto_10B, "Italian_cities.gpkg", layer = "Grosseto_10B")

 

If you are new to Python, you can refer to this post to set up your Python environment with Anaconda and the Jupyter Notebook for spatial analysis. We will work with the same Geopackage file than for the R application. First, place the Geopackage in the same directory as your notebook. You can now run the code below to import a layer in Python using the GeoPandas library. In this example, we are importing a layer of building related to the italian city of Grosseto. In order to check that the layer has been imported, you can print the first rows using the .head function.

import geopandas as gpd
Grosseto = gpd.read_file("Italian_cities.gpkg", layer = "Grosseto")
Grosseto.head()

You can use the ‘to_file‘ method provided by GeoPandas to save a new layer in the GeoPackage. For example, the code below reproject the geometries in a projected CRS, perform a buffer of 10 meters and save a new layer named « buffered_Grosseto » in the GeoPackage « Italian_cities ».

# Re-project geometries to a projected CRS
Grosseto = Grosseto.to_crs(epsg=6875)

# Create a buffer of 10 meters around the geometries
buffered_Grosseto = Grosseto.buffer(10)

# Save the buffered layer to the GeoPackage file
buffered_Grosseto.to_file("Italian_cities.gpkg", driver="GPKG", layer="buffered_Grosseto")

I hope you enjoyed this short tutorial about how to work with the geopackage format in Python and R. Don’t hesitate to comment and provide feedbacks by engaging with this post.

R is an open-source statistical programming language used in statistical analysis but also in spatial analysis, artificial intelligence (AI), and machine learning (ML) applications. When coupled with RStudio, an integrated development environment (IDE) for R, it becomes user-friendly with an interactive interface. In this guide, we will walk you through the initial steps of setting up R and RStudio along with installing essential packages and testing them with spatial data.

Before diving into data mining, you need to set up the programming environment. Start by downloading and installing R from the Comprehensive R Archive Network (CRAN) website (https://cran.r-project.org/). Choose the appropriate version for your operating system and follow the installation instructions. Once R is installed, proceed to install RStudio, which provides a user-friendly interface for R programming. You can download RStudio from the official website (https://www.rstudio.com/products/rstudio/download/) and install it on your system.

The interface is divided into four parts, each fulfilling a specific role in the workflow. The Source section houses scripts, while the Console executes code and displays feedback. In Environments, users can review imported data and created objects. Finally, the Output section presents graphs, maps, and other outputs. This output section also facilitates file browsing and access to the help sections of the packages.

R’s functionality can be extended through packages, which are collections of R functions, data, and compiled code. One such essential package for spatial analysis is sf, which provides simple features (sf) for handling and analyzing spatial data. To install the sf package, open RStudio and execute the following command in the console:

install.packages("sf")

 

Once the sf package is installed, load it into your R session using the library() function:

library(sf)

Now, you have access to a wide range of spatial functions and data structures provided by the sf package, allowing you to manipulate and analyze spatial data efficiently.

Reading a csv file in R is straightforward using the read.csv function. Within this function, you can set a custom delimiter using the sep argument, and point at the presence of a header (first line as column titles). Don’t forget to put your file in your working directory. Alternatively, you can provide the full path to your file if your csv file is not located in your working directory. This website provides samples of csv file to download.

# Example 1: File in the working directory
read_csv = read.csv('file.csv', sep=',', header=FALSE)

# Example 2 : path to file
read_csv = read.csv('/Users/admin/file.csv', sep=',', header=FALSE)

To test the functionality of the sf package, let’s import a GeoPackage (GPKG) layer containing spatial data and visualize it on a map. You can download sample GPKG data from various sources such as governmental GIS portals or open data repositories. Assuming you have a GPKG file named example_data.gpkg, use the st_read() function from the sf package to read the spatial data into R. If you want to know more about the GeoPackage format, and try with a real Geopackage file, you can have a look at this post.

data <- st_read("path/to/example_data.gpkg")

Replace "path/to/example_data.gpkg" with the actual path to your GPKG file. If your geopackage file contains more than one layer, you can choose which layer to import using the layer = "layer_name" argument. Once the data is imported, you can create a simple map to visualize it using the plot() function

plot(data)

This will generate a basic plot displaying the spatial features contained in the GPKG layer.
R combined with RStudio provides a powerful environment for spatial analysis, AI, and ML tasks. By following the steps outlined in this guide, you’ve prepared a perfect environment for exploring more advanced techniques. Stay tuned for more tutorials and insights on leveraging R for spatial analysis. Happy coding