QGIS: Qt5 and Python3 migration, current state

Behind the scenes a lot has happened to get ready for Qt5 and Python3. On the same codebase that is becoming the next release QGIS 2.16. This is really a great thing since we can focus work on a single master branch and I’m very happy that we got so far with this approach already.

Testing

At OPENGIS.ch we have put a huge effort into getting the Travis CI test infrastructure to test our code with Qt5 and Python 3. This gives us confidence that we don’t have regressions introduced once we declare Qt5 and Python 3 to be default. At the time of writing we have 177 tests passing on Qt5/Python3 vs 211 tests on Qt4/Python2. Most of the missing tests are caused by a single issue (PyQt5 and NULL, see below).

Migration tool

There is a script 2to3 that takes care of migrating “old” python code to portable code. That means, after running this tool on your python code it is compatible with PyQt4, PyQt5, Python2 and Python3.

It uses the future library for python compatibility and a custom qgis.PyQt module that takes care of importing from the appropriate PyQt4 or PyQt5 modules.

This can be done on build for core plugins with a new cmake option We do this on our (travis) CI builds when building for Qt5.

Please note that the tool does a very good job (kudos to Jürgen at this point) but it cannot do everything, so plugin developers will also need to test in-depth and we’ll need to also prepare a migration guide that lists things to manually take care of.

PyQt5

PyQt5 – just like Qt5 – is very similar to PyQt4. This is a good thing since it makes it easier to write portable code.

The main issue which we have found so far is the lack of PyQtNullVariant and without this we don’t have proper support for NULL values. Definitely a no-go. Or we use to a different handling of attributes which would mean major manual updates to all plugins, IMHO also a no-go. The good thing is, there are good chances that PyQtNullVariant will be re-introduced in PyQt 5.7 but this means that our minimum Qt requirement will be Qt 5.7 which in turn means that older linux distros will be locked into using old QGIS versions.

Qt5

A lot of these updates have been done some time ago already. Qt5 (without python involved) runs quite painless. QField wouldn’t run without it.

What’s left to do

  • Finding a solution for the PyQt5 NULL issue
  • Check which tests still fail after the issue has been fixed
  • Implement many other changes which we want to work on before being able to ship QGIS with a version number 3.0.
  • Writing a migration guide

Building

If you are curious to test it, make sure you have the build dependencies (recent distros ship with Qt5 and Python3, so just apt-get, dnf, pacman or however them from the repositories)

Here the commands I use to build and run from the build directory (so you can do this on a system with other QGISes installed as well)

Posted in C++, GIS, Programming, Python, QGIS

Prepare your plugins for QGIS 3

QGIS 3 is not yet there and there is still plenty of time to prepare and migrate.

But I thought I would give some advice about things that you can keep in mind while working on your plugins to make your life easier when you will have to actually do the migration. It’s mostly about making your code prepared for Python 3 and PyQt5.

Do not use star imports

Don’t do

some things have been been moved between different modules and it is easier to rewrite the code if it is known, where classes come from. So instead do

IDE’s make this task easier.

Only cast to string where required

One of the things that changed between Python 2 and Python 3 is the handling of strings. Most notably the change in semantics of the type  str . In Python 3 a  str is a string. In Python 2 it is not, instead it is an array of bytes, a real string in Python 2 is unicode , the two things can often be used interchangeably, but no longer when you want to handle special characters like ä, ñ or even more modern characters like ✓ (you didn’t know that this is a character? It actually is part of modern character sets). In Python 3 there is also a pure array of bytes. It’s called  bytes .

If you want to get too much trouble, don’t do any unrequired extra conversions to  unicode or  str . Often python converts things automatically for you and you don’t need to be explicit about it.

If you know a text will be in a variable

instead of

use

 

There will still be situations where you need to be explicit, but in such cases you will get exceptions that tell you about it.

Write unit tests

If you already have a good code coverage of unit tests you are in a comfortable position. Because you can easily try different tools that help to migrate the code and test the resulting code by running the unit tests in a PyQt5/Python 3 version of QGIS. This makes trial and error much, much faster than manually testing through the whole plugin again and again and again.

You will even be able to run the tests on a Python 2 and a Python 3 version of QGIS and maintain a plugin that is compatible with the old and the new world.

Read more about conversion from Python2 to Python3

http://python3porting.com/noconv.html and google for it. While reading it, forget about any python version <2.7 or 3.0 – 3.3. These versions are outdated, need not be supported and just make a developers life harder.

 

Posted in Uncategorized

Increasing the stability of processing algorithms

Processing just got a new testing framework to improve the long-term stability of this important plugin. And you can help to improve it, even if you are not a software developer!

This is yet another piece in our never-stopping crusade to improve the stability and quality of the best desktop GIS on the market.

Processing

You probably know processing. If you don’t: processing is the number one plugin to enable after every QGIS installation. It offers a very wide variety of geo-algorithms from generic one to very task-specific tools and allows building models and to completely automate workflows this way.

Processing is being improved consistently and gets better with every release. But like always in software development, there is a risk, that an improvement can have undesired side-effects which break previously working parts of an application.

Unit Testing and Continuous Integration

A bit more over a year ago (when working still as a freelancer) I started a crowdfunding initiative for automated testing, a technique in software engineering also known as continuous integration. With every single change a developer does to an application, a number of functions – so called unit tests – are run and their outcome is compared to a known-good control dataset. This way side-effects can be detected early on and fixed before they get deployed to productive environments.

This has been an amazing story of success. Since it has been put into place a lot of new unit tests have been added to a lot of QGIS functionality. A lot of bugs have been discovered by some servers that consistently test all the cool new stuff that comes in. Meanwhile we arrived at a point where we even test meta-quality of our codebase that makes the life for plugin developers easier: are new functions available from python? And do they come with documentation?

pr

However, until now processing was excluded from these checks. But no longer.

To demonstrate the importance of this, take the intersection algorithm. Some months ago it started to fail in certain scenarios, caused by an update on the geometry engine. A totally unrelated change suddenly made the intersection algorithm behave differently. It just produced faulty results. The only thing was a small warning in the message log, a well-hidden place where you normally don’t check for warnings.

A small numbers of tests are already in place and make sure that the following algorithms run properly:

  • Centroid
  • Delete Holes
  • Intersection
  • Densify
  • Polygons to lines

If these unit tests had already been in place, this problem would have triggered an alarm right away. No longer, as of now, at least this same problem will not happen again!

But as you can see, there is only a small number of all the algorithms in processing being tested right now. Is your favorite one not yet included? That’s where you come in. That’s where the whole community of QGIS can help to make QGIS incredibly rock-freakin’-solid!

Help making it better

The tests are based on a very simple infrastructure.

  • A number of test datasets against which an algorithm can be run (e.g. intersection)
  • A simple description of which algorithm to run with which parameters (e.g. the layers polys.gml and multipolys.gml)
  • An expected result dataset (what you produce)

The first piece is already in place. The test datasets have been carefully developed to contain all kind of different geometries and attributes. This ensures that the tested algorithms are robust against all kind of side-effects.

Creating the other pieces couldn’t be easier

  1. Make sure you have a copy of the QGIS git repository.
  2. Choose an algorithm to test. Check the algorithm_test.yaml file that it’s not yet in place.
  3. Open a test dataset in your local QGIS copy: python/plugins/processing/tests/testdata
  4. Run the algorithm and redirect the result to  python/plugins/processing/tests/testdata/expected . Preferably in gml format.
  5. Manually check, that the result you receive is correct and that there have been no errors. This step is important!
  6. Open the Processing menu entry History.
  7. Right click the entry and click on Create Test.
  8. You will see a yaml specification that describes your algorithm. If it looks good, copy it to the end of python/plugins/processing/tests/testdata/algorithm_test.yaml .
  9. Request that your test is integrated. It will automatically be run on our test infrastructure. If it is good, it should be integrated shortly.

test-generator

What has been done

As a by-product of this development, a couple of things have been developed and fixed.

  • Implementation of a qgis.testing  python module. This comes with some nice pieces which can be used by every python plugin for creating its own unit tests. It comes with a mock iface and a method to compare vector layers with control over attribute and geometry comparison.
  • Too many copies of a mock iface are already floating around in different plugin projects. Help making this one the best and only one!
  • Several fuzzy comparison options have been implemented (epsilon for geometries coords, epsilon for attributes…).
  • QgsVectorFileWriter is now able to produce geometry collections as output. While we cannot represent them in QGIS, a processing algorithm can now create such an output (a number of file formats support this. Shapefiles don’t.).
  • A crash has been fixed that surfaced when running certain algorithms with null geometries.
  • Some improvements have been brought to gdal, mostly concerning the geojson driver

 

Thank you Victor Olaya, Michael Kirk, Alex Bruy, Martin Dobias

Tagged with: , , , ,
Posted in C++, Programming, Python, QGIS, QGIS Plugins

Geometry generator symbology

difference(buffer($geometry, 250), buffer($geometry, -250))

December traditionally is an amazing time since the weather is usually quite forgiving to long working hours.

Therefore the first parts of our recent crowdfunding project for 2.5D rendering have been merged into QGIS master and will be shipped with QGIS 2.14.

It’s something of the sort of development that we really, really, really like here at OPENGIS.ch: an implementation that adds enormous flexibility and enables the user to use QGIS in ways that we never thought of.

Say hello to geometry generators.

Geometry generators allow to use expression syntax to generate a geometry on the fly during the rendering process. The resulting geometry does not have to match with the original geometry type and you can add several differently modified symbol layers on top of each other.

Examples

 

How to use it

It couldn’t be easier to  use. Open the symbology dialog. Choose geometry generator as symbol layer type. Choose what kind of symbol you would like to generate, write your expression and style it in whatever way you like.

Configuration Dialog

 

It’s your turn

Show the world what you can do with it.

Thanks

  • ADUGA
  • Regional Council of Picardy
  • Ville de Nyon
  • Wetu GIT cc
  • All other crowdfunders

Special thanks to Nicolas Rochard and  for the help to bring this project into shape. And to Nyall Dawson for his invaluable inputs throughout the planning and reviewing process.

 

Tagged with: , ,
Posted in Featured, QGIS

QField Documentation

After getting QField up and running in Android 5, we felt it was time to start documenting how QField works, we started documenting how to install and use QField. We also added a section on how to handle your data to get them on QField. It is all pretty basic, but it dose give some hints.

You can find the documentation here: http://qfield.opengis.ch/docs/

As QField’s source code the docs are opensourced (on github) and we look forward for your help in documenting and translating.

Thanks a lot

Posted in Uncategorized

Passing android Intents to Qt

Working on QField I had the necessity of passing values from the QtActivity.java to the Qt cpp world, here how I did it using an Intent that is sent to the QtActivity (the one you should not edit that comes with Qt). For much more information see this post series.
hopefully this will be helpful to someone.

This is the first version of the cpp code that I wrote, just for reference. The above code is much cleaner

Posted in Android, C++

QField for Android 5

Screenshot_2015-12-01-14-17-16
QField app on Google Play

QField app

QField Karma edition app on Google Play

QField Karma edition app

It’s done, finally we managed to get rid of Ministro so that we finally can say, QField runs on any android from 4.0.3 (ICS). This makes as of today (according to google) 96% of the android installations worldwide. Eventually we want to settle to 4.3 (JB) as minimum to allow us using certain features and avoiding one known issue, but for now it would mean cutting of another 25% of the users.

So as of today it is: 4.0.3 (Ice cream sandwich API 15) is the required minimal Android version to run QField and Android 4.3 (Jelly Bean API 18) is the suggested minimal version.

We tested with 4.4, 5.0.1 and 5.1 but we haven’t had the chance to get our hands on an Android 6 so if you can, let us know how it works.

But adding support for android 5 isn’t the only great news, during the process we also:

  • Reintroduced WMS support
  • Removed ministro dependency. All libs are now bundled so that the installation is as simple as possible
  • Drastically reduced total download size from 300MB+ to 36MB
  • Updated libs to QGIS 2.13 (https://github.com/qgis/QGIS/commit/6b3eddd)

We would like to thank to the City of Vevey and the QGIS hack fest Gran Canaria for supporting the development of this critical feature.

QField is an Open Source project led by OPENGIS.ch LLC, more information, the source code and a possibility to donate to the project can be found on the QField page (preferred) or by buying the QField for QGIS Karma edition app.

Also if you need a specific feature, contact us to sponsor its development.

Tagged with: , , ,
Posted in Featured, QField

QGIS Crowdfunding: 2.5D Rendering

title

QGIS has a great variety of rendering possibilities from categorization to data defined settings which allows to make awesome cartographic products. It also features some extensions like qgis2threejs and globe that make it possible to explore the third dimension. While these extensions are great tools they have their limitations like they do not fully integrate with the styling system or cannot be used in print composers.

2.5D rendering

Mockup of a possible rendering result with a combination of classify and 2.5D effect

This project aims to improve the internal possibilities of QGIS to give an oblique view 3D effect based on a height attribute and an angle while fully preserving all the possibilities which the QGIS styling offers. But it doesn’t stop there, the whole rendering is built in a modular way so you can use all of its parts for countless other possibilities.

Funds are already available for a major part of this project thanks to ADUGA and the Regional Council of Picardy. For the missing pieces we would like to ask the community to help us to create the required extensions to include these amazing new functionalities into QGIS.

Geometry modifiers

Every building exists of the parts: floor, walls and roof. To get a nice effect can paint a shadow on the floor, then draw the walls for the buildings and finally paint the roof.

The wall as well as the roof geometries are nothing but modified versions of the source geometry. The roof is a translated version of it, the walls a 2 dimensional extrusion (the area between footprint and translated roof outline).

A new possibility to define a geometry modifier will be introduced. For every symbol layer in the layer styling it will be possible to define an expression that transforms the geometry before it is being painted.

Rendering order

Because buildings which are further apart from the camera need to be painted first and buildings closest to the camera last it is required that we can control the order in which features are rendered. It will be possible to define an expression (or simply a field) in which features are rendered. For this use-case this will be based on the geometry but you may use this to control the rendering order of any kind of layer. Or if you are a plugin author you can just send any feature request with an order by to the layer.

It is planned that for best compatibility this will be implemented in a provider independent way. Due to performance considerations we plan to add the possibility to delegate this job to the database in the future and will keep this in mind during the implementation.

Expressions

A series of expressions will need to be developed

Translation of a geometry

Extrusion of a 2D geometry

Evaluation of a string as expression

Degrees to radians

Extract the individual points of a linestring

Azimuth of a line segment

Order a multipolygon by centroid (to render the walls of a building in the appropriate sequence)

Style variables

To make it easy to configure the style a new possibility to assign style variables will be introduced. This will make it possible to specify an expression which will define the height of individual buildings one single time on the style dialog and then reference and use this variable from various places within the rendering system.

Detailed specification

We have written a document that contains more detailed specifications for the individual parts. If you would like to get access to this, please contact us and we will send you a digital copy of it.

Tagged with: , ,
Posted in 3D, C++, Featured, QGIS

test

Tagged with: ,
Posted in Uncategorized

SpaceMouse in Ubuntu 15.04

While preparing some 3D scenes for an exibition I discovered the SpaceMouse by 3dconnexion. A neat device we plan on installing in front of a projected globe.

To get it to run in Ubuntu first get the drivers from www.3dconnexion.eu/service/drivers.html

then

sudo apt-get install libmotif3
mkdir -p /tmp/3D3dxware-linux
cd /tmp/3D3dxware-linux
cp ~/Downloads/3dxware-linux-v1-8-0.x86_64.tar.gz /tmp/3D3dxware-linux
tar -xf 3dxware-linux-v1-8-0.x86_64.tar.gz
sudo ./install-3dxunix.sh

answer yes, 4, yes.
That’s it, you might get an error saying: “Red Hat EL 7 currently not supported for automatic driver startup.”. This is not a big deal as we can start the daemon by doing:

sudo /etc/3DxWare/daemon/3dxsrv -d usb &

to test if all works, launch

/tmp/xcube

I’ll play around more to see how it goes.

For further, a bit older information, see this post

Posted in 3D, tech toys