Fr

ee

Python Geospatial Analysis Cookbook

This book begins by tackling the installation of the necessary software dependencies and libraries needed
to perform spatial analysis with Python. From there, the next logical step is to prepare our data for analysis;
we will do this by building our toolbox to deal with data preparation, transformations, and projections. When
our data is ready for analysis, we will tackle problems such as indoor routing and diverse overlay analysis
methods. To validate our results, we will explore how topology checks can ensure top-quality results.

What this book will do

for you...
Discover the projection and coordinate
system information of your data and learn how
to transform that data into different projections
Import or export your data into different data
formats to prepare it for your application or
spatial analysis
Use PostGIS with Python to take advantage
of powerful analysis functions
Execute spatial analysis functions on
vector data, including clipping, spatial joins,
measuring distances and areas, and combining data to produce new results

Inside the Cookbook...

A straightforward and easy-to-follow format

A selection of the most important tasks

and problems

Create your own set of topology rules to

perform and ensure quality assurance rules
in Python

Carefully organized instructions to solve

problems efficiently

Find the shortest indoor path with network

analysis functions in easy, extensible recipes
revolving around all kinds of network
analysis problems

Solutions that can be applied to solve

real-world problems

Clear explanations of what you did

community experience distilled

Prices do not include

local sales tax or VAT
where applicable

P U B L I S H I N G

Visit www.PacktPub.com for books, eBooks,

code, downloads, and PacktLib.

Michael Diener

$ 49.99 US
31.99 UK

P U B L I S H I N G

Python Geospatial Analysis Cookbook

Geospatial development links your data to places on the Earth's surface. Its analysis is used in almost every
industry to answer location questions.

Sa

pl
e

Quick answers to common problems

Python Geospatial
Analysis Cookbook
60 recipes to work with topology, overlays, indoor routing, and
web application analysis with Python

Michael Diener

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 1 'Setting Up Your Geospatial
Python Environment'
A synopsis of the books content
More information on Python Geospatial Analysis Cookbook

About the Author

Michael Diener graduated from Simon Fraser University, British Columbia, Canada,
in 2001 with a bachelor of science degree in geography. He began working in 1995 with
Environment Canada as a GIS (Geographic Information Systems) analyst and has continued to
work with GIS technologies ever since.
In 2008, he founded a company called GOMOGI that is focused on building web and mobile
GIS application with open source tools. In 2011, the focus changed to indoor wayfinding and
navigation solutions and building the indrz platform that Michael had envisioned.
From time to time, Michael also holds seminars for organizations wanting to explore or
discover the possibilities of how GIS can increase productivity and help better answer spatial
questions. He is also the creative head of new product development in his company. His
technical skills include working with Python to solve a wide range of spatial problems on
a daily basis. Through the years, he has developed many spatial applications with Python,
including indrz and golfgis, which are two of the products built by his company, GOMOGI.
He is also lecturer of GIS at the Alpen Adria University, Klagenfurt, where he enjoys teaching
students the wonderful powers of GIS and explaining how to solve spatial problems with open
source GIS and Python.

Preface
Geospatial analysis is not special; it is just different when compared to other types of analysis
such as financial market analysis. We work with geometry objects, such as lines, points, and
polygons, and connect these geometries to attributes such as business data. We ask "where"
question, such as "Where is the nearest pub?", "Where are all my customers located?", and
"Where is my competition located?". The other location questions include, "Will this new
building cast a shadow over the park?", "What is the shortest way to school?", "What is the
safest way to school for my kids?", "Will this building block my view of the mountains?", and
"Where is the optimal place to build my next store?". Identify the areas that fire trucks can
reach from their station in 5 min, 10 min, or 20 min, and so on.
One thing all these questions have in common is the fact that you need to know where certain
objects are located in order to answer them. Without the spatial component, you cannot
answer such questions and this is what geospatial analysis is all about.
Geospatial features are laid over each other and patterns or trends are easily identified. This
ability to see a pattern or trend is geospatial analysis in its simplest form.
Throughout this book, simple and complex code recipes are provided as small working models
that can easily be integrated or expanded into a larger project or model.
Analysis is the fun part of GIS, and involves visualizing relationships, identifying trends, and
seeing patterns that are not visible in a spreadsheet.
The Python programming language is clean, clear, and concise, making it great for beginners.
It also has advanced powers for professionals to help them quickly code solutions to complex
problems. Python makes visualization quick and easy for experts or beginners who work with
geospatial data. It's that simple.

Preface

What this book covers

Chapter 1, Setting Up Your Geospatial Python Environment, explores setting up your computer
to handle all software requirements in one go, such as pyproj, NumPy, and Shapely. All your
development software needs to enable spatial analysis or geoprocessing on Windows and
Linux are met in this chapter.
Chapter 2, Working with Projections, explains how to deal with spatial data that's projected or
unprojected. You can learn and discover how to transform your data into a correct projection
to prepare for an analysis.
Chapter 3, Moving Spatial Data from One Format to Another, explains how geospatial data
comes in many different formats and also how messaging data from one format to another is a
daily chore. In this chapter, you will find out about the most common data management tasks.
Chapter 4, Working with PostGIS, shows you how most of our geospatial data is stored in
a spatial database and using, accessing, manipulating this data with Python is what this
chapter is about.
Chapter 5, Vector Analysis, introduces a very common geospatial data format, that is, the
vector data format. To execute analysis functions on vector data, we will explore patterns used
to create new data by snapping, clipping, cutting, and overlaying vector datasets followed by
determining the 3D ground distance and total elevation gain.
Chapter 6, Overlay Analysis, explains how to combine spatial data to create new data by using
the process of overlaying two sets of data over each other.
Chapter 7, Raster Analysis, shows you how to create an elevation profile and quick ways to
merge images to perform raster analysis functions on your data.
Chapter 8, Network Routing Analysis, shows you how finding the nearest anything is a common
geospatial analysis feature. This chapter will disclose how to go about solving an indoor network
type problem and demonstrate some common use cases for wayfinding inside buildings.
Chapter 9, Topology Checking and Data Validation, covers data quality and connections. In this
chapter, you will learn how to verify your data for errors using custom topological functions.
Chapter 10, Visualizing Your Analysis, explains how geospatial data is inherently visual and
you will learn about presenting your analysis on a web map and a 3D web.
Chapter 11, Web Analysis with GeoDjango, builds on Chapter 8, Network Routing Analysis,
where you will create an indoor routing web application. You will easily be able to route a
person from point A to point B within a building with real 3D network data. These key features
will be presented by bringing together all the parts of the recipes you have learned so far.

Preface
Appendix A, Other Geospatial Python Libraries, explains how Python flourishes with geospatial
libraries, and you will also find a listing of many popular libraries that are used for data
analysis, regardless of whether they're spatial or not. This may trigger your interest.
Appendix B, Mapping Icon Libraries, quickly goes over the icon libraries out there that play a
special role in the python geospatial working environment.

Setting Up Your
Geospatial Python
Environment
In this chapter, we will cover the following topics:
f

Installing virtualenv and virtualenvwrapper

Installing pyproj and NumPy

Installing shapely, matplotlib, and descartes

Installing pyshp, geojson, and pandas

Installing SciPy, PySal, and IPython

Installing GDAL and OGR

Installing GeoDjango and PostgreSQL with PostGIS

Introduction
This chapter will get the grunt work done for you so that you can freely and actively complete
all the recipes in this book. We will start off by installing, each of the libraries you will be using,
one by one. Once each step is completed, we will test each library installation to make sure
it works. Since this book is directed toward those of you already working with spatial data,
you can skip this chapter if you have it installed already. If not, you will find the installation
instructions here useful as a reference.
The choice of Python libraries is based on industry-proven reliability and functionality. The
plethora of functions in Python libraries has led to a flourishing GIS support on many top
desktop GIS systems, such as QGIS and ESRI ArcGIS.
1

Setting Up Your Geospatial Python Environment

Also included in this book is an installer.sh bash file. The installer.sh file can
be used to install the Python libraries that are available for your virtual environment from
pip and other dependencies via the apt-get command. The installer.sh bash file
is executed from the command line and installs almost everything in one go, so please
take a look at it. For those of you who are starting with Python for the first time, follow the
instructions in this chapter and your machine will be set up to complete different recipes.
Installations can sometimes be tricky even for advanced users, so you will find some of the
most common pitfalls and hook-ups described in this chapter.
The development of these recipes was completed on a fresh Linux/Ubuntu 14.04 machine.
Therefore, the code examples, if not otherwise specified, are Linux/Ubuntu-specific with
Windows notes wherever necessary, unless otherwise specified.

Installing virtualenv and virtualenvwrapper

This recipe will enable you to manage different versions of different libraries for multiple
projects. We use virtualenv to create virtual Python environments to host collections of
project-specific libraries in an isolated directory. For example, you may have an old legacy
project using Django 1.4, whereas a new project requires you use Django version 1.8. With
virtualenv, you can have both versions of Django installed on the same machine, and each
project can access the appropriate version of Django without any conflicts or problems.
Without virtualenv, you are forced to either upgrade the old project or find a workaround
to implement the new features of the other version, therefore limiting or complicating the
new project.
The virtualenv allows you to simply switch between different Python virtual environments
for your individual projects. This has the added benefit that you can easily and quickly set up
a new machine for testing or help a new developer get their machine up and running as fast
as possible.

Getting ready
Before anything, we are going to assume that you already have a Linux/Ubuntu machine or a
virtualbox instance running Linux/Ubuntu so you can follow these instructions.
I also suggest trying out Vagrant (http://www.vagrantup.com),
which uses virtualbox to box and standardize your development
environment.

Chapter 1
Ubuntu 14.04 comes with Python 2.7.6 and Python 3.4 preinstalled; the other libraries are
your responsibility as explained in the following sections.
Windows users need to download and install Python 2.7.x from the Python home page at
https://www.python.org/downloads/windows/; please download the newest version
of the 2.7.x series since this book is written with 2.7.X in mind. The installer includes a
bundled version of pip, so make sure you install it!
Take a close look at the correct version to download, making sure that you get either the
32-bit or 64-bit download. You cannot mix and match the versions, so be careful and
remember to install the correct version.
A great site for other kinds of Windows binaries can be found at http://www.lfd.uci.
edu/~gohlke/pythonlibs/. Wheel files are the new norms of installations and can be
executed from the command line as follows:
python pip install libraryName.whl

On Windows, make sure that your Python interpreter is set up on

your system path. This way, you can simply call Python directly
from the command prompt using the C:\Users\Michael>
python filename.py command. If you need more help,
information can be found by following one of the online
instructions at https://pypi.python.org/pypi/pip.
As of Python 2.7.9 and later versions, pip is available on
installation.

Python 3 would be awesome to use, and for many Python GIS libraries, it is ready for
show time. Unfortunately, not all GIS libraries jive with Python 3 (pyproj) as one would
love to see at the time of writing this. If you want, feel free to go for Python 3.x and give it
a go. A great webpage to check the compatibility of a library can be found at https://
caniusepython3.com/.
To install virtualenv, you need to have a running installation of Python and pip. The
pip package manager manages and installs Python packages, making our lives easier.
Throughout this book, if we need to install a package, pip will be our tool of choice for this
job. The official installation instructions for pip can be found at https://pip.pypa.io/en/
latest/installing.html. To install pip from the command line, we first need to install
easy_install. Let's try it out from the Terminal:
$ sudo apt-get install python-setuptools python-pip

Setting Up Your Geospatial Python Environment

With this one line, you have both pip and easy_install installed.
What is sudo?
sudo is a program for Unix-like computer operating systems
that allows users to run programs with the security privileges
of another user (normally, the super user or root). Its name is
a concatenation of su (substitute user) and do (take action).
Take a look at http://en.wikipedia.org/wiki/Sudo
for more information on this.

The command sudo means to run an execution as a super user. If this fails, you will need
to get the ez_setup.py file, which is available at https://bootstrap.pypa.io/ez_
setup.py. After downloading the file, you can run it from the command line:
$ python ez_setup.py

Now pip should be up and running and you can execute commands to complete the
installations of virtualenv and virtualenvwrapper. The virtualenvwrapper creates shortcuts
that are faster ways to create or delete your virtual environments. You can test it as follows:
$ pip install virtualenv

How to do it...
The steps to install your Python virtualenv and virtualenvwrapper packages are
as follows:
1. Install virtualenv using the pip installer:
$ sudo pip install virtualenv

2. Install virtualenvwrapper using easy_install:

$ sudo easy_install virtualenvwrapper

We use easy_install instead of pip because with

Ubuntu 14.04, the virtualenvwrapper.sh file
is unfortunately not located at /usr/local/bin/
virtualenvwrapper.sh where it should be according
to the online documentation.

3. Assign the WORKON_HOME variable to your home directory with the folder name
venvs. Create a single folder where you want to store all your different Python virtual
environments; in my case, the folder is located at /home/mdiener/venvs:
$ export WORKON_HOME=~/venvs
$ mkdir $WORKON_HOME

Chapter 1
4. Run the source command to execute the virtualenvrapper.sh bash file:
$ source /usr/local/bin/virtualenvwrapper.sh

5. Next, we create a new virtual environment called pygeoan_cb, and this is also the
name of the new folder where the virtual environment is installed:
$ mkvirtualenv pygeoan_cb

To use virtualenvwrapper the next time you start up your machine, we need to
set it up so that your bash terminal runs the virtualenvwrapper.sh script when
your computer starts.
6. First, put it in your ~/.bashrc file:
$ echo "export WORKON_HOME=$WORKON_HOME" >> ~/.bashrc

7.

Next, we'll import the virtualenvwrapper function in our bash:

$ echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.bashrc

8. Now we can execute our bash:

$ source ~/.bashrc

How it works...
Step one shows how pip installs the virtualenv package into your system-wide Python
installation. Step two shows how the virtualenvwrapper helper package is installed with
easy_install because the virtualenvwrapper.sh file is not created using the pip
installer. This will help us create, enter, and generally, work or switch between Python virtual
environments with ease. Step three assigns the WORKON_HOME variable to a directory where
we want to have all of our virtual environments. Then, we'll create a new directory to hold all
the virtual environments. In step four, the command source is used to execute the shell script
to set up the virtualenvwrapper package. In step five, we see how to actually create a
new virtualenv called pygeoan_cb in our /home/mdiener/venvs directory. This final
step automatically starts our virtualenv session.
Once the virtualenv session starts, we can now see the name of virtualenv in brackets
like this:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

To exit virtualenv, simply type the following code:

$ deactivate

Now, your command line should be back to normal as shown here:

mdiener@mdiener-VirtualBox:~$

Setting Up Your Geospatial Python Environment

To reactivate virtualenv, simply type:
$ workon pygeoan_cb

The workon command has Tab completion. So, simply type

workon, and then the first letter of the name of the virtual
environment you want to enter, such as py. Hit Tab and it will
autocomplete the name.

Inside the /venvs folder, you will find specific individual virtual environments for each project
in the form of a subfolder. The virtualenvwrapper package will always create a new folder
for each new project you create. You can, therefore, easily delete a folder and it will remove
your virtual environment.
To quickly print a list all of the installed libraries to a file, we'll use the pip command:
$ pip freeze > requirements.txt

This will create a text file called requirements.txt in the current folder. The text file
contains a list of all the installed Python packages inside the Python virtual environment
currently running.
To create a new virtualenv from a requirements file, use the following command:
$ pip install -r /path/to/requirements.txt

There's more
For those of you who are just starting out with geospatial Python development, it should be
noted that you should keep your project-specific code at another location outside your Python
virtual environment folder. For example, I always have each project-related code contained in a
separate folder called 01_projects, which is my main folder. The path to my projects folder is
/home/mdiener/01_projects, and the structure of two of my projects is as follows:
f

01_projects/Name_project1

01_projects/Name_project2

All virtual environments are located under /home/mdiener/venvs/. Usually, I give them the
same name as a project to keep things organized, as follows:
f

/home/mdiener/venvs/Name_project1

/home/mdiener/venvs/Name_project2

Chapter 1

Installing pyproj and NumPy

The pyproj is a wrapper around the PROJ.4 library that works with projections and performs
transformations (https://pypi.python.org/pypi/pyproj/) in Python. All your
geographic information should be projected into one of the many coordinate systems
supported by the European Petroleum Survey Group (EPSG). This information is necessary
for the systems to correctly place data at the appropriate location on Earth. The geographic
data can then be placed on top of each other as layers upon layers of data in order to create
maps or perform analysis. The data must be correctly positioned or we won't be able to add,
combine, or compare it to other data sources spatially.
Data comes from many sources and, often, a projection is not the same as a dataset. Even
worse, the data could be delivered with a description from a data provider stating it's in
projection UTM31 when, in reality, the data is in projection UTM34! This can lead to big
problems later on when trying to get your data to work together as programs will throw you
some ugly error messages.
NumPy is the scientific backbone of number crunching arrays and complex numbers that are
used to power several popular geospatial libraries including GDAL (geospatial abstraction
library). The power of NumPy lies is in its support for large matrices, arrays, and math
functions. The installation of NumPy is, therefore, necessary for the other libraries to function
smoothly, but is seldom used directly in our quest for spatial analysis.

Getting ready
Fire up your virtual environment, if it is not already running, using the following standard
start command:
$ workon pygeoan_cb

Your prompt should now look like this:

(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

If workon for some reason does not start your virtual

environment, you can start it simply by executing source /
home/mdiener/venvs/pygeoan_cb/bin/activate
from the command line; try the steps listed in the Installing
virtualenv and virtualenvwrapper recipe again to get it going.

Now, we need to install some Python tools for development that allow us to install NumPy, so
run this command:
$ sudo apt-get install -y python-dev

You are now ready to move on and install pyproj and NumPy inside your running virtual
environment.
7

Setting Up Your Geospatial Python Environment

How to do it...
Simply fire up virtualenv and we will use the pip installer to do all the heavy lifting as follows:
1. Use pip to go ahead and install NumPy; this can take a couple of minutes as many
lines of installation verbosity are written on screen:
$ pip install numpy

Windows users can grab the .whl file for NumPy and execute it using following
command:
pip install numpy -1.9.2+mkl-cp27-none-win32.whl

2. Use pip one more time to install pyproj:

$ pip install pyproj

Windows users can use the following command to install pyproj:

pip install pyproj-1.9.4-cp27-none-win_amd64.whl

3. Wait a few minutes; NumPy should be now running along with pyproj. To test if it's
worked out, enter the following command in the Python console. The output should
look like this:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~/venv$ python
Python 2.7.3 (default,

Feb 27 2014, 19:58:35)

[GCC 4.6.3] on linux2

Type help,
information.

copyright, credits, or

license for more

>> import numpy

>> import pyproj

No errors, I hope. You have now successfully installed NumPy and pyproj.
All sorts of errors could show up, so please take a look at the
respective installation links to help you solve them:
For pyproj: https://pypi.python.org/pypi/pyproj/
For NumPy: http://www.numpy.org

Chapter 1

How it works...
This easy installation works using the standard pip installation method. No tricks or special
commands are needed. You need to simply execute the pip install <library_name>
command and you are off to the races.
Library names can be found by visiting the
https://pypi.python.org/pypi web page if
you are unsure of the exact name you want to install.

Installing shapely, matplotlib, and descartes

A large part of geospatial analysis and visualization is made possible using Shapely,
matplotlib, GDAL, OGR, and descartes, which are installed later. Most of the recipes here will
use these libraries extensively so setting them up is necessary to complete our exercises.
Shapely (http://toblerity.org/shapely) provides pure spatial analysis of geometries
using the Cartesian coordinate system as is used by AutoCAD, for those of you familiar
with CAD-like programs. The benefit of using a flat coordinate system is that all the rules of
Euclidean geometry and analytic geometry are applied. For a quick refresher in the coordinate
systems that we all learned in school, here is a little image to quickly jolt your memory.

Description: A Cartesian coordinate system demonstrating a flat

plane to plot and measure geometry.
Illustration 1: Source: http://en.wikipedia.org/wiki/
Cartesian_coordinate_system.
9

Setting Up Your Geospatial Python Environment

The classic overlay analysis and other geometric computations is where Shapely shines using
the GEOS library as its workhorse in the background.
As for matplotlib (http://matplotlib.org/), it is the plotting engine that renders nice
graphs and data to your screen as an image or scalable vector graphic (svg). The uses of
matplotlib are only limited to your imagination. So, like the name partially implies, matplotlib
enables you to plot your data on a graph or even on a map. For those of you familiar with
MATLAB, you will find matplotlib quite similar in functionality.
The descartes library provides a nicer integration of Shapely geometry objects with Matplotlib.
Here, you will see that descartes opens the fill and patch of matplotlib plots to work with
the geometries from Shapely and saves you from typing them individually.

Getting ready
To prepare for installation, it is necessary to install some global packages, such as
libgeos_c, as these are required by Shapely. NumPy is also a requirement that we have
already met and is also used by Shapely.
Install the requirements of matplotlib from the command line like this:
$ sudo apt-get install freetype* libpng-dev libjpeg8-dev

These are the dependencies of matplotlib, which can be seen on a Ubuntu 14.04 machine.

How to do it...
Follow these instructions:
1. Run pip to install shapely:
$ pip install shapely

2. Run pip to install matplotlib:

$ pip install matplotlib

3. Finally, run pip to install descartes:

$ pip install descartes

10

Chapter 1
Another test to see if all has gone well is to simply enter the Python console and try to import
the packages, and if no errors occur, your console should show an empty Python cursor. The
output should look like what is shown in the following screenshot:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~/venv$ python
Python 2.7.3 (default,

Feb 27 2014, 19:58:35)

[GCC 4.6.3] on linux2

Type help,

copyright, credits, or

license for more information.

>>> import shapely

>>> import matplotlib
>>> import descartes
>>>

# type exit() to return

>>> exit()

If any errors occur, Python usually provides some good clues as to where the problem
is located and there is always Stack Overflow. For example, have a look at http://
stackoverflow.com/questions/19742406/could-not-find-library-geos-cor-load-any-of-its-variants/23057508#2305750823057508.

How it works...
Here, the order in which you install the packages is very important. The descartes package
depends on matplotlib, and matplotlib depends on NumPy plus freetype and libpng. This
narrows you down to installing NumPy first, then matplotlib and its dependencies, and
finally, descartes.
The installation itself is simple with pip and should be quick and painless. The tricky
parts occur if libgeos_c is not installed properly, and you might need to install the
libgeos-dev library.

11

Setting Up Your Geospatial Python Environment

Installing pyshp, geojson, and pandas

These specific libraries are for specific formats that make our life easier and simpler than
using GDAL for some projects. pyshp will work with shapefiles, geojson with GeoJSON, and
pandas with all other textual data types in a structured manner.
pyshp is pure Python and is used to import and export shapefiles; you can find the source
code for pyshp here at https://github.com/GeospatialPython/pyshp. The pyshp
library's sole purpose is to work with shapefiles. GDAL will be used to do most of our data's
in/out needs, but sometimes, a pure Python library is simpler when working with shapefiles.
geojson is the name of a Python library and also a format, making it a little confusing to
understand. The GeoJSON format (http://geojson.org) is becoming ever more popular
and to this extent, we use the Python geojson library to handle its creation. You will find it on
Python Package Index (PyPI) if you search for geojson. As you would expect, this will help us
create all the different geometry types supported in the GeoJSON specifications.
pandas (http://pandas.pydata.org) is a data analysis library that structures your data
in a spreadsheet-like manner for further computations. Since our geospatial data comes
from a broad set of sources and formats, such as CSV, pandas helps work with the data with
minimal effort.

Getting ready
Enter your virtual environment using the following command:
$ workon pygeoan_cb

Your prompt should now look like this:

(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

How to do it...
The three installations are as follows:
1. Pyshp will first be installed by simply using pip as follows:
$ pip install pyshp

2. Next, the geojson library will be installed using pip:

$ pip install geojson

3. Finally, pip will install pandas:

$ pip install pandas

12

Chapter 1
To test your installation of pyshp, use the import shapefile type. The output should look
like what is shown in the following output:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~/venv$ python
Python 2.7.3 (default,

Feb 27 2014, 19:58:35)

[GCC 4.6.3] on linux2

Type help,

copyright, credits, or

license for more information.

>> import shapefile

>> import geojson
>> import pandas

The import shapefile statement imports the pyshp library;

unlike the other libraries, the import name is not the same as the
installation name.

How it works...
As seen in the other modules, we've used the standard installation pip package to execute
installations. There are no other dependencies to worry about, making for fast progress.

Installing SciPy, PySAL, and IPython

SciPy is a collection of Python libraries, including SciPy library, matplotlib, pandas, SymPy, and
IPython. The SciPy library itself is used for many operations, but we are particularly interested in
the spatial module. This module can do many things including running a nearest neighbor query.
PySAL is a geospatial computing library that's used for spatial analysis. Creating models and
running simulations directly from Python code are some of the many library functions that
PySAL offers. PySAL is a library that, when put together with our visualization tools such as
matplotlib, gives us a great tool.
IPython is a Python interpreter for a console that replaces the normal Python console you may be
used to when running and testing Python code from your terminal. This is really just an advanced
interpreter with some cool features, such as Tab completion, which means that beginners can get
commands quickly by typing a letter and hitting Tab. The IPython notebooks help share code in
the form of a web page, including code, images, and more without any installation.

Getting ready
The dependency jungle we looked at earlier is back and we need three more universal
installations to our Ubuntu system using apt-get install as follows:
$ sudo apt-get install libblas-dev liblapack-dev gfortran
13

Setting Up Your Geospatial Python Environment

Windows and Mac users can use a full installer (http://
www.scipy.org/install.html), such as Anaconda
or Enthought Canopy, which will perform all the installation
dependencies for you in one go.

Three dependencies are used for the SciPy installation. PySAL depends on SciPy so make
sure to install SciPy first. Only IPython does not need any extra installations.
Start up your Python virtual environment with the following code:
mdiener@mdiener-VirtualBox:~$ workon pygeoan_cb
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

How to do it...
Let's look at these steps:
1. First, we'll install SciPy since PySAL depends on it. This will take a while to install; it
took my machine 5 minutes to go through so take a break:
$ pip install scipy

2. PySAL can be installed super quickly using pip:

$ pip install pysal

3. As usual, we'd like to see whether everything's working, so let's fire up the Python
shell as follows:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$python
>>> import scipy
>>> import pysal
>>>

4. IPython is to be installed globally or inside the virtual environment using pip

as follows:
$ pip install ipython

How it works...
SciPy and PySAL libraries are both geared to help accomplish various spatial analysis duties.
The choice of tool is based on the task at hand, so make sure that you check which library
offers what function at the command prompt as follows:
>>> from scipy import spatial
>>> help(spatial)
14

Chapter 1
The output should look like what is shown in the following screenshot:

Installing GDAL and OGR

Converting formats is boring, repetitive, and is one of the many, many responsibilities that the
GDAL library provides, not to mention format transformations. However, GDAL also shines with
regard to other geospatial functions, such as getting the current projections of a Shapefile or
generating contours from elevation data. So, to only say that GDAL is a transformation library
would be wrong; it really is so much more. The father of GDAL, Frank Warmerdam, deserves
credit for starting it all off, and the GDAL project is now part of the OSGEO (Open Source
Geospatial Foundation, refer to www.osgeo.org).
The GDAL installation includes OGR; there is no extra
installation required.

Currently, GDAL covers working with raster data, and OGR covers working with vector data.
With GDAL 2.x now here, the two sides, raster and vector, are merged under one hat. GDAL
and OGR are the so-called Swiss Army knives of geospatial data transformations, covering
over 200 different spatial data formats.

15

Setting Up Your Geospatial Python Environment

Getting ready
GDAL isn't known to be the friendliest beast to install on Windows, Linux, or OSX. There are
many dependencies and even more ways to install them. The descriptions are not all very
straightforward. Keep in mind that this description is just one way of doing things and will not
always work on all machines, so please refer to the online instructions for the latest and best
ways to get your system up and running.
To start with, we will install some dependencies globally on our machine. After the
dependencies have been installed, we will go into the global installation of GDAL for
Python in our global site packages.

How to do it...
To globally install GDAL into our Python site packages, we will proceed with the following steps:
1. The following command is used when installing build and XML tools:
$ sudo apt-get install -y build-essentiallibxml2-dev libxslt1-dev

2. Install the GDAL development files using the following command:

$ sudo apt-get install libgdal-dev # install is 125MB

3. This following command will install GDAL package in the main Python package. This
means that GDAL will be installed globally. The global installation of GDAL is usually
not a bad thing since, as far as I am aware, there are no backward incompatible
versions, which is very rare these days. The installation of GDAL directly and only in
virtualenv is painful, to say the least, and if you are interested in attempting it, I've
mentioned some links for you to try out.
$ sudo apt-get install python-gdal

If you would like to attempt the installation inside your virtual

environment, please take a look at this Stack Overflow
question at http://gis.stackexchange.com/
questions/28966/python-gdal-package-missingheader-file-when-installing-via-pip.

4. To get GDAL in the Python virtual environment, we only need to run a simple
virtualevnwrapper command:
toggleglobalsitepackages

Make sure you have your virtual environment activated as follows:

mdiener@mdiener-VirtualBox:~$ workon pygeoan_cb
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

16

Chapter 1
5. Now, activate the global Python site packages in your current virtual environment:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$ toggleglobalsitepackages
enable global site-packages

6. The final check is to see if GDAL is available as follows:

$ python
>>> import gdal
>>>

7.

No errors have been found and GDAL is ready for action.

Windows 7 plus users should use the OSGeo4W windows installer (https://trac.osgeo.
org/osgeo4w/).Find the following section on the web page and download your Windows
version in 32-bit or 64-bit. Follow the graphical installer instructions and the GDAL installation
will then be complete.
Windows users can also directly get binaries if all fails at
http://www.gisinternals.com/sdk/. This installer
should help avoid any other Windows specific problems that can
arise and this site can help get you going in the right direction.

How it works...
The GDAL installation encompasses both the raster (GDAL) and vector (OGR) tools in one.
Within the GDAL install are five modules that can be separately imported into your project
depending on your needs:
>>> from osgeo import gdal
>>> from osgeo import ogr
>>> from osgeo import osr
>>> from osgeo import gdal_array
>>> from osgeo import gdalconst
>>> python
>>> import osgeo
>>> help(osgeo)

17

Setting Up Your Geospatial Python Environment

To see what packages are included with your Python GDAL installation, we use the Python
built-in help function to list what the OSGeo module has to offer. This is what you should see:
NAME
osgeo - # __init__ for osgeo package.
FILE
/usr/lib/python2.7/dist-packages/osgeo/__init__.py
MODULE DOCS
http://docs.python.org/library/osgeo
PACKAGE CONTENTS
_gdal
_gdal_array
_gdalconst
_ogr
_osr
gdal
gdal_array
gdalconst
gdalnumeric
ogr
osr
DATA
__version__ = '1.10.0'
version_info = sys.version_info(major=2, minor=7, micro=3,
releaseleve...
VERSION
1.10.0
(END)

At the time of writing this, the GDAL version is now bumped up to 2.0, and in developer land,
this is old even before it gets printed. Beware that the GDAL 2.0 has compatibility issues and
for this book, version 1.x.x is recommended.

See also
The http://www.gdal.org homepage is always the best place for reference regarding any
information about it. The OSGEO includes GDAL as a supported project, and you can find more
information on it at http://www.osgeo.org.

18

Chapter 1

Installing GeoDjango and PostgreSQL

with PostGIS
This is our final installation recipe and if you have followed along so far, you are ready for
a simple, straightforward start to Django. Django is a web framework for professionals
with deadlines, according to the Django homepage. The spatial part of it can be found
in GeoDjango. GeoDjango is a contrib module installed with every Django installation
therefore, you only need to install Django to get GeoDjango running. Of course, "geo" has its
dependencies that were met in the previous sections. For reference purposes, take a look at
this great documentation on the Django homepage at
https://docs.djangoproject.com/en/dev/ref/contrib/gis/install/#refgis-install.

We will use PostgreSQL and PostGIS since they are the open source industry go-to spatial
databases. The installations are not 100% necessary, but without them there is no real point
because you then limit your operations, and they're definitely needed if you plan to store your
spatial data in a spatial database. The combination of PostgreSQL and PostGIS is the most
common spatial database setup for GeoDjango. This installation is definitely more involved
and can lead to some hook-ups depending on your system.

Getting ready
To use GeoDjango, we will need to have a spatial database installed, and in our case, we
will be using PostgreSQL with the PostGIS extension. GeoDjango also supports Oracle,
Spatialite, and MySQL. The dependencies of PostGIS include GDAL, GEOS, PROJ.4, LibXML2,
and JSON-C.
Start up your Python virtual environment as follows:
mdiener@mdiener-VirtualBox:~$ workon pygeoan_cb
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$

Downloading the example code

You can download the example code files for all Packt
books you have purchased from your account at
http://www.packtpub.com. If you purchased
this book elsewhere, you can visit http://www.
packtpub.com/support and register to have the
files e-mailed directly to you.

19

Setting Up Your Geospatial Python Environment

How to do it...
Follow these steps. These are taken from the PostgreSQL homepage for Ubuntu Linux:
1. Create a new file called pgdg.list using the standard gedit text editor. This stores
the command to fire up your Ubuntu installer package:
$ sudo gedit /etc/apt/sources.list.d/pgdg.list

2. Add this line to the file, save, and then close it:
$ deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main

3. Now, run the wget command for add the key:

$ wget --quiet -O - https://www.postgresql.org/media/keys/
ACCC4CF8.asc | \ sudo apt-key add -

4. Run the update command to actualize your installer packages:

$ sudo apt-get update

5. Run the install command to actually install PostgreSQL 9.3:

$ sudo apt-get install postgresql-9.3

6. To install PostGIS 2.1, we will have one unmet dependency, libgdal1, so go ahead
and install it:
$ sudo apt-get install libgdal1

7.

Now we can install PostGIS 2.1 for PostgreSQL 9.3 on our machine:
$ sudo apt-get install postgresql-9.3-postgis-2.1

8. Install the PostgreSQL header files:

$ sudo apt-get install libpq-dev

9. Finally, install the contrib module with contributions:

$ sudo apt-get install postgresql-contrib

10. Install the Python database adapter, psycopg2, to connect to your PostgreSQL
database from Python:
$ sudo apt-get install python-psycopg2

11. Now we can create a standard PostgreSQL database as follows:

(pygeoan_cb)mdiener@mdiener-VirtualBox:~$ createdb
[NewDatabaseName]

20

Chapter 1
12. Using the psql command-line tool, we can create a PostGIS extension to our newly
created database to give it all the PostGIS functions as follows:
(pygeoan_cb)mdiener@mdiener-VirtualBox:~$ psql -d
[NewDatabaseName] -c "CREATE EXTENSION postgis;"

13. Moving on, we can finally install Django in one line directly in our activated
virtual environment:
$ pip install django

14. Test out your install of Django and GDAL and, as always, try to import them as follows:
>>> from django.contrib.gis import gdal
>>> gdal.HAS_GDAL
True

Windows users should be directed to the PostgreSQL Windows (http://www.postgresql.

org/download/windows/) binaries provided by EnterpriseDB (http://www.
enterprisedb.com/products-services-training/pgdownload#windows). Download
the correct version and follow the installer instructions. PostGIS is also included in the list of
extensions that you can directly install using the installer.

How it works...
Installations using the apt-get Ubuntu installer and the Windows installers are simple enough
in order to have PostgreSQL, PostGIS, and Django up and running. However, the inner
workings of the installers are beyond the scope of this book.

There's more...
To summarize all the installed libraries, take a look at this table:
Library name

Description

Reason to install

NumPy

This adds support for large

multidimensional arrays and matrices

It is a requirement for many other

libraries

pyproj

This handles projections

It transforms projections

shapely

This handles geospatial operations

It performs fast geometry

manipulations and operations

matplotlib

This plots libraries

It provides a quick visualization

of results

descartes

This uses Shapely or GeoJSON objects

as matplotlib paths and patches

It speedily plots geo-data

pandas

This provides high-performance data

structures and data analysis

It performs data manipulation, CSV

creation, and data manipulation
21

Setting Up Your Geospatial Python Environment

Library name

Description

Reason to install

SciPy

This provides a collection of Python

libraries for scientific computing

It has the best collection of

necessary tools

PySAL

This contains a geospatial analysis

library

It performs a plethora of spatial

operations (optional)

IPython

This provides interactive Python

computing

It is a helpful notebook to store and

save your scripts (optional)

Django

This contains a web application

framework

It is used for our demo web

application in Chapter 11, Web
Analysis with GeoDjango

pyshp

This provides pure Python shapefile

manipulation and generation

It helps input and output shapefiles

GeoJSON

This contains the JSON format for

spatial data

It facilitates the exchange and

publication of this format

PostgreSQL

This is a relational database

It helps store spatial data

PostGIS

This is the spatial extension to

PostgreSQL

It stores and performs spatial

operations on geographic data in
PostgreSQL

22

Get more information Python Geospatial Analysis Cookbook

Where to buy this book

You can buy Python Geospatial Analysis Cookbook from the Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: