If you’ve been following our latest updates, you’ll be well aware that North Road and Faunalia are running a crowd funding campaign to add rich charting and graph functionality to QGIS’ Print Layout designer. This missing feature is a large gap in QGIS printing capabilities, so we’re planning on filling that gap by exposing the powerful QGIS “Data Plotly” plugin to allow these charts to be embedded inside your layouts, and allow them to be created and modified in a simple, interactive style. And thanks to a large group of generous backers, the campaign is off to a fantastic start!

Accordingly, we’d like to take the opportunity to showcase some of the current plot styles available from the QGIS DataPlotly plugin, all of which will be possible to insert into your print layouts if the campaign is successful. Let’s start with the default chart option – a simple scatter plot:

In this screenshot we see a scatter plot of Educational Usage vs Distance from City for a network of railway stations. We’ve left most settings at their default in order to illustrate that even out-of-the-box, the charts look great! They’ll fit right alongside your map masterpieces in your print layouts and won’t look out of place. It’s also important to note that the above screenshot demonstrates the current interactive canvas mode for the DataPlotly plugin. If this campaign is successful, the chart designer shown above will be available directly inside the QGIS Print Layout designer window. Users will be able to drop new charts into their layouts, and then edit the properties of those charts in a interactive manner. Exciting stuff indeed!

So what other plot styles are currently available in DataPlotly? Here’s a quick showcase of what’s hopefully in the future for QGIS’ print layouts…

Box plots

Bar plot

Histograms

Pie Charts

2D Histogram

Polar Plots

Ternary Plots

Contour Plots

Violin Plots

These plots can already be created from your map canvas using the version of DataPlotly available from the standard QGIS plugin repository, so we encourage you to download the plugin and have a play, and start to get a feel for the flexibility and power having access to these charting options will bring to your print layouts!

You can help make this feature a reality by supporting the campaign or by sharing the page and increasing exposure to the campaign. Full details about the planned functionality and how to contribute are available at the campaign page.

We are pleased to announce the first public release of Input. Input is a Free and Open Source mobile application built on top of QGIS.

Why Input?

Collecting data is often an essential part of a geo-data management workflow. The problems we have tried to resolve with Input:

• A mobile app: to collect the data. The app has an intuitive interface. Similar to Google Maps, you don’t need to read a whole bunch of documentation to be able to use the app.

• Data synchronisation: a collaborative way of managing the data. We provide Mergin, a central storage, where data administrators can upload their data/projects for their users to change in the field. Changes made to the data through Input will be tracked and can be uploaded to Mergin. Likewise, data administrators can propagate changes to their users by updating the files on Mergin.

How to use Input?

You can set up your projects in QGIS. Input is based on QGIS, so it can read all data and services (e.g. Shapefile, Geopackage, TIF, WMS, XYZ tiles, WFS, etc) available in QGIS.

You can customise your forms and identify panel for the layers to be surveyed. Input uses Display tags and Map Themes to better view the data. For more information, see QGIS project configuration of the user documentations.

You can then upload your data and projects to Mergin and share them with your users. Permissions to users to read/write the project can be granted through Mergin.

Input can be installed from Google Play Store. Users will be able to log in to the their Mergin account and download the projects.

Within the app, users can capture geometries (e.g. points, lines and polygons). Capturing of data can be free-hand, or it can be achieved by streaming the GPS locations and generating vertices.

Forms can be easily edited based on the widgets users have set up in the QGIS project. For example, you can add photos, notes, dates, etc to the digitised features.

Input keeps track of changes and you can upload the changes back to Mergin from within the app.

Feedback

If you’d like to use Input and Mergin within your enterprise environment, please contact us so that we can provide you with a dedicated hosting and no data limit.

We are pleased to announce the release of QGIS 3.6 ‘Noosa’! Noosa was the location of a local Australian developer meeting in autumn 2017.

Installers for all supported operating systems are already out. QGIS 3.6 comes with tons of new features, as you can see in our visual changelog.

We would like to thank the developers, documenters, testers and all the many folks out there who volunteer their time and effort (or fund people to do so). From the QGIS community we hope you enjoy this release! If you wish to donate time, money or otherwise get involved in making QGIS more awesome, please wander along to qgis.org and lend a hand!

QGIS is supported by donors and sustaining members. A current list of donors who have made financial contributions large and small to the project can be seen on our donors list. If you would like to become a sustaining member, please visit our page for sustaining members for details. Your support helps us fund our six monthly developer meetings, maintain project infrastructure and fund bug fixing efforts.

QGIS is Free software and you are under no obligation to pay anything to use it – in fact we want to encourage people far and wide to use it regardless of what your financial or social status is – we believe empowering people with spatial decision making tools will result in a better society for all of humanity.

Ever wished QGIS had a way to insert dynamic, feature rich charts and graphs directly inside print layouts? If so, our latest crowdfunding campaign has you covered! This missing feature is a large gap in QGIS printing capabilities, so we’re planning on filling that gap by exposing the powerful QGIS “Data Plotly” plugin to allow these charts to be embedded inside your layouts, and allow them to be created and modified in a simple, interactive style.

If you’re not aware of the existing capabilities of the DataPlotly plugin, here’s a quick screencast which should get you excited about the possibilities here…

QGIS is already a reporting powerhouse, and we believe that linking DataPlotly with QGIS print layouts will boost the current functionality up an order of magnitude! To make it possible we need 8600€ pledged before 30 April 2019. North Road is collaborating on this campaign with our friends at Faunalia, and development work will be shared between the two consultancy firms.

You can help make this a reality by supporting the campaign or by sharing the page and increasing exposure to the campaign. Full details about the planned functionality and how to contribute are available at the campaign page.

On behalf of QGIS.ORG and the whole community, I’m would like to extend our thanks and congratulations to all the local volunteers who helped to make the event happen, with special thanks to Luigi “Ginetto” Pirelli, who spearheaded the effort. The event, which included a full week of workshops, a user conference, and contributor meeting, marked another milestone in the history of QGIS.

It was possibly the largest meeting we have had to date. It especially gratifying seeing more diversity and new faces. Our inclusive and welcoming community has always been a point of pride and it was amazing seeing how newcomers easily and pleasantly integrating in the community, producing good and tangible results within just a few days.

Many decisions were made, many discussions were fruitfully concluded, many tortillas were eaten, plans were laid out. These events are critical for preparing the way for the future of the QGIS.ORG project.

Our heartfelt thanks to all who donated their time and intellect, and to the many donors and sponsors to make all this possible.

See you in Bucharest next August, for the 23rd QGIS meeting!

QGIS.ORG

QGIS 3.4 has recently become our new Long Term Release  (LTR) version. This is a major step in our history – a long term release version based on the massive updates, library upgrades and improvements that we carried out in the course of the 2.x to 3x upgrade cycle.

We strongly encourage all users who are currently using QGIS 2.18 LTR  as their preferred QGIS release to migrate to QGIS 3.4. This new LTR version will receive regular bugfixes for at least one year. It also includes hundreds of new functions, usability improvements, bugfixes, and other goodies. See the relevant changelogs for a good sampling of all the new features that have gone into version 3.4

• QGIS 3.0 Changelog
• QGIS 3.2 Changelog
• QGIS 3.4 Changelog

Most plugins have been either migrated or incorporated into the core QGIS code base.

We strongly discourage the continued use of QGIS 2.18 LTR as it is now officially unsupported, which means we’ll not provide any bug fix releases for it.

You should also note that we intend to close all bug tickets referring to the now obsolete LTR version. Original reporters will receive a notification of the ticket closure and are encouraged to check whether the issue persists in the new LTR, in which case they should reopen the ticket.

If you would like to better understand the QGIS release roadmap, check out our roadmap page! It outlines the schedule for upcoming releases and will help you plan your deployment of QGIS into an operational environment.

The development of QGIS 3.4 LTR has been made possible by the work of hundreds of volunteers, by the investments of companies, professionals, and administrations, and by continuous donations and financial support from many of you. We sincerely thank you all and encourage you to collaborate and support the project even more, for the long term improvement and sustainability of the QGIS project.

PyQGIS scripts are great to automate spatial processing workflows. It’s easy to run these scripts inside QGIS but it can be even more convenient to run PyQGIS scripts without even having to launch QGIS. To create a so-called “stand-alone” PyQGIS script, there are a few things that need to be taken care of. The following steps show how to set up PyCharm for stand-alone PyQGIS development on Windows10 with OSGeo4W.

An essential first step is to ensure that all environment variables are set correctly. The most reliable approach is to go to C:\OSGeo4W64\bin (or wherever OSGeo4W is installed on your machine), make a copy of qgis-dev-g7.bat (or any other QGIS version that you have installed) and rename it to pycharm.bat:

Instead of launching QGIS, we want that pycharm.bat launches PyCharm. Therefore, we edit the final line in the .bat file to start pycharm64.exe:

In PyCharm itself, the main task to finish our setup is configuring the project interpreter:

First, we add a new “system interpreter” for Python 3.7 using the corresponding OSGeo4W Python installation.

To finish the interpreter config, we need to add two additional paths pointing to QGIS\python and QGIS\python\plugins:

That’s it! Now we can start developing our stand-alone PyQGIS script.

The following example shows the necessary steps, particularly:

1. Initializing QGIS
2. Initializing Processing
3. Running a Processing algorithm

import sys

from qgis.core import QgsApplication, QgsProcessingFeedback
from qgis.analysis import QgsNativeAlgorithms

QgsApplication.setPrefixPath(r'C:\OSGeo4W64\apps\qgis-dev', True)
qgs = QgsApplication([], False)
qgs.initQgis()

# Add the path to processing so we can import it next
sys.path.append(r'C:\OSGeo4W64\apps\qgis-dev\python\plugins')
# Imports usually should be at the top of a script but this unconventional 
# order is necessary here because QGIS has to be initialized first
import processing
from processing.core.Processing import Processing

Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
feedback = QgsProcessingFeedback()

rivers = r'D:\Documents\Geodata\NaturalEarthData\Natural_Earth_quick_start\10m_physical\ne_10m_rivers_lake_centerlines.shp'
output = r'D:\Documents\Geodata\temp\danube3.shp'
expression = "name LIKE '%Danube%'"

danube = processing.run(
    'native:extractbyexpression',
    {'INPUT': rivers, 'EXPRESSION': expression, 'OUTPUT': output},
    feedback=feedback
    )['OUTPUT']

print(danube)

When QGIS 3.0 was release, I published a Processing script template for QGIS3. While the script template is nicely pythonic, it’s also pretty long and daunting for non-programmers. This fact didn’t go unnoticed and Nathan Woodrow in particular started to work on a QGIS enhancement proposal to improve the situation and make writing Processing scripts easier, while – at the same time – keeping in line with common Python styles.

While the previous template had 57 lines of code, the new template only has 26 lines – 50% less code, same functionality! (Actually, this template provides more functionality since it also tracks progress and ensures that the algorithm can be cancelled.)

from qgis.processing import alg
from qgis.core import QgsFeature, QgsFeatureSink

@alg(name="ex_new", label=alg.tr("Example script (new style)"), group="examplescripts", group_label=alg.tr("Example Scripts"))
@alg.input(type=alg.SOURCE, name="INPUT", label="Input layer")
@alg.input(type=alg.SINK, name="OUTPUT", label="Output layer")
def testalg(instance, parameters, context, feedback, inputs):
    """
    Description goes here. (Don't delete this! Removing this comment will cause errors.)
    """
    source = instance.parameterAsSource(parameters, "INPUT", context)

    (sink, dest_id) = instance.parameterAsSink(
        parameters, "OUTPUT", context,
        source.fields(), source.wkbType(), source.sourceCrs())

    total = 100.0 / source.featureCount() if source.featureCount() else 0
    features = source.getFeatures()
    for current, feature in enumerate(features):
        if feedback.isCanceled():
            break
        out_feature = QgsFeature(feature)
        sink.addFeature(out_feature, QgsFeatureSink.FastInsert)
        feedback.setProgress(int(current * total))

    return {"OUTPUT": dest_id}

The key improvement are the new decorators that turn an ordinary function (such as testalg in the template) into a Processing algorithm. Decorators start with @ and are written above a function definition. The @alg decorator declares that the following function is a Processing algorithm, defines its name and assigns it to an algorithm group. The @alg.input decorator creates an input parameter for the algorithm. Similarly, there is a @alg.output decorator for output parameters.

For a longer example script, check out the original QGIS enhancement proposal thread!

For now, this new way of writing Processing scripts is only supported by QGIS 3.6 but there are plans to back-port this improvement to 3.4 once it is more mature. So give it a try and report back!

Sorry, this entry is only available in Dutch.

Following our crowdfunding campaign, we are pleased to announce the completion of QGIS packages for macOS.

Thanks to the response from the QGIS community, we have finalised the packages, ready for your day-to-day use. Below are the list of improvements we have carried out:

• Support for Processing tools:
  • GRASS (7.6): most algorithms work but there are still some reliant on Python 2.x. This issue will be resolved with the release of GRASS 7.8
  • SAGA and GDAL/OGR: all algorithms work
• Extra Python modules: similar to OSGeo4W, common Python modules are now shipped with the packages.
• Support for ECW and MrSid raster formats
• Support for dark theme

The main benefits of the packages:

• Built with Apple Developers Certificate
• Availability of QGIS nightly (master)
• Automatic packaging
• Use of the latest libraries (Proj, GDAL, etc)

Unfortunately, we did not raise enough funds to resolve issues with macOS 10.11 and 10.12. Python (and hence plugins) are not supported for those OSes. In addition, it was not possible to polish the code and move the infrastructure to QGIS.org.

Supporters of our campaign

Our work was made possible with the help of the supporters of our campaign. Below is the list of individuals and organisations who supported this campaign:

• Ujaval Gandhi
• Loïc Ségalou
• Fletcher Applied Sciences, Inc
• Auspatious
• Gecosistema SRL
• Farallon Geographics
• L - P : Archaeology
• 3D geoinformation group, TU Delft
• Henry Walshaw
• Joe Tennis
• Nathaniel Vaughn KELSO
• Geobits Ltd
• Hillcrest Geographics
• Larry Spencer
• Malte Pill
• John Steggall
• Spatial Networks
• Dogwood Geospatial
• Hugh Saalmans
• Ryan Cooper
• QGIS Usergroup Denmark
• LuminFire

In addition, there were individuals who donated directly to QGIS.org for this work.

You may also like...

Mergin Maps, a field data collection app based on QGIS. Mergin Maps makes field work easy with its simple interface and cloud-based sync. Available on Android, iOS and Windows.

Around 2014/2015 Martin updated the whole Legend / Layermanager code in QGIS. He wrote some nice blogs about this new “Layer Tree API”: Part 1, Part 2 and Part 3 so people would better understand how “to talk PyQGIS to the Legend”. In 2016 Martin merged some code on top of this, which would make … Continue reading About Layer tree embedded widgets and have your WM(T)S always crispy sharp

Gary Sherman has a wide and varied background, including that of geologist, mining engineer, software engineer, publisher, and author. He has authored both technical books and articles, as well as fiction. In 2002, he founded the popular open source QGIS project and has published several books on the topic. For eight years, Gary was at the helm of Locate Press, publisher of books on open source software. Gary has published a number of novels as G.

We end our series with a somewhat trivial, though interesting addition to our map and a special offer. Leaflet allows you to add an image that spans a specified region on the map. Here we add a picture of a little lost moose to the map. In this instance, it serves no purpose other than to show we can do it. The JavaScript code needed is: var imageUrl = "/images/calf_moose.png"; bounds = thetrail.

Today we’ll take a look at another plugin—one that allows us to interactively change they style of features on our map: Leaflet.StyleEditor. This illustrates how we can customize our map by changing styles on the fly and also serves as a starting point for even more customization. Installing and Referencing the Plugin The web page for the plugin provides information on installing it. This requires getting the css, js, and image files in the proper location, then referencing them in our HTML file:

Today we’ll use the qgis2web plugin to export from QGIS to Leaflet. The QGIS project, a location map for the third (in progress) Life on the Alaska Frontier novel, looks like this: Installing qgis2web The qgis2web plugin is installed like any other. Click on the Plugins->Manage and Install Plugins... menu item, click Not installed, and then find qgis2web in the list. Click the Install plugin button to complete the install.

At its core, Leaflet is designed to be lightweight. That being said, there are hundreds of third-party plugins available to extend and enhance the functionality of your web maps. Today we’ll illustrate adding a plugin to our map from Day 6. The L.Control.ZoomBar plugin adds a custom zoom control that allows us to draw a box around the area we want to zoom to, as well as adding a Home button to return to the initial map view.

In this post we’ll add a link to the towns popup that will display the satellite view on Google Maps. The API for working with Google Maps URLs can be found here: https://developers.google.com/maps/documentation/urls/guide. To add a link to the town name in the popup, we modify the JavaScript code that creates the towns layer: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 var towns = L.

Dear QGIS Community

Our first three rounds of Grant Proposals were a great success. We are very pleased to announce the fourth round of grants is now available to QGIS contributors.

Based on community feedback, this year, we will not accept proposals for the development of new features. Instead proposals should focus on infrastructure improvements and polishing of existing features.

The deadline for this round is Sunday, 2 June 2019. All the details for the grants are described in the application form, and for more context we encourage you to also read last year’s articles:

• QGIS Grants #3: Call for Grant Proposals 2018
• QGIS Grant Programme 2018 Results

We look forward to seeing all your great ideas about how to improve QGIS!

Anita Graser

QGIS PSC

In January, we wanted to learn more about if and how QGIS users contribute back to the project. We received 299 responses from all over the world:

55% of responders have contributed to the project in the past:

Responders who stated that they had contributed to QGIS were asked to specify what kind of contributions they had provided. This question was multiple-choice. Time contributions are generally more common than financial contributions. 30% of responders helped by creating reproducible bug reports and 24% implemented improvements themselves. The most common financial contribution are personal donations to QGIS.ORG at 17%.

Membership in user groups, contracting developers / documentation writers / translators, or having a support contract with a QGIS support provider are less common amongst responders:

Responders who stated that they had not contributed to QGIS most commonly stated that they didn’t know how to contribute (26%), while lacking financial resources were only raised by 10% of responders:

New question

This month, we’d like to know which plugins you think should be advertised as “featured” on the official QGIS plugin repository.

The survey is available in English, Spanish, Portuguese, French, Italian, Ukrainian, Danish, and Japanese. If you want to help us translate user questions in more languages, please get in touch!

Sorry, this entry is only available in French.