Seems this is a good day for QGIS Oracle users. According this commit made by Jürgen QGIS now has built-in Oracle support. Win!
Native Oracle support can now see QGIS being opened up to a wider user base yet again. A large user base normally means more people willing to sponsor awesome new features and bug fixes. Having seen the growth in the user base from having native MS SQL Server 2008+ support I can imagine what it will be like with Oracle.
The list of formats QGIS can open and edit is getting larger and larger with each release. Is there a future for vendor lock in? I can’t see it.
Standard disclaimer about latest dev build and new features:)
This has been part of an ongoing effort from the documentation team since before the 1.8 release to bring our all our documentation into reStructedText rather then LaTeX. Moving to reStructedText allows quicker updates and a larger range of final output formats.
I would like to thank everyone who has been involved in this process as I know what a grueling process updating documentation can be.
Community notice
Just remember you don’t have to be a programmer to contribute to an open source project. If you think you could contribute to the updating of the QGIS documentation please contact the team on the mailing list.
If you need to do any kind of spatial operations in QGIS using Python or C++ you really want them to be as fast a possible in order reduce the amount of time you make the user wait. Lets take the simple scenario of a recent question that was asked on gis.stackexchange; Summing up values of neighboring polygons?.
I went for the SQL approach as I like how quick SQL can express what you need to do, however SQL is not the only way to skin a cat as spatialthoughts has shown in his blog post. Here Ujaval has used Python to find the neighboring polygons of each feature. Running the script on a small dataset yields results in reasonable time however running it on a larger dataset can take a long time.
In order to check if a feature touches another you need to have two features to compare against each other. The simple way to do this is to create two loops where you check each feature against every other feature. Here is a quick code example of just that.
layer = qgis.utils.iface.activeLayer()
# Select all features along with their attributes
allAttrs = layer.pendingAllAttributesList()
layer.select(allAttrs)
# Get all the features to start
allfeatures = {feature.id(): feature for (feature) in layer}
def noindex():
for feature in allfeatures.values():
for f in allfeatures.values():
touches = f.geometry().touches(feature.geometry())
# It doesn't matter if we don't return anything it's just an example
import timeit
print "Without Index: %s seconds " % timeit.timeit(noindex,number=1)
So the above code is pretty simple, just loop each feature and check against every other feature. No worries. No worries at least until you run this on a large dataset then I think you can see the issue here. Running the above code on a layer with around 28000 features takes 1912.41 seconds – that’s 31 minutes. Holy crap!
Note: We put all the features of the layer into a dictionary as it will make lookup quicker in the later index example.
How can we speed up the above code? Lets take a gander at QgsSpatialIndex
QgsSpatialIndex to rule them all
QgsSpatialIndex is a wrapper around the open source SpatailIndex lib and uses a RTree for an index method. If you don’t know what an index is you can think of it like the index in a book – a pointer to a location in the book rather then having to scan every page to find a word.
There isn’t much to using QgsSpatialIndex just insert each QgsFeature and it handles the rest, when we need something out we just use the intersects method to return any features inside an area.
layer = qgis.utils.iface.activeLayer()
# Select all features along with their attributes
allAttrs = layer.pendingAllAttributesList()
layer.select(allAttrs)
# Get all the features to start
allfeatures = {feature.id(): feature for (feature) in layer}
def withindex():
# Build the spatial index for faster lookup.
index = QgsSpatialIndex()
for f in allfeatures.values():
index.insertFeature(f)
# Loop each feature in the layer again and get only the features that are going to touch.
for feature in allfeatures.values():
# Get the ids of all the features in the index that are within
# the bounding box of the current feature because these are the ones
# that will be touching.
ids = index.intersects(feature.geometry().boundingBox())
for id in ids:
f = allfeatures[id]
if f == feature: continue
touches = f.geometry().touches(feature.geometry())
# It doesn't matter if we don't return anything it's just an example
import timeit
print "With Index: %s seconds " % timeit.timeit(withindex,number=1)
Running this code on our 28000 feature layer returns the results in 10 seconds. 31 minutes down to 10 seconds by just using a spatial index. Nice!
So the next time you need to do some spatial operations remember to use the handy QgsSpatialIndex in order to speed up your code. If you don’t want to use QgsSpatialIndex, or need some more flexiblity, you could even use the Python RTree module.
Full code
layer = qgis.utils.iface.activeLayer()
# Select all features along with their attributes
allAttrs = layer.pendingAllAttributesList()
layer.select(allAttrs)
# Get all the features to start
allfeatures = {feature.id(): feature for (feature) in layer}
def noindex():
for feature in allfeatures.values():
for f in allfeatures.values():
touches = f.geometry().touches(feature.geometry())
# It doesn't matter if we don't return anything it's just an example
def withindex():
# Build the spatial index for faster lookup.
index = QgsSpatialIndex()
map(index.insertFeature, allfeatures.values())
# Loop each feature in the layer again and get only the features that are going to touch.
for feature in allfeatures.values():
ids = index.intersects(feature.geometry().boundingBox())
for id in ids:
f = allfeatures[id]
touches = f.geometry().touches(feature.geometry())
# It doesn't matter if we don't return anything it's just an example
import timeit
print "With Index: %s seconds " % timeit.timeit(withindex,number=1)
print "Without Index: %s seconds " % timeit.timeit(noindex,number=1)
The easiest way install Python libraries is to use easy_install and pip. easy_install and pip are package managers for Python. From the easy_install page:
Easy Install is a python module (easy_install) bundled with setuptools that lets you automatically download, build, install, and manage Python packages.
pip is a tool for installing and managing Python packages, such as those found in the Python Package Index. It’s a replacement for easy_install.
To get easy_install you need to install Python setuptools and you are good to go. Sounds easy! However the setuptools installer assumes that you have the normal standalone Python installed which writes it’s install location to the registry, and when you run the installer it will say that it can’t find Python on the system. What the!?
If you have installed QGIS, or any other tool from the OSGeo4W install, you will see that OSGeo4W bundles its own version of Python in: C:\OSGeo4W\apps\python27. This is the Python that is used when calling python in the OSGeo4W shell. It seems someone on the OSGeo wiki has made a bootstrapped installer for setuptools that will install setuptools and easy_install into the C:\OSGeo4W\apps\python27 folder for you.
Most of the time any Python packages that are needed by your OSGeo4W tools are bundled in the installer and can be downloaded using the OSGeo4W installer, however there have been cases when I wanted to install a non OSGeo4W package into my setup by using easy_install or pip. Like bottle and flask in the example above.
As QGIS is such a fast moving project I have decided to make this a regular blog post in order to highlight some new features added to QGIS. If you haven’t already, don’t forget to check out round one.
Remember that some of these features may still only be new which might change between now and the next official released version. With that out of the way lets get listing.
Atlas integration
If you are a regular user of QGIS Python plugins, and who isn’t, then you would have used the awesome Atlas plugin developed by Vincent Picavet. This great tool can be used to generate mapbooks, or an atlas as some people like to say, using a coverage layer and a print composer. What makes this even more awesome is that it is now built into the print composer.
Atlas composer intergration
The builtin atlas function also gives you the ability to use an expression to do runtime text replacement, including access to all the fields on the coverage layer. The coverage layer doesn’t even have to be a region layer, it can be a simple point layer, or even a line layer. You can see the result of me running the atlas generation from the above example here
Big thanks to Oslandia for integrating this great feature, and the companies sponsoring the work.
New Python console
This new addition comes from the great work that Salvatore Larosa has been doing to add a better Python console to QGIS.
The new Python console includes attribute auto complete, syntax highlighting, better copy and paste, uploading to codepad, the ability to run code from a file, etc. You don’t realise how much difference there is until you go back to using the old one in version 1.8.
New Python console
Tabbed and groups in builtin forms
One of the things I really loved about QGIS, coming from MapInfo, was the builtin forms. Just having the ability to enter data using controls like combo boxes, calendar widgets, etc makes you one step closer to having better data. This feature is the exact reason I setup a 67 year old for kerb data collection.
As good as they are the builtin forms have an issue of ending up with as a big scrolling list with lots of fields; also the lack of the ability to group or put fields on tabs in the UI meant you had to create a custom form. Well not any more.
There is now a combo box on the Fields tab that allows you to build a generated form but also add tabs and group boxes. You can even have the same field shown more then once on the form, handy for something like an ID field that you would like to show on each tab.
With this new ability the builtin forms can get me 95% of the way for data entry jobs, the other 5% I just make a custom form – but that is very rare.
Sextante
Sextante is a great and powerful analytical framework that has been added to the core of QGIS thanks to Victor Olaya. This is not a feature that I use a lot but this is only due to most of my work being in development and not analysis, however that doesn’t mean that it’s not a really cool feature.
One of the greatest things about the Sextante toolbox is that it allows you to integrate other great open source tools like GRASS, SAGA, R, OTB, etc, right into your QGIS workflow and view the results in the canvas. It even includes a modeller so that you can build a connected diagram of all the bits of your process, even if it crosses between programs.
The toolbox
For me what is even better is that you can use Sextante in your plugins or custom Python code. Sextante has a Python interface – well the whole thing is written in Python – that you can use to run a Sextante supported algorithm.
“(InaSAFE) is very beneficial for all of us. It’s a good example of our partnership.”
Dr Susilo Bambang Yudhoyono – President of Indonesia
Some of the improvements include:
A new loadFromTemplate method, in the API, that can do text replacement in the QGIS composer template.
Better support for EPSG:4326 scale bars
Multipage in one composer
Automatic overview frame in map frame
HTML frame
Zebra style grid frame border
More control of grid labels. Inside, outside, disabled
etc, etc
These are great additions to the QGIS composer and I have already used the overview frame feature along with the new atlas integration to make some quick nice looking map books. \
Last Thursday and Friday was our first local Australian FOSS4G event which was hosted at the CSRIO building in Brisbane. Very big thanks to CSRIO for hosting the event. The venue was setup perfectly for hosting an event like this, including dual projectors for presenting, video calls over to Perth, etc.
The first day was done using a un-conference style of event. This is the first time I’ve been to a un-conference and I liked the format a lot. Once everyone was there on the first morning we collected ideas from people and everyone voted on which ones they would like to see. After we had picked enough topics Shaun and I made a program for the day and we started.
The second day was a code sprint. I worked on converting a MapBasic scripts from one of the guys to QGIS, and Jody enlisted the others to help check the headers of the GeoServer project so that it can finally pass OSGeo incubation.
Overall I think it was a very successful event. I would like to make these a yearly event if we can, provided that we have people to talk, or projects to work on.
So that came around quick. Seems it is November already.
Tomorrow is the FOSS4G-Au a locally organized un-conference.
How do I register?
If you would still like to come – which you should – you can register here (it’s free!) http://www.meetup.com/osgeo-aust-nz/events/83965312/ but you must RSVP on the meetup page in order to get building access and internet access.
Ever since I added expression based labels, including the new expression builder UI, something that I always wanted to add is the ability to define custom user defined functions in Python (or C++) and use them in an expression. The expression engine is used for labels, rulebased rendering, layer actions, field calculator, and atlas composer tags. Thanks to the all the awesome work on the expression engine by Martin all this cool stuff is now possible.
Today I pushed a commit into master that adds the ability to define a function in Python (or C++), register it in the expression engine, then use it anywhere expressions are used.
The good stuff
Lets take a use case from Ujaval Gandhi and his example of counting vertices for each feature.
First we need to import the new qgsfunction decorator function from qgis.utils. The qgsfunction decorator will take a normal Python function, wrap it up in the class used to define a function, and register it in the engine.
So what does an empty function look like:
from qgis.utils import qgsfunction
from qgis.core import QGis
@qgsfunction(0, "Python")
def vertices(values, feature, parent):
pass
@qgsfunction(0, "Python") means we are defining a new vertices function that takes 0 args and lives in the “python” group in the expression builder UI. Any custom function must take (values, feature, parent) as python args. values is a list of QVariants passed into the function, feature is the current QgsFeature, and parent is expression engine node (you use this to raise errors).
Lets stick some more logic in there:
from qgis.utils import qgsfunction
from qgis.core import QGis
@qgsfunction(0, "Python")
def vertices(values, feature, parent):
"""
Returns the number of vertices for a features geometry
"""
count = None
geom = feature.geometry()
if geom is None: return None
if geom.type() == QGis.Polygon:
count = 0
if geom.isMultipart():
polygons = geom.asMultiPolygon()
else:
polygons = [ geom.asPolygon() ]
for polygon in polygons:
for ring in polygon:
count += len(ring)
return count
Pretty simple. Get the geometry from the feature, check if it’s a polygon, if it is then count the number of vertices and return that number.
Now that we have that all done we can save it into a file in our .qgis/python folder, lets call it userfunctions.py (note you don’t have to save it here, anywhere that QGIS can find it will do. Anywhere on PATH)
Lets open QGIS and run import userfunctions.py:
Importing functions from userfunctions.py
Now open the label properties for the layer:
The new function shown in the expression builder
Nice! Notice also that the function doc string is used as the function help. How cool is that. You can also see the $ sign in front of the function, this is because any functions that take no args are considered special and use the $ sign as a convention, this is all automatic when the function is registered.
And the result is:
The label using the new function
You can even use it in the rule based rendering:
Rule rendering using new function
Enjoy!
Notes
You must unregister a function once you are finished with it using QgsExpression.unregisterFunction(name). This mainly applies to plugins where the user might unload your plugin and the code is no longer available. In the above example we could import userfunctions and never unregister because we plan on using it for the whole session.
Another quick announcement for today. The local FOSS4G-AU chapter is holding un-conference and code sprint in Brisbane on the 15 and 16th of November 2012.
Ben Caradoc-Davies made the announcement on the mailing list the other day:
The Free and Open Source Software for Geospatial Australia (FOSS4G-AU)
2012 Unconference and Code Sprint will be held at CSIRO’s Queensland
Centre for Advanced Technologies (QCAT), Pullenvale QLD.
15 November: Unconference
16 November: Code Sprint
This is a participant-organised event: please add your unconference and code sprint topic suggestions to the wiki. Organisers are welcome; please speak up.
I would like to announce QMap: A simple data collection application built using QGIS and Python.
QMap is a QGIS based field data collection application that was built by myself and a work college at Southern Downs Regional Council. QMap is now opened source under the same licence as QGIS, GPLv2. The project homepage can be found at http://nathanw2.github.com/qmap/ and source at https://github.com/NathanW2/qmap.
Before I go into to many more details I will preface with: The application is currently under active development and as such there might be bugs or little rough bits that I haven’t cleaned up yet. However having said that, the program is functional and we are using it at work for the purpose it was built.
Features
Simple to use
Simple to manage
Simple to install
Forms built using Qt Designer
Loads normal QGIS projects
Anything QGIS supports QMap does too (snapping, PostGIS, etc)
It’s just QGIS with a tablet friendlier interface.
Syncing support (MS SQL 2008 only at the moment)
The Story
The program was developed after we looked around and decided that nothing really fit our needs quite right and to our satisfaction. (Within budget of course)
We had a list of, I think simple, requirements:
Must be simple to use by field staff
Can deal with complex or simple forms
Fully offline but with a syncing option
GPS support
Easy maintenance
The first point for me is a big one. I have a seen a lot of data collection applications and unfortunately this is where I feel a lot of them fall down. Most seem to be designed with people like me in mind, people who understand computers, understand menu systems, etc. If you work in local government or with an older age group of outside workforce you will know that this assumption doesn’t hold true. Most of our field staff are not computer people, a few don’t even have home computer, expecting them to navigate a menu just to enable the GPS, or click on a small 16×16 pixel icon, on a tablet PC is not a option.
I decided to take the same approach as QGIS and use Qt Designer to build the forms. Why invent another tool? Using Qt Designer can also give us the flexibly of creating simple or complex forms in our own layout.
We do have pretty good 3G connection coverage over our region however we only have limited bandwidth to play with and having a solution that is full connected doesn’t really give the best user experience. I would rather just store everything locally on the device and then sync when needed. As all our layers are stored in MS SQL Server 2008 for the syncing we decided to use .NET Sync framework. I would love to have sync support for PostGIS, Spatialite, or any other normal files, but it was out of scope for the project (at the moment).
For me easy maintenance means two things: not having to deal with crap loads of configurations; and having the power to change what I don’t like. For the first point I’m a big fan of convention over configuration. I like to just drop stuff in a folder with a certain naming convention and it should just pick it up and work. This also goes for the form bindings, just name the control the same as the field in the layer and QMap will bind it for you. If I can follow a convention for things I have. Conventions make setup easier and consistent.
Once you have tasted the open source kool aid it can be quite hard to go back. Knowing that if there is a bug in QGIS I can fix it to make my project better is a comforting feeling. There is also the lack of licence fees which makes open source very attractive for jobs with small budgets.
How does it work?
At the moment the core of the application is built as a QGIS plugin, however there is one little trick here that is worth mentioning. QMap is really a script that loads QGIS and sets the –configpath in order to load all the QGIS settings from a supplied path, inside the supplied path is the plugin. Think of it as a sandboxed QGIS which only loads the QMap plugin. I’m also using the new customization function to remove all unneeded interface items.
Notes
Here are some notes worth bring up:
The application is still under development so things might change.
There is only point support at the moment, although adding line and region support wouldn’t be hard.
Syncing only works using MS SQL 2008 and the code is a bit rough. Will be cleaned up over time.
The build script only works on Windows and there is some win32 stuff for power management in the code. This is not because I don’t want to support the other platforms just that it was out of scope at work.
You need to be using the latest development build of QGIS (qgis-dev for those using OSGeo4W) this is because there have been a few bug fixes that make the application work as expected that aren’t in 1.8.
Nathan Woodrow 