3.86 out of 5
3.86
86 reviews on Udemy

Learning Path: PyQGIS: Conquer the Geospatial World

Work your way through QGIS using the most popular scripting language - Python
Instructor:
Packt Publishing
837 students enrolled
English [Auto-generated]
Explore the different ways to interact with QGIS with Python
Implement a complete turnkey mapping application called ForestTrails
Use Python and QGIS to produce captivating GIS visualizations and build complex map layouts
Generate PDF map books automatically

You can be an excellent sculptor, but without the right tools, you would find it difficult to work. Similarly, even if you are very good at programming, building GIS application is a completely different ball game! The best tool you can go for while building GIS applications is QGIS. QGIS is a standalone geographical information system. It simplifies the process of building complex geospatial applications. It comprises of the tools that reduce the time and effort you spend on a typical application. If you are looking to create complex geospatial applications within a short span of time, then this Learning Path is the way to go.
Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.
The main goal of this Learning Path is to make mold you into an expert GIS application developer.
In PyQGIS: Conquer the Geospatial World with QGIS, you will learn how to use the QGIS system with a specific focus on the PyQGIS library.
Before we begin learning, let’s draw attention towards the “roadmap of the course”.
It begins with understanding the QGIS system, the Python console, and the PyQGIS library. We then move on to learning how to create QGIS plugins and use them in external applications. We then dig deeper into QGIS Python API, concentrating on how this library can be used to display information on a map. We then look at how external applications that use the PyQGIS library can let the user select and edit geospatial features. We go on to use the knowledge we have gained to implement a sophisticated turnkey mapping system.
Then, we will look to create, edit, and optimize a vector layer for faster queries, reproject a vector layer, reduce the number of vertices in a vector layer without losing critical data, and convert a raster to a vector. Following this, you will work through recipes that will help you compose static maps, create heavily customized maps, and add specialized labels and annotations. As well as this, we’ll also share a few tips and tricks based on different aspects of QGIS.
By the end of this Learning Path, you will have mastery over the QGIS tool and will find yourself capable of building complex applications with ease.

Introduction to QGIS Python Programming

1
The Course Overview
This video provides an overview of the entire course.
2
Installing QGIS and Python
Prepare your system to develop applications using Python and QGIS.
3
Introduction to QGIS
Because you don't need to have prior knowledge of QGIS to complete this course, in this video, we introduce the QGIS system itself.
4
Using Python with QGIS
This video is an introduction to the three ways in which Python can be used with QGIS.
5
Using the Python Console as a Window into the QGIS Environment

Using the QGIS Python Console, learn more about the QGIS programming environment.

6
Examining a Python Plugin

See how QGIS Python plugins work to extend the functionality of the QGIS system.

7
Using the QGIS Python API within an External Application
Learn how to write a standalone Python program that uses the QGIS Python APIs.
8
Using the Console
Learn how to use the QGIS Python Console to explore the QGIS environment and to write and run Python scripts.
9
Working with Geospatial Data in the Console
Learn how to write a Python program that reads and analyses geospatial data using the QGIS console.
10
Scripting the QGIS User Interface

Learn how to write Python programs that interact with the user using various QGIS user interface elements.

11
Discovering the QGIS Python API
Before you can work with the QGIS Python API, you have to understand how the API was developed, how it is organized, and how to learn more about it.
12
Important Core Classes
The qgis.core package contains fundamental classes that are used throughout the QGIS system. You will need to become familiar with these to use the PyQGIS API.
13
Important GUI Classes
The qgis.gui package defines a number of user interface widgets that you will want to include in your programs.
14
Analyzing Raster Data

Learn how to analyze the contents of a raster file containing elevation data.

15
Manipulating and Saving Vector Data

Learn how to read, write, and manipulate vector-format geospatial data.

16
Using Different Symbols for Different Features
Using Different Symbols for Different Features
17
Calculating the Distance between Two Points
Learn how to create a map tool that lets the user identify two points within a map and displays the real-world distance between those two points.
18
Creating a Simple Plugin
Learn how to create your own QGIS plugin from scratch.
19
The Plugin Development Process

Learn how to effectively develop plugins for QGIS.

20
Distributing Plugins

Learn how to prepare your plugin so that it can be shared with other people.

21
Writing a Useful Plugin
Learn how to create a more useful QGIS plugin that displays information about a clicked-on geometry.
22
Possibilities and Limitations of Plugins
Understand what can and can't be done with QGIS plugins.
23
Designing a Turnkey Mapping Application
Design, prepare, and implement the Lex (Landmark Explorer) application.
24
Creating the Lex Application
Start to implement the Lex system by defining the structure for the application and creating the overall user-interface
25
Drawing the Map

Add a map view to a standalone PyQGIS-based mapping application.

26
Implementing Panning and Zooming
Add features to the Lex application to allow the user to pan and zoom the map.
27
Implementing "Explore" Mode

Add a mode where the user can click on a landmark to display information about that landmark.

28
Possibilities and Limitations of External Applications
Learn what can and can't be done with external applications using PyQGIS.

QGIS Python Programming Techniques

1
The Course Overview
This video provides an overview of the entire course.
2
Installation and Setup
Prepare your system to work through the examples in this course
3
Working with Symbol Layers
Learn to combine multiple "symbol layers" to create sophisticated types of symbols.
4
Implementing Symbol Layers in Python

Learn how to create a system layer that draws features in a way not supported by the built-in QGIS symbol layer classes.

5
Implementing Renderers in Python

Learn how to create your own custom renderer classes using Python.

6
Working with Custom Map Layers
Learning how to create your own custom map layers to draw information can't easily be represented as a vector or raster map layer.
7
Creating Custom Map Canvas Items
Learn how to create your own map canvas items that draw directly onto the map canvas.
8
Using Memory-Based Layers
Learn how to work with memory-based map layers to produce effects not easily achieved using traditional vector layers.
9
Working with Selections
Learn how to let the user select vector features within your PyQGIS-based programs, and identify the selected feature(s) so you can work with them.
10
Layer Editing Mode

Learn how Layer Editing Mode works and how to use it within your own PyQGIS-based programs.

11
Adding and Editing Points
Learn how to create map tools that let the user add and edit Point geometries.
12
Deleting Points and other Geospatial Features
Add functionality to a PyQGIS-based application that lets the user delete a feature by clicking on it.
13
Adding Lines and Polygons

Learn how to let the user create new LineStringand Polygon features by drawing them onto the map canvas.

14
Editing Lines and Polygons
Learn how to let the user edit a LineString or Polygon geometry by clicking and dragging.
15
Introducing the ForestTrails Application

In this video, we will understand what it does and how it will work.

16
Designing the ForestTrails Application
In this video, we will design the application in more detail.
17
Laying Out the Application

Start implementing the ForestTrails system.

18
Defining the User Interface
The application's user interface needs to be defined in a separate Python class. In this video, we will implement that UI class.
19
Implementing the Main Program

This video continues to implement the ForestTrails system by fleshing out core Python sources files which make up the main program.

20
Testing the Application

Check that all the code we have written so far is working properly, and investigate the application's user interface.

21
Obtaining the Basemap
In this video, we obtain and prepare the basemap for use within the application.
22
Defining the Map Layers
In this video, we need to show the basemap and vector-format data in the map canvas. And we need to setup the underlying database and then define the map layers and their associated renderers.
23
The 'Pan' Map Tool
In this video, the user needs to be able to move the map around by clicking and dragging while in the "Pan" mode.
24
Implementing the Track Editing Mode

In this video, we will integrate the layer editing mode into our application so the user can turn on and off the editing mode and is reminded to save their changes when they quit the program.

25
The 'Add Track' Map Tool
In this video, because all the track data in the ForestTrails system is created by the end user, we need a tool to let the user create a new track.
26
Testing and Improving the Application
In this video, we will solve program’s very subtle problem which needs to be fixed.
27
The 'Edit Track' Map Tool
In this video, we will edit existing tracks.
28
The 'Delete Track' Map Tool

This section helps to round out the track-editing capabilities of the ForestTrails system; we need the ability to delete tracks.

29
The Get Info Map Tool
In this video, we help to get some way of allowing the user to enter the metadata about a track, including its name, type, and status.
30
The Set Start Point and Set End Point Actions
In this video, before we can implement the Find Shortest Path feature, we need to let the user set the desired starting and ending points.
31
The Find Shortest Path Action
In this video, we will see the ability to find the shortest path between two designated points.
32
Finishing Off and Testing
No program is ever complete. There are some annoying UI quirks we need to fix before reviewing what we have done and looking at ways to make our program even better.

Automated Data Processing with PyQGIS

1
The Course Overview
This video gives an overview of the entire course.
2
Installing QGIS 2.18 for Development
QGIS needs to be installed properly for working on it. This video will help you do that.
3
Using the QGIS Python Console for Interactive Control
The Python console is an interactive platform used for automation.
4
Automatically Starting the Python Console

In order to have the Python console always available, we will go through this video.

5
Using the Python's Script Runner Plugin
The QGIS Python Script Runner plugin provides a middle ground for QGIS automation between the interactive console and the overhead of plugins.
6
Setting Up Your QGIS IDE
QGIS IDE has advanced debugging tools and is very useful.
7
Debugging QGIS Python Scripts
Debugging programs that have processes in the foreground and background can be extremely difficult. This interactive debugging approach of QGIS makes the development of complex applications efficient.
8
Navigating the PyQGIS API
PyQGIS allows you to control virtually every aspect of QGIS. This video helps you to do that.
9
Creating a Traditional QGIS Plugin
Plugins are the best way to extend QGIS, as they can be easily updated and reused by other people. We will create a plugin in this video.
10
Creating a Processing Toolbox Plugin
The QGIS Processing Toolbox provides a powerful set of algorithms for QGIS Python Programming. Creating a plugin will help in easing the process.
11
Storing and Reading Global and Project Preferences
PyQGIS allows you to store application-level preferences and retrieve them. QGIS also has project-level preferences, which can override the application-level preferences in some cases. We will learn how to work with them in this video.
12
Accessing the Script Path from Within Your Script
Sometimes, you need to know exactly where the current working directory is so that you can access external resources. Accessing the script will enable that.
13
Loading a Vector Layer from a File Sample
Vector data stored in a local file is one of the most common geospatial data formats. We need to learn how to load the vector sample from a file.
14
Loading a Vector Layer from a Geodatabase
The geodatabase provides powerful geospatial data management and operations. Hence it is important to learn about how to load a layer from a geodatabase.
15
Examining Vector Layer Features and Attributes
Once a vector layer is loaded, you may want to investigate the data. A true GIS layer contains both spatial geometry and non-spatial attributes. So we are going to examine vector layer attributes and features in this video.
16
Filtering a Layer by Geometry

In this video, we'll perform a spatial operation to select the subset of a point layer based on the points contained in an overlapping polygon layer.

17
Filtering a Layer by Attributes
In addition to the spatial queries outlined previously, we can also subset a layer by its attributes. You will do that in this video.
18
Buffering a Feature
Buffering a feature creates a polygon around a feature as a selection geometry or just a simple visualization.
19
Measuring the Distance between Two Points and Along a Line
In the QgsDistanceArea object, PyQGIS has excellent capabilities for measuring the distance. We'll use this object measuring the distance between two points and along a line with multiple vertices.
20
Calculating the Area of a Polygon

Area calculation can be an end in itself to measure the size of a plot of land or a building. It can also be the input to other calculations such as land use maps. This video measures the area of a polygon.

21
Creating a Spatial Index

A spatial index optimizes a layer for spatial queries by creating additional simpler geometries that can be used to narrow down the field of possibilities within the complex geometry. So let’s use that instead of geometry.

22
Calculating the Bearing of a Line
Sometimes, you need to know the compass bearing of a line to create specialized symbology or to use as input in a spatial calculation. In this video, we'll calculate the bearing of the end points of a line.
23
Loading Data from a Spreadsheet
Spreadsheets are one of the most common methods used to collect and store simple geographic data. So, it is very important to know how to load data from a spreadsheet.
24
Accessing Layer Metadata
Metadata is an important tool for GIS analysts to understand a dataset. In this video, you'll extract the layer capabilities from a layer.
25
Creating a Vector Layer in Memory
Sometimes you need to create a temporary dataset for a quick output, or as an intermediate step in a more complex operation without the overhead of actually writing a file to disk. You will learn just that in this video.
26
Adding a Point Feature to a Vector Layer
The simplest editing that can be done to a vector is adding a point feature. You will learn that in this video.
27
Adding a Line Feature to a Vector Layer

Previously we added a point feature to a vector layer. Taking this a step further, adding a line feature is adding more points.

28
Adding a Polygon Feature, Field, and Other Attributes to a Vector Layer
A polygon is the most complex kind of geometry; however, in QGIS the API is very similar to a line. When you add a new attribute, the attribute value for all existing features are set to NULL for that field index. We will add polygon, field and other attributes.
29
Joining a shapefile Attribute Table to a CSV File

Joining attribute tables to other database tables allows you to use a spatial data set to reference a dataset without any geometry, using a common key between the data tables. Hence we will learn to do that in this video.

30
Changing the Vector Layer Geometry and Feature’s Attribute
To change the location and attribute of a feature PyQGIS provides a simple way. Learning that is important
31
Removing Data from a Vector Layer, Deleting, and Re-projecting a Vector Layer
In this video we will remove features, attributes with features and reproject a vector layer using the Processign toolbox.
32
Converting a Shapefile to KML or GeoJSON
Files in the KML or GeoJSON format are better to work with than shapefiles. Therefore, it is a good practice to convert them to these file formats.
33
Merging and Splitting Shapefiles
Merging datafiles with similar attributes and features leads to efficient use of memory. Alao sometimes it is necessary to split large datasets for ease of operation. Thus we will learn merging and splitting in this video.
34
Generalizing a Vector Layer
Generalization removes points from vector layer and reduces space.
35
Dissolving Vector Features
Dissolving helps in creating a single layer with common attributes.
36
Performing a Union on Vector Shapes
A union combines two overlapping vector shapes into one.
37
Rasterizing a Vector Layer
A raster dataset is sometimes more efficient way of displaying data in the backdrop.
You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
3.9
3.9 out of 5
86 Ratings

Detailed Rating

Stars 5
34
Stars 4
28
Stars 3
16
Stars 2
5
Stars 1
3
e96b2767e342a028e95f12e2ad69b63d
30-Day Money-Back Guarantee

Includes

13 hours on-demand video
Full lifetime access
Access on mobile and TV
Certificate of Completion