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

QGIS, a leading open-source Geographic Information System (GIS), provides an interesting suite of tools for geospatial analysis. Have you ever wondered about controlling QGIS with a Python script ? About calling a specific tool within QGIS from Python? This capability can be useful to integrate processing already available in QGIS within a script of your own without opening the QGIS software directly. In this blog post, we’ll explore how to call QGIS from a Python script in the Jupyter Notebook. Let’s dive in.

If you’re new to Python or Jupyter Notebook, check out our introductory guide to set up a Python environnement using Anaconda. In this tutorial, we assume that you are using the Anaconda distribution of Python. The first step is to open your Anaconda prompt windows and create a Conda environment that includes both QGIS and Jupyter Notebook. On Windows, click on the Start Menu and type “Anaconda Prompt” in the search bar and open it. Within the command prompt, run the line below:

Now, you can activate the newly created Conda environment using the following command, also in the Anaconda prompt windows. Once you activate the qgis_jupyter environment, you’ll have access to QGIS and Jupyter Notebook within the same environment, allowing you to use QGIS functionality directly from your Jupyter Notebooks. If you have an issue with the code above, it means that you need to install QGIS in your newly created environment. Thus, run this conda install -c conda-forge qgis line of code before proceeding further.

And finally, open a Jupiter Notebook within the environnement you just activated

Now that your notebook is open, you can run the code snippet below to set up the interaction with QGIS. Note that even if you don’t need to open the QGIS standalone, you need to have QGIS installed on your machine to interact with it. That’s why we need to specify in the code below the installation directory path of QGIS and initialize it. This ensures that the Python interpreter can locate the necessary QGIS libraries. Additionally, the script initializes the next processing algorithms that will be performed.

The layer contains the building footprints of Grosseto. Provided you put the GeoPackage in the folder where your notebook is located, you can already import and plot the layer, as shown below. For this example, we are working on a subset of 100 buildings.

Now, let’s execute a straightforward algorithm, such as « dissolve, » by invoking the QGIS tool directly within the notebook and visualize the outcome to verify its success. Ensure to specify the location of the Geopackage in the code, along with defining the input and output layers. Subsequently, call the algorithm using the native:dissolve identifier, and adjust its parameters as necessary. The result, named Dissolved_Subset_Grosseto is saved as a new layer in the GeoPackage and ploted in the notebook.

As you can see below the buildings have been perfectly dissolved using the native QGIS algorithm.

This code snippet below demonstrates a workflow in Python using the buffer QGIS algorithm. First, we reproject the input layer to a Cartesian Coordinate Reference System (CRS) suitable suitable for the buffer function. Subsequently, the script iterates through a series of distances, executing the buffer algorithm four times with varying distances (10, 20, 50, and 100 meters). Each buffer operation generates a new layer with the GeoPackage.

Let’s map the different buffers. The code below import the layers we just created with a loop, and plot them in reverse order in order to visualize the overlap using Matplotlib.

Feel free to engage with this post by commenting, asking questions, or providing feedback.