QGIS2 compatibility plugin

Lately I’ve been spending time porting a bigger plugin from QGIS 2.8 to 3 while maintaining 2.8 compatibility.
You can find it at https://github.com/opengisch/qgis2compat/
and http://plugins.qgis.org/plugins/qgis2compat/

One code to rule them all.

My target was to have to edit the source code as little as possible to simulate a lazy or busy coder that has to upgrade his/her plugins.

Lots of work has already gone into 2.14 to support PyQt 4 and 5 with the same code (Kudos to jef-n and mkuhn).

The qgis python package will then use the appropriate PyQt for you. But not all can be fixed in QGIS itself and this is why QGIS2compat can help you.

Use cases

QGIS2compat targets two main use cases.

PyQt compat

If you still need to rely on QGIS < 2.14 writing from qgis.PyQt will not work for you as the qgis.PyQt package is simply not there. And this is one of the two use case where QGIS2compat can help you. This feature is complete.

QGIS 2-3 API compatibility

The other use case of QGIS2compat plugin is the availability of a QGIS API compatibility layer which lets you write your code for QGIS 3 API and it will take care of adapting it to the QGIS 2 API. This feature is an ongoing work in progress since we are in the middle of API breakage period. So we do need your help to keeping adding new apicompat fixes (see below).

Usage

In your plugin’s __init__.py you should put something like the example
below. This will pick the QGIS PyQt compatibility layer which is
available since QGIS 2.14 or fall back to qgis2compat.

Also if you are in QGIS >= 2.14 and QGIS < 3 it will run the apicompat
package which will take care of the Python api changes between QGIS 2
and QGIS 3.

in each module where you do PyQt imports you should use the following
structure.

This will guarantee that the imports come from the most appropriate and
up-to-date place and gives you PyQt4 and PyQt5 support for QGIS >= 2.8.

Updating your plugin

This can be done automatically by the 2to3 tool included in QGIS sourcecode.
Please note that it is not the plain 2to3 python tool and can be found
at https://github.com/qgis/QGIS/blob/master/scripts/2to3
This tool will fix many (probably not all) issues with your code and make it
compatible with Python 3.

After running 2to3, update your __init__.py as explained above.

once done, it is time to run your tests (which you of course have written
before migrating) and fix the minor glitches that might have appeared.

Adding new apicompat fixes

To add a new api compatibility fix, just create (or add to an existing one) a
new module in apicompat and import it in __init__.py__ like it is done for
the qgsvectorlayer.py

As QGIS2compat works on a fairly low level, we require unit tests for each
fix to be included in each pull request.

Need professional help?

OPENGIS.ch can help you updating all your plugins and with any QGIS related problem you have. Contact us for a quote

Posted in PyQt, QGIS, QGIS Plugins, Uncategorized

Updating PyQt signals that use lambda in QGIS with 2to3

Just for the sake of documenting things, when running qgis 2to3 on a plugin I encountered a tricky situation regarding signals.

The original code:

The generated code:

so in do_load_project we get False instead of “my test argument”, why?
well due to a subtle difference in the generated code. in the original code we had the signature triggered() which has no arguments, so in our lambda extra_arg gets passed my_arg.
in the generated code, triggered actually has an optional param checked [1] which if emitted gets passed to extra_arg causing the problem.

The correct code (note the additional argument in the lambda definition)

some reference:
[0] http://pyqt.sourceforge.net/Docs/PyQt5/signals_slots.html
[1] http://doc.qt.io/qt-4.8/qaction.html#triggered

Posted in PyQt, QGIS Plugins

Using threads in QGIS python plugins

I really wanted to write this post since a long time but things got in the way, and now an email finally triggered me.

As part of a consultancy I got to work with threads in a python plugin for QGIS. Since it was a pretty tedious process, I decided to write  the whole thing fairly generic so that it could be used easily by others.

Before using this, please note that there are ongoing efforts to get something like this directly in QGIS 3.

The code below (or maybe a more recent version – the one posted here is 1da300f from May 6, 2015) can be found on github

The usage is pretty self explanatory but it goes like this. You create your worker class that inherits from AbstractWorker and implement the work method:

in your code you import all the needed modules and functions and call your ExampleWorker like this:

here, for reference, the whole code

Hope this could help you, if you need professional help don’t hesitate contacting us

Posted in Python, QGIS, QGIS Plugins

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