Planet Georezo » Autres planets

Un Planet est un site Web dynamique qui agrÃ¨ge le plus souvent sur une seule page, le contenu de notes, d'articles ou de billets publiÃ©s sur des blogs ou sites Web afin d'accentuer leur visibilitÃ© et de faire ressortir des contenus pertinents aux multiples formats (texte, audio, vidÃ©o, Podcast). C'est un agrÃ©gateur de flux RSS. Il s'apparente Ã un portail web.
Vous pouvez lire le billet sur le blog La Minute pour plus d'informations sur les RSS !

Feeds

5812 items (0 unread) in 76 feeds

Dans la presse

Du côté des éditeurs

Toile géomatique francophone

Géomatique anglophone

Blogs GeoRezo.net

Autres planets

Planet OSGeo

Abonnez vous à cette page (RSS) !

Autres planets

Skip to page: 1 2 3 ... 14

23 September 2021
19:46
gvSIG Team: Las 17as Jornadas Internacionales gvSIG cambian a modalidad online
sur Planet OSGeo

Debido a las restricciones existentes en la movilidad entre países actualmente, las 17as Jornadas Internacionales gvSIG serán finalmente un evento online.

Por este motivo, el periodo de envío de comunicaciones se amplía hasta el 20 de octubre para que las personas que no podían estar presentes y deseen realizar una ponencia puedan presentar sus propuestas. Así mismo, el periodo de inscripción de las Jornadas Internacionales gvSIG comenzará finalmente el 27 de octubre, con la publicación del programa.

Toda la información sobre las normas para la presentación de comunicaciones puede consultarse en el apartado ‘Comunicaciones‘ de la web de las jornadas.
19:43
gvSIG Team: 17th International gvSIG Conference will finally become an online event
sur Planet OSGeo

Due to current restrictions on mobility between countries, the 17th gvSIG International Conference will finally be an online event.

For this reason, the period for sending communications is extended until October 20th so that people who could not be present and wish to make a presentation can present their proposals. Likewise, the registration period for the gvSIG International Conference will finally start on October 27th, when the program is published.

All the information about the rules for submitting proposals can be consulted in the “Communications” section of the conference website.
11:00
CARTO Blog: Spatial Data Science Conference '21: First Speakers Announced
sur Planet OSGeo

The 5th annual Spatial Data Science Conference is just over a month away and we are very excited to announce our first lineup of speakers! #SDSC21 will be available to the ...
10:00
CARTO Blog: Canary Islands Volcano: Mapping La Palma Lava Flow & Damage
sur Planet OSGeo

On Sunday the Cumbre Vieja volcano on La Palma in the Spanish Canary Islands started erupting causing the destruction of 300 homes and forcing the evacuation of more than 6...
9:00
MapTiler: Vector basemaps in QGIS
sur Planet OSGeo
The new version 2.0 of MapTiler QGIS Plugin was released. The first version of the plugin was written in Python and released as open-source last year. We are happy to see that our source code was ported into QGIS C++ core with some improvements.

The new version of the MapTiler plugin takes advantage of the rewritten code and pushes our maps from MapTiler Cloud almost to perfection. Our maps in Cloud contain data of the entire planet, with details down to the street level, thanks to the OpenStreetMap project and community. But you are not limited just to our Cloud.

Load these and many other map styles directly from MapTiler Cloud
Open vector tile style from any URL
MapTiler plugin is the easiest way how to add any complex vector tile map hosted anywhere on the Internet into your QGIS project. Enjoy the comfort of adding your style.json with multiple sources in just a single click.
Add context to your map with icons
Version 2.0 is packed with a lot of visual improvements. Labels, line width, color interpretation, opacity setting, and many other small enhancements make the maps better. However, the biggest improvements are map symbols. The first version suffered from a lack of possibility to display icons. The new version handles them with ease.

Let users understand your map
Having place names in a local language can significantly improve how users understand the map. Use Customize in Cloud option from the MapTiler plugin menu to choose from more than 50 languages and customize the language of the map to suit your needs.

New Outdoor style in QGIS
In MapTiler, we all are outdoor enthusiasts. That’s why we recently announced a new Outdoor map style. Hiking trails, biking routes, points of interest, landcover, hillshade, and contour lines, everything you wish for in a good outdoor map is now available in QGIS as a base map for planning your adventure.

High DPI print as the main benefit of vector maps
The previous version of the plugin brought to QGIS high-quality vector maps. However, few issues were identified when printing in high DPI or on retina displays. The new version solved all those issues and you can print maps in high resolution. Set high DPI, print or export your map to PDF, and zoom in deeply to inspect the level of sharpness. Even though our raster tiles are optimized for serving, you can never get such detail as with vectors.

We also prepared a new basemap allowing attribution-free print-out.

Keep in mind that for printing maps or exporting from MapTiler Cloud you must have a commercial plan, see terms and conditions or contact our sales.
Download/upgrade the plugin for free
Learn more about the plugin or get it by searching maptiler in the plugin service in QGIS. Installing the plugin is straightforward:
1. Open QGIS
2. Click on the menu Plugins ? Manage and Install Plugins…
3. Search for maptiler
4. Click on the Install Plugin (Reinstall, if you already have the old version installed)
5. Restart QGIS
6. Right-click on the MapTiler plugin ? Account…
7. Follow the link after Get a FREE key Now, just add the key and start loading maps.
Open-source code on GitHub
The MapTiler plugin for QGIS is released under an open-source license on GitHub. Feel free to report issues or send pull requests!

Links:
22 September 2021
11:00
CARTO Blog: Capturing the Sensitivity of National Wind Energy Potential to Local Siting Challenges
sur Planet OSGeo

Onshore wind energy is among the fastest growing utility-scale renewable energy technologies in the world. With falling costs, usage is on the rise with wind generation cap...
21 September 2021
11:00
CARTO Blog: A Look Back at 18 Months of COVID Grants & Maps
sur Planet OSGeo

18 months ago, on the same day that the World Health Organization (WHO) declared COVID-19 a pandemic, CARTO announced that it would be making its platform available for fre...
15 September 2021
18:55
Jackie Ng: Announcing: FDO Toolbox 1.5.2
sur Planet OSGeo
This release addresses 2 issues:
- The --connect-params switch of the list-connection-params command in FdoCmd is now optional. This means you can now list required connection parameters for a given FDO provider without having to establish a data store connection.
- This release contains updated FDO binaries which include the following changes:
Download
9:51
Free and Open Source GIS Ramblings: Movement data in GIS #46: trucks from space
sur Planet OSGeo

Can we reliably measure truck traffic from space? Compared to private transport, spatiotemporal data on freight transport is even harder to come by. Detecting trucks using remote sensing has been a promising lead for many years but often required access to pretty specialized sensors, such as TerraSAR-X. That is why I was really excited to read about a new approach that detects trucks in commonly available Sentinel-2 imagery developed by Henrik Fisser (Julius-Maximilians-University Würzburg, Germany). So I reached out to him to learn more about the possibilities this new technology opens up.
Vehicles are visible and detectable in Sentinel-2 data if they are large and moving fast enough (image source: ESA)
To verify his truck detection results. Henrik had already used data from truck counting stations along the German autobahn network. However, these counters are quite rare and thus cannot provide full spatial coverage. Therefore we started looking for more complete reference data. Fortunately, Nikolaus Kapser at the Austrian highway corporation ASFINAG offered his help. The Austrian autobahn toll system is gantry-based. It records when a truck passes a gantry. Using the timestamp of these truck passages and the current traffic speed, it is possible to estimate truck locations at arbitrary points in time, such as the time a Sentinel-2 image was taken. This makes it possible to assess the Sentinel-2-based truck detection along the autobahn network for complete Sentinel-2 images.

Overall, Sentinel-2-based detections tend to underestimate the number of trucks. Henrik found a strong correlation (with an average r value > 0.8) between German traffic counting stations and trucks detected by the Sentinel-2 method. These counting stations were selected for their ideal characteristics, including distance from volatile traffic situations such as a high number of highway intersections. This is very different from our comparison which covers autobahn sections in and near Vienna. We therefore expected larger detection errors. However, our new Austrian analysis reaches similar results (with r values of 0.79, 0.70, and 0.86 for three different days 2020-08-28, 2020-09-22, and 2020-11-06).

Thanks to the truck reference locations provided by ASFINAG, we were also able to analyze the spatial distribution of truck detections. We decided to compare ASFINAG data (truth) and Sentinel-2-based detections using a grid based approach with a cell size of 5×5 km. Confirming Henrik’s original results, grid cells with higher detection than ground truth values are clearly in the minority. Interestingly, many cells in Vienna (at the eastern border of the image extent) exhibit rather low relative errors compared to, for example, the cells along Westautobahn (the east-west running autobahn in the center of the image extent).

Some important remarks: The Sentinel-2-based detection method only works for large vehicles moving around 50km/h or faster. It is hence less suited to detect trucks in city traffic. Additionally, trucks in tunnel sections cannot be detected. To enable a fair comparison, we therefore flagged trucks in the ground truth dataset that were located in tunnels and excluded them from the analysis. Sentinel-2 captures the region around Vienna around 10:00 o’clock in the morning. As a result, it is not possible to assess other times of day. Finally, cloud cover will reduce the accuracy. Therefore we picked images with low reported cloud cover percentage (< 5%).

It is really exciting to finally see a truck detection method that works with readily available remote sensing data because this means that it is potentially transferable to other areas of the world where no official traffic counts are available. Furthermore, this method should be in line with data protection regulations (avoiding identification of individuals and potential reconstruction of movement trajectories) thus making it possible to use and publish the resulting data without further anonymization steps.

This post was written in collaboration with Henrik Fisser (Uni Würzburg / DLR) and Nikolaus Kasper (Asfinag MSG). Keep your eyes open for upcoming detailed publications on the Sentinel-2-based method by Henrik.

This post is part of a series. Read more about movement data in GIS.
14 September 2021
19:17
GeoTools Team: GeoTools 26-RC Release Candidate
sur Planet OSGeo

The GeoTools team is pleased to share the availability GeoTools 26-RC : geotools-26-RC-bin.zip geotools-26-RC-doc.zip geotools-26-RC-userguide.zip geotools-26-RC-project.zip This release candidate is also available from the OSGeo Maven Repository and is made in conjunction with
17:03
Even Rouault: The ultimate guide for successful contribution to open source
sur Planet OSGeo

(This is a post I started on December 2019 and didn't publish because I felt it was too negative. But recent events show that it is still a current topic, and at least this will document my own preception of things)
We have lately stumbled upon a few clumsy attempts of corporations at contributing to open source software. Needless to say this is a bumpy ride not for the faint of heart, from both side of the equation.
If you just want to stop your reading here, just remember that good old motto: When in Rome, do as the Romans do. And be prepared to become a Roman citizen.

Us, open source developers have our own hard-to-decipher customs. We pay tribute to the Allmighty Git (*), preferably his most revered (often with awe) incarnation called GitHub. You may also find followers of GitLab, gitea, gitorious.In that case, never pronounce the word 'GitHub' before them. It is also said that some might still use email patches: be sure to set a 80 character limit to lines, use LF line endings and refrain from using PNG signatures. Be sure to stay away from SourceForge followers. They will continuously impose on you advertising messages that will destroy your sanity.
You should subscribe to mailing lists. Be wary of trolls. We may occasionally engage into flame wars, generally sanctionned by motions. We are structured into groups that defer to a Project Steering Committee to decide (or not) which way to follow. Our groups regularly gather at solstice time in dark rooms for a week-long trance (note: was written pre-pandemic), known as a hackfest, hackathon or code sprint. For the tribes involved in geospatial, we have an annual Pow-Wow, called FOSS4G, during which we temporarily bury the hatchet and occasionaly thank our sponsors. You may stumble upon a C89 developer sharing a beer with a Java 11 one, or an adorer of Leaflet trying to convert a OpenLayers follower. If you want to join the Pow-Wow, remove your tie and suit, wear a t-shirt and sandals, and make sure to display a prominent "I Love Open Source" sticker on your laptop. You may also add a "I Love Shapefile" or "I Love GeoPackage" sticker, but only if you are confident to which one the group pays tribute. Failure to display the appropriate sticker will expose you to terrific insults about 10-character limits or obscure write-ahead log locking issues. If unsure, use the "I ? Shapefile" sticker.
We have taboo words. Thou Should Not Talk about business plan, intellectual property, patent portfolio, customer demand, strategy, costless SDK, CVE number, internal policy, consolidated codebases, education license fees. Planning and roadmap should also be pronounced with care, as some tribes will probably not have even the slightest idea of what you talk about.
If despite all those strange habits, you want to join with us, be prepared to follow a long and demanding initiation path. You will have to demonstrate your (possibly affected) adoration to our principles. As strange as it can be, we abhor being offered large presents that we cannot prevent ourselves from seeing as Trojan horses. You will rather have to locate a long list of problems pinned on a wall called bug tracker where each member of the community has written an issue or a wish he has. Start by the modest one that makes sense to you, solve it and offer its resolution to the Reviewer in a sufficiently argumented Pull Request. The Reviewer, which often equates to the Maintainer, will scrutinize at your gift, often at night time after Day Job. He may decide to accept it right away, or return it to you with a comment requesting a change, or just ignore it with the highest contempt. Be humble and obey to his command. You may beg for enlightenment, but never object even if you cannot make sense of his rebutal. He is the allmighty after the Allmighty. Never Rebase if asked to Merge; never Merge if asked to Rebase. Refactor when asked, but don't when not ! You should rewrite history before submitting, or maybe not. If unsure, consult Contributing.md, or be prepared that RTFM will be yelled at you (only for the tribes that don't have yet written CodeOfConduct.md). Do not even consider objecting that you have not been tasked to address his demands. You must also make sure to listen to the complaints of the Continuous Integration (CI) half-gods: the Reviewer will probably not even look at your gift until CI has expressed its satisfaction. Retry as many times as needed until they are pleased. You may attempt at submitting a RFC, but be prepared for lengthy and lively discussions. Listen, correct or you may not survive to your first "-1" spell !
We praise especially gifts that have no direct value for you: improved test suite (e.g. [https:]] ), documentation addition and fixes, answering to users on the mailing list. Only when you feel that you have built enough trust, you might try to offer your initial gift. But, even if it is accepted, the most surprising habit is that your gift will remain yours. You will have to make sure you regularly remove the dust that accumlates on it over time, so it remains constantly shiny. While removing dust on your gift, never neglect from removing it also from nearby gifts offered by others. Otherwise the Maintainer might threaten at invoking the terrible Revert incantation on you. Also consider that existing contributors to a project might see your new code, they won't have directly use of, as an extra burden to their daily tasks (studying the commit history of [https:]] , or even more crudly at [https:]] , demonstrates that)

Ready for a ride, and possibly enjoying the feeling that "our" code can also become "yours" ?

(*) some tribes, cut off from the rest of the world, are said to still pursue their adoration of more ancient divinities sometimes known as SVN or CVS. We cannot confirm and have eradicated the last remains of those old cults.
2:00
EOX' blog: EOxServer 1.0
sur Planet OSGeo

With the release of version 1.0 of the EOxServer achieved it is a good time to shed some light on this workhorse software more than ten years in active development. Even before this milestone, EOxServer was and is used in quite a number of operational deployments, most notably in the VirES line of p ...
2:00
GeoServer Team: GeoServer 2.20-RC Released
sur Planet OSGeo
We are happy to announce GeoServer 2.20-RC release candidate is available for testing. Downloads are available (zip and war) along with docs and extensions.

This is a GeoServer release candidate made in conjunction with GeoTools 26-RC and GeoWebCache 1.20-RC.
- Release candidates are a community building exercise and are not intended for production use.
- We ask the community (everyone: individuals, organizations, service providers) to download and thoroughly test this release candidate and report back.
- Testing priority is the new internationalization support
- Participating in testing release candidates is a key expectation of our open source social contract. We make an effort to thank each person who tests in our release announcement and project presentations!
- GeoServer commercial service providers are fully expected to test on behalf of their customers.
Release Candidate Testing Priorities
This is an exciting release and a lot of great new functionality has been added. We would like to ask for your assistance testing the following:
- The number one testing priority is to try out GeoServer with your data! Mass market open source thrives on having many people to review. Scientific open source like GeoServer thrives on exposure to many datasets.
- The rest of this blog post highlights new features for GeoServer 2.20, please try out these features, read the documentation links, and ask questions.
Known Issues:
- No issues reported at this time, you could be the first!
Internationalization
The leading feature for this release is the internationalization of Title, Abstract and Contact details for:
- WMS 1.1 and 1.3
- WFS 2.0
- WCS 2.0
See documentation for internationalization support and GSIP-203 proposal for details.

New feature:
- GEOS-10123 Internationalization for title and abstract
- GEOS-10207 Allow creation of internationalized raster legends
- GEOS-10190 i18n support for Contact Information
- GEOS-10185 LayerGroup legend internationalization styles returns multiple values
- GEOS-10177 Allow Default Translation
- GEOS-10129 Add language function for multilingual support in sld
Improvements and fixes:
- GEOS-10205 Layer with i18n title might appear twice in the capabilities, while being contained in a named tree
- GEOS-10204 Default locale is not being used while producing internationalized outputs in Capabilities document
- GEOS-10160 Requested Language in GetCapabilities
Modules Status Information for Extensions
Thanks to Ian for completing a [long outstanding request] [https:] to provide listing everything you have installed:
- The Server Status page now provides a complete list of the loaded modules and extensions
- This extension list can also be checked via REST API (allowing scripts to check if the functionality they require has been installed)
New Feature:
- GEOS-10067 Implement module status in extensions (GISP-143)
Improvements and fixes:
- GEOS-9967 Add Module Status implementation for CSW Extension
Updates and quality assurance
GeoServer continues to be build with the latest open source technologies:
- GeoTools 26-RC
- GeoWebCache 1.20-RC
- JAI-EXT 1.1.20
- ImageIO-EXT 1.3.10
- JTS 1.18.2
- GeoFence 3.5.0
- Flatgeobuf to 3.10.1
The team continues to work with automated code checks, gradually improving the codebase and introducing checks to ensure issues are not re-introduced over time:
- Check system.out.println and printStackTrace statements are not accidentally committed, which can add to logs
- Cognitive complexity checks, start cleaning up methods that are too complex
- Use StandardCharsets when possible, rather than String
- Avoid unnecessary object wrapper creation
- Use short arrays initializers
- Work towards consistent style with checks to avoid C style array declarations, add missing @Override annotations, and check java generics are used
This dedication helps provide confidence in the technology we publish.
WMS
Fixes and improvements:
- GEOS-4939 Coordinate system ISSUE - S-JTSK Krovak East North (EPSG: 5514) - cannot be set up
- GEOS-10032 Group Layer in Catalog Mode Hide not in capabilities when unauthenticated
- GEOS-10013 Mark invalid error while validating or saving a Style
- GEOS-9907 Enable usage of labelPoint function in GetFeatureInfo requests
- GEOS-9759 Set Response Cache Headers in LayerGroups
The following functionality has been removed:
- GEOS-10001 Remove animator and animated GIF support from WMS
  
  Use of WPS Animation process is provided as an alternative
WFS
Fixes and improvements:
- GEOS-10222 WFS CSV OutputFormat delimiter
WPS
Fixes and improvements:
- GEOS-9990 Add GUI and REST API to configure the wps-download module
- GEOS-10073 WPS animation download process should report about eventual time mis-matches
WMTS
Improvements and fixes:
- GEOS-10008 Have GeoServerTileLayer implementing TileJSONProvider
- GEOS-9971 GeoWebCache S3 plugin require AWS creds
INSPIRE Extension
New feature:
- GEOS-10124 Add Language support to INSPIRE extension
Improvements and fixes:
- GEOS-10211 Unable to pass INSPIRE validation: Version is mandatory (WMS)
- GEOS-10192 Inspire extension consistent outputResponse element
- GEOS-10141 Inspire extension better error message on language not found
- GEOS-10163 Incorrect INSPIRE namespace URI
And more!
Fixes and Improvements:
- GEOS-10092 Fix the page description of remote WMS/WMTS connection
- GEOS-10189 I18n improvement using the UTF-8 charset for Chinese translations
- GEOS-10033 Geoserver startup and shutdown shell scripts don’t handle path with spaces
- GEOS-9381 Conversion from boolean true/false in geoserver to SQL Server bit 0/1, is broken
- GEOS-9970 MapML GetFeature bug fix for CRS authority
- GEOS-10201 Geoserver fails to start on Windows 11 beta
Find out more in the release notes.
About GeoServer 2.20
Additional information on GeoServer 2.20 series:
- Internationalization of title and abstract
- Release notes (2.20-RC)
13 September 2021
15:24
Just van den Broecke: Terraform - First Steps on Hetzner Cloud
sur Planet OSGeo
I use Ansible already for years to provision server instances and for subsequent CI/CD. A recent example is the Geonovum OGC API Testbed . Here (selective) Docker Containers are automatically deployed on GitHub pushes using Ansible called from within a GitHub Workflows.

Now investigating how Terraform could play a key role in (Cloud) infrastructure management. There is a small overlap between Ansible and Terraform but that is a matter of how they are applied in concert.

Ansible is more geared towards maintaining the OS and its running components e.g. Docker Containers on VM-instances. Terraform is more geared to maintaining a Cloud infrastructure, "in the large": acquiring VM-instances, networks, DNS. If you are familiar with AWS, Google Cloud Platform, or in our case Hetzner Cloud , it is what you can do by clicking in their respective UIs or via their APIs like Hetzner's hcloud . And btw: both Ansible and Terraform are Open Source.

Quote from random web-search : "Terraform is designed to provision different infrastructure components. Ansible is a configuration-management and application-deployment tool. It means that you'll use Terraform first to create, for example, a virtual machine and then use Ansible to install necessary applications on that machine."

Both Ansible and Terraform are "declarative", i.e. configuration-based, where the configuration describes a desired state. ctions are "idempotent", i.e. the same action can be applied multiple times, but when the desired state is reached it won't have effect.

As I plan to apply Terraform in other projects as well, I took a deep dive, following hands-on tutorials from the Terraform website. In a very short time I was amazed by Terraform's power and elegance! My ultimate goal was to manage (acquire, configure, access, destroy) the lifecycle of Hetzner Cloud Virtual Machines (VMs, VPS's). This all took about less than two hours, documenting my steps along the way.

I started at the Getting Started page. While there is a lot of stuff on AWS, Terraform Cloud, I basically stuck to these four steps. You may even skip the third (GCP) step. Important is to learn the terminology and config conventions.
1. Installation
2. Using Docker Provider
3. Using GCP Provider
4. Using Hetzner Cloud Provider
  Tip: in IntelliJ IDEA install the Terraform plugin. It will recognise/help with Terraform files!
Step 1 - Installation
learn.hashicorp.com/tutorials/terraform/install-cli

On a Mac with Homebrew install the Terraform CLI:
```
1$ brew tap hashicorp/tap
2
3$ brew install hashicorp/tap/terraform
4
5$ terraform -version
6
7Terraform v1.0.2
8on darwin_amd64
```
That's it!
Step 2 - Using Docker Provider
learn.hashicorp.com/collections/terraform/docker-get-started

I started project dirs under ~/project/terraform/learn/.
```
1$ mkdir -p ~/project/terraform/learn/terraform-docker-container
```
Create a file called main.tf:
```
 1terraform {
 2  required_providers {
 3    docker = {
 4      source  = "kreuzwerker/docker"
 5      version = "~ 2.13.0"
 6    }
 7  }
 8}
 9
10provider "docker" {}
11
12resource "docker_image" "nginx" {
13  name         = "nginx:latest"
14  keep_locally = false
15}
16
17resource "docker_container" "nginx" {
18  image = docker_image.nginx.latest
19  name  = "tutorial"
20  ports {
21    internal = 80
22    external = 8000
23  }
24}
25
```
This defines that we will use the Terraform Provider plugin named "docker" with source kreuzwerker/docker . `Terraform has a registry of official (Provider) plugins.

Now initialize and install the plugin:
```
 1$ terraform init
 2
 3 **Initializing the backend...**
 4
 5 **Initializing provider plugins...**
 6
 7- Finding kreuzwerker/docker versions matching "~ 2.13.0"...
 8
 9- Installing kreuzwerker/docker v2.13.0...
10
11- Installed kreuzwerker/docker v2.13.0 (self-signed, key ID **24E54F214569A8A5**)
12
13. etc
14
```
You may validate your config:
```
1$ terraform validate
```
Moment of truth: create the resources:
```
1$ terraform apply
```
Verify the existence of the NGINX container by visiting localhost:8000 in your web browser or running docker ps to see the container.

That's it for Docker. Next is to use a real Cloud Provider.
Step 3 - Using GCP Provider
learn.hashicorp.com/collections/terraform/gcp-get-started

This was actually more elaborate than the Hetzner Cloud exercise. I had a GCP account, so this went smooth: first creating a Network and later a VM Instance. In this step also learned about using Terraform Providers, Resources, Variables(-files.) I leave this as an option and skip to Hetzner Cloud which is the goal of this post.
Step 4 - Using Hetzner Cloud Provider
The Hetzner Cloud plugin provider was not in the tutorials, but it was still not too hard to extrapolate from Step 3, from various Hetzner tutorials and from the hetznercloud/hcloud Terraform Provider.

Links:
- hcloud Provider: [https:]]
- [https:]]
- [https:]]
- using TF-hcloud with Docker: github.com/insekticid/docker-terraform-hcloud-example
Prerequisite is to have a Hetzner Cloud account and thus login access to console.hetzner.cloud .

Steps:
- create a new Project in [https:]] e.g. TerraformLearn
- add your SSH public key to this project via "Security" menu link left
- generate and copy an API Token for the project
My goal was to create a Debian VM, login there with root and SSH key and destroy it afterwards.
```
1$ mkdir -p ~/project/terraform/learn/terraform-hetzner
```
Create main.tf as follows:
```
 1terraform {
 2   required_providers {
 3     hcloud = {
 4       source  = "hetznercloud/hcloud"
 5       version = "1.27.2"
 6     }
 7   }
 8 }
 9 
10 provider "hcloud" {
11   token = var.hcloud_token
12 }
13 
14 resource "hcloud_server" "node1" {
15   name        = "node1"
16   image       = "debian-9"
17   server_type = "cx11"
18   ssh_keys = ["just@sunda.lan"]
19 }
20 
```
Create a file variables.tf:
```
1 # Set the variable value in *.tfvars file
2 # or using the -var="hcloud_token=..." CLI option
3 variable "hcloud_token" {
4   sensitive = true # Requires terraform = 0.14
5 }
6 
```
Then a file called terraform.tfvars. This is a file with "secrets" normally not checked-in a repo but there are many other possiblities to deal with secrets/credentials:
```
1 hcloud_token = "the token string from Hetzner Cloud API Token"  
```
Moment of truth: apply!
```
1$ terraform init
2
3$ terraform apply -auto-approve
```
Using -auto-approve you skip the interactive approval-step.

Next check the Hetzner Cloud Console project page and see the new VM running!

Try to login on your new VM (IP may also be gotten from output.tf, another exercise):
```
1$ ssh root@<Your VM IP>
```
Then destroy your VM:
```
1$ terraform destroy -auto-approve`
```
There is much more one can do with the Hetzner Provider: basically everything that is available in the console UI and hcloud API: creating Volumes, managing networks, adding SSH-keys, snapshots, using cloud-init etc. See the manpage in particular the Resources drop-down menu: registry.terraform.io/providers/hetznercloud/hcloud/latest/docs

Beware that some Terraform actions are destructive: e.g. upgrading the OS will destroy the existing VM and create a new. For those cases Floating IPs and auto-provisioning with Ansible will help. But in that case Ansible would be more suited to upgrade the OS. One can always execute terraform plan first to see the execution plan. My recommendation is to let Terraform handle the basics, and have Ansible manage the details on VMs.

Alternatives: TF with DigitalOcean using the DO Provider: registry.terraform.io/providers/digitalocean/digitalocean/latest/docs .

All in all: Terraform can form a nice partnership with Ansible.
2:00
Lutra consulting: Google Summer of Code 2021 : Virtual Raster Provider for QGIS
sur Planet OSGeo
Read the guest post and congratulate Francesco Bursi, who successfully completed GSOC 2021 project to add virtual raster provider for QGIS with help of mentors Martin Dobias and Peter Petrik.

In this year’s Google Summer of Code (GSoC), I decided to work on the native QGIS raster calculator. Martin Dobias and Peter Petrik volunteered to mentor my work. I’ve been studying Civil Engineering and GeoInformatics at the University of Padua; here I had the opportunity to work both with a lot of GIS software including QGIS. I enjoyed working with QGIS almost immediately because of the possibility to perform complex analysis with a few clicks or with few python commands. Being passionate about programming and enthusiastic about Open Source, I realized that having the possibility to work together with some experienced developers and with an active community was really a great and unique opportunity, so I decided to apply to the GSoC.
Virtual Raster Provider
The existing raster calculator is a powerful tool to perform map algebra that outputs a raster layer, before this work it was possible to take advantage of this tool only by saving the output of this operation as a file. The aim of this year GSoC was to allow users to perform their analysis without creating a new derived raster and taking up disk space and therefore have the result as an on-the-fly computational layer.

Let’s jump to an example and let’s say I want to compute the Chanopy Height Model (CHM), subtracting the Digital Terrain Model (DTM) from the Digital Surface Model (DSM).

I also want to perform some other analysis on the DTM since I want to compute the ideal elevation value for a particular tree planting (disclaimer: the elevation value used is example purposes only, moreover when planting trees you should take into account a lot of factors like slope, aspect, latitude. QGIS, by the way, can really be helpful in this kind of analysis). To do so I will start from the same data and I will create different on-the-fly layers for each calculation, in order to avoid the creation of different files I can take advantage of the new checkbox added to the raster calculator dialog. The computation of CHM is performed in the next screencast and the output layer name is, of course, CHM.

I’ll end up with a new raster layer (CHM) that can be styled as a normal raster and that is not written as an output file to the disk. For some further analysis, from the DTM, I want to obtain the portion of the area with an elevation between 150 and 350 metres above the datum. By applying the following expression to DTM I’ll end up with a raster that has a value of 1 where conditions specified by the expression is TRUE and it will have value of 0 otherwise.
```
("dtm@1" > 150) AND ("dtm@1" < 350)
```
I did not select the output layer name intentionally. The resulting layer will be named after the expression used to generate the layer.
Conditional Statement
I also had the opportunity to improve the raster calculator capabilities by adding the possibility to write expressions that involve conditional statements. Taking the already used example, let’s imagine I want to compute the CHM only for the areas of the DTM that are between 150 and 350 metres above the datum. It’s now possible to write an expression as the following one:
```
if ( ("dtm@1" > 150) AND ("dtm@1" < 350), CHM, -10)
```
This expression will output a raster with values of the CHM where the conditions are met and value of -10 if the conditions are not met. Since this is a final result of our analysis I’ll store this output as a file to the disk in the form of a GeoTIFF. I’d like to outline that the CHM used in the expression above and in the next screencast is an onn-the-fly computed raster, so it is possible to:
- Take advantage of the virtual raster provider (on-the-fly computed raster) in other analysis with the raster calculator (and with other analysis tools);
- Store the on-the-fly computed raster as a file.
Conclusion
I had fun and I struggled working with QGIS, but I learned a lot of new and interesting things. My pull requests were met with several constructive comments, suggestions and feedback. Some suggestions can be a starting point for future improvements.
- An enhancement for the feature I’ve developed can be the possibility to take advantage of OpenCL acceleration as it has also been suggested in the dev mailing list;
- Another enhancement that concerns the raster calculator and only partially the virtual raster provider would be the possibility to support the creation of output raster with multiple bands with the declaration of multiple formulas. I hope to continue to contribute to the QGIS project in the future.
11 September 2021
2:00
PostGIS Development: PostGIS 3.2.0alpha1 Released
sur Planet OSGeo

The PostGIS Team is pleased to release the first alpha of the upcoming PostGIS 3.2.0 release.

Best served with PostgreSQL 14 beta3. This version of PostGIS utilizes the faster GiST building support API introduced in PostgreSQL 14. If compiled with the in-development GEOS 3.10dev you can take advantage of improvements in ST_MakeValid. This release also includes many additional functions and improvements for postgis_raster and postgis_topology extensions.
Continue Reading by clicking title hyperlink ..
10 September 2021
11:00
CARTO Blog: Uncovering Site Selection Strategies using Point of Interest Data
sur Planet OSGeo

In the U.S. it can cost more than $1 million to open a McDonald’s, Taco Bell, Burger King, or Wendy’s restaurant. With such high levels associated with funding startup cost...
09 September 2021
17:00
3liz: QuickOSM 2.0
sur Planet OSGeo

QuickOSM 2.0.0 Introduction
Je suis Maxime Charzat et je suis étudiant à l’ENSG, École Nationale des Sciences Géographiques.

3Liz m’a engagé pour donner un coup de jeune à l'extension. Outre quelques bugfix et mises à jour, cela faisait des années que le plugin n’avait pas été agrémenté de nouvelles fonctionnalités. C’est tout l’objet de ma venue à 3Liz pour ce stage.
Nouveautés Requête rapide
Ce panneau a bien évolué dans cette nouvelle version. En effet, l’idée était de permettre autant des utilisations simples que plus avancées, et bien sûr d’améliorer ces utilisations.

Du côté des utilisations plus basiques, on a voulu simplifier les connaissances par rapport aux clés/valeurs d’OSM. Dans le contexte de l’utilisation du plugin par une personne novice, on a ajouté un champ contenant des pré-réglages de manière similaire aux autres outils qui utilise OSM tel que Vespucci, JOSM… Ce champ est traduit dans la langue définie dans QGIS et permet donc d’abaisser la barrière que peuvent être les clés/valeurs. En tapant Boulangerie en français, la requête OSM shop=bakery est automatique.

Concernant les utilisations avancées, il y avait une fonctionnalité qui était demandée depuis longtemps. Il s’agit de pouvoir créer des requêtes avec plusieurs clés/valeurs. C’est maintenant possible. L’interface permet de jouer avec un tableau pour choisir les clés/valeurs, en ajouter, en supprimer, choisir les liens entre eux. On peut désormais construire une requête qui demande les boulangeries qui font aussi patisserie (shop=bakery AND pastry=yes) ou alors qui demande et les bars et les refuges animaliers (amenity=bar OR amenity=animal_shelter).

Pour les férus de données OSM, les métadonnées peuvent être demandées en cochant la case à cocher dans le groupe Avancé. Cela permet entre autres d’avoir accès à la version de l’objet et à la dernière personne qui a mis à jour cet objet.

Dernier ajout sur ce panneau : un historique des requêtes. L’extension enregistre maintenant temporairement les dix dernières requêtes effectuées. Cela permet de relancer une requête récente sans avoir à s’embêter à devoir derechef tout remplir.

Fichier OSM
Ce panneau permet de charger un fichier OSM ou PBF dans QGIS, stocké en local sur votre ordinateur. Le problème, c’était que l’on était obligé de charger tout le fichier (qui peut être assez volumineux). Il est désormais possible de ne charger que les données qui répondent à une requête de clés/valeurs.

À partir d’un fichier téléchargé par exemple sur [https:]] , sans utiliser internet, on peut faire des requêtes sur un gros volume de données. Volume pas forcément supporté par l’API Overpass utilisé par le plugin pour télécharger les données OSM.
Boîte à outil Traitement
En réfléchissant à tous les usages du plugin, on a décidé de compléter la gamme d’algorithmes dans la boîte à outil Traitement. En effet, jusqu’alors seuls les algorithmes de construction de requêtes étaient implémentés dans le modeleur graphique de QGIS.

Si vous ne connaissez pas le modeleur de QGIS, c'est le moment de jeter un œil.

On en a donc ajouté équivalent du panneau Requête rapide dans la boîte à outil Processing.
Thème de carte
Voici une grosse nouveauté pour la version 2.0.0 et qui peut-être assez puissante. Sur les bases du panneau Mes requêtes qui existait dans la version QGIS 2, on a implémenté l’option de sauvegarder ses requêtes.

Mais, cela va même au-delà de juste enregistrer, on offre la possibilité de les transformer en un thème de carte. Ainsi, en deux clics, en précisant juste l’étendue ou le lieu voulu, il est possible de télécharger toutes les données, d’effectuer toutes les requêtes qui permettent d’afficher une carte prête à l'emploi. On peut même associer un style aux couches directement.

Concrètement, en lançant le thème Urban ci-dessus, vous téléchargez automatiquement les bâtiments et les routes. De plus un style accompagne les données pour la mise en forme.
Configuration
Les requêtes sauvegardées ont donc un mode d’édition pensé pour être exhaustif. On veut laisser à l’utilisateur le pouvoir de fabriquer son thème en ayant la main sur la majorité des options possibles. Ainsi, dans le thème on peut gérer plusieurs requêtes (qui se lancent les unes à la suite des autres lors du processus), gérer la plupart des paramètres pour chaque requête, définir les champs en sortie.

On a aussi le choix entre deux types de thème : soit basique, soit avancé. La différence se fait dans la requête. En type basique, le processus va construire les requêtes avec les clés/valeurs données. En type avancé, le processus va utiliser la requête écrite par l’utilisateur.

Le plugin ne contient que un seul thème par défaut pour le moment. On va avoir besoin de vous pour étoffer cette liste. Si vous vous sentez l’âme d’un contributeur, que vous pensez qu'un thème est manquant, que vous voulez participer à ce plugin, alors n’hésitez pas à nous proposer vos thèmes sur [https:]] en prévoyant le fichier JSON et les fichiers QML.

On peut très bien imaginer un thème carte randonnée, carte cadastre, carte occupation du sol…
Conclusion
Je suis heureux de pouvoir vous présenter cette nouvelle version de QuickOSM. Cela ouvre et approfondi un champ des possibles que j’ai hâte que vous découvriez. N’hésitez pas à nous faire des retours (Twitter, LinkedIn, GitHub…) et à nous proposer vos thèmes.

Amusez-vous !!!

Maxime Charzat
17:00
3liz: QuickOSM 2.0
sur Planet OSGeo

QuickOSM 2.0.0 Introduction
Hi everyone, I'm Maxime Charzat, student at ENSG, French Engineering school about GIS. I've been interning at 3Liz with the goal to clean up, update and add new features to the QGIS QuickOSM plugin.
What's new Quick query
We had two goals with this panel. Make it simpler for newcomers to download OSM data and our other goal was to make it better for advanced users, so they could get more out of the OSM data.

The first goal was to simplify the way to find OSM keys and values. So we've used prepopulated data as in other OSM tools such as Vespucci, JOSM… These data are available in the language defined in QGIS, so people can easily find keys like bench/highway. By typing Boulangerie in French, the query will be automatically transformed with shop=bakery.

For advanced user, we add the support for multiple key/value. There is now a table to add one or more keys. These different rows are linked by a AND and OR.

For instance, it's now possible to query bakeries that have pastries (shop=bakery AND pastry=yes).

For people familiar with OSM data, metadata can be requested by clicking the checkbox in the advanced settings. This will give you the object version and who contributed to the last version of the said object.

Last but not least, we added the history of queries. The plugin now remembers temporarily the last ten queries, so they can be easily be relaunched.

OSM File
This lets you load a PBF or OSM file in QGIS, stored on your hard drive. Before 2.0, you had to load the full dataset from the file. In 2.0 you can now filter using key/values.

This means that you can now process huge quantities of OSM data offline, without using the Overpass API. Files can be generated by services like [https:]] . It means people working on large dataset won't affect the Overpass API.
Processing toolbox
Until now only construction query algorithm were supported in the QGIS Processing Modeler.

If you don't know yet about QGIS Modeler, it's time to have a look.

We decided to add more QGIS Processing algorithm.

You can now find the equivalent of the Quick query in the Processing toolbox.
Map presets
This is the biggest new feature in this release.

Map presets are a nice way to save queries, like it was possible before in QGIS 2. But we added more features. It's possible to save a set of queries within a single map preset, to have a map out-of-the-box.

You can define one or more queries and associate a QGIS Style file for each layer.

For instance, by clicking on the Urban map preset showed above, you will download automatically buildings and roads with a style.

The plugin comes with a single map preset for now. But we need you to contribute to this list. If you feel like a map maker and contributor and if you think a map preset is missing, feel free to come and share it on [https:]] . We would like to see a hiking map preset, bicyle map preset…
Conclusion
I'm happy that I could make this newer version of QuickOSM available to you. I can't wait to see some feedbacks (Twitter, LinkedIn, GitHub…) and to see more map presets coming in the plugin.

Also we'd love to have more people translating QuickOSM, see [https:]]

Have fun Maxime Charzat
7:05
Lutra consulting: Organising Charitable Collection Routes with Offline Mobile Maps
sur Planet OSGeo
Significant time saved when route maps distributed with Input and Mergin.

This case study was originally written in Czech. The Czech version can be found here.

Every year, teams of volunteers walk door-to-door through the Czech town of Litomyšl collecting charitable donations. Event organisers define routes for the various volunteer teams by marking-up paper maps with pens. The process has a number of issues both in the making and usage of the maps which organisers worked to overcome by making the maps digital using open source GIS software.

Maps were developed using QGIS and made available on volunteers’ phones using the Input app. Volunteers are now able to easily orientate themselves on maps which clearly show their routes. Organisers have reduced the time it takes to update routes and distribute these to volunteers.

Veronika Peterková works for the Litomyšl Parish Charity, a non-profit organisation providing health and social services to people in need since 1993.

Veronika describes the charity’s activities: “We provide home medical services and nursing care to the residents of Litomyšl and its surrounding villages. This includes helping families where the healthy development of a child is at risk and providing respite stays for clients who are otherwise cared for by their families at home. We provide care for about 1000 clients a year.”

She added: “We also coordinate the activities of volunteers who visit the elderly, help with tutoring children and with various leisure and cultural activities.”

One of the parish charity’s biggest fundraising events is the “T?íkrálová sbírka” (Three Kings Collection), a door-to-door carol-singing collection taking part around the 6th of January each year.

Volunteers participating in the Three Kings Collection.

“The Three Kings Collection is the largest national volunteer event in the Czech Republic. In the Litomyšl region alone, nearly 300 volunteers are involved each year with the carol-singers collecting over 500,000 Czech crowns (~20,000 EUR) in sealed boxes. The proceeds are intended to help the sick, the disabled, the elderly, mothers with children in need and other in-need groups in the local area.” Veronika explains.

The Three Kings Collection is organised by Caritas Czech Republic and at least 10% of its proceeds are allocated for humanitarian aid abroad.
The Challenge
Veronika is responsible for planning routes for the carol-singers so they efficiently visit households in the Litomyšl area. Singers are split into groups and paper maps are provided which show groups which households to visit.

An example of previous paper maps, image courtesy of Farní charita Litomyšl.

The above maps were produced by printing screenshots from a national web mapping provider and marking-up printouts for each of the 50 teams using marker pens.

This method proved to have a number of issues as Veronika describes: “On maps of larger areas, house numbers were not always visible due to the scale. This made it even harder for coordinators not familiar with the area to orient themselves, leading to confusion. Coordinators also found it hard to keep the maps dry and undamaged during unfavourable weather. If new groups signed-up afterwards or others opted-out, we’d have to redo/redivide the areas which would be very time-consuming as the maps would need to be marked-up manually once again.”
The Solution and Implementation
Veronika wanted to try a new solution for organising the 2021 Three Kings Collection with the goal of making volunteer tasks clearer and less reliant on paper maps. She wanted the new solution to allow her to:
- reduce work through the reuse of maps in future Three Kings Collection events
- easily update maps if new groups sign in/out and areas need editing
- allow carol singers to see exactly where they are on the map
- gradually replace paper maps while still allowing the use of paper maps where preferred
- group and colour buildings to be visited on the computer
- record a building’s use (e.g. commercial) to direct volunteers more effectively
- clearly show how areas are assigned so anyone can see who is responsible for a given area
In addition, Veronika wanted the solution to be affordable and work offline without volunteers needing internet connectivity in the field.

Peter Petrík, a regular participant of the Litomyšl Three Kings Collection suggested Veronika try using the Input app for coordinating the collection in 2021. Peter works for Lutra Consulting, the company behind Input and Mergin.

He showed Veronika how to create the maps in QGIS, a free and open source mapping software. Using map data from OpenStreetMap, they created a project showing the buildings to be visited, coloured by their associated volunteer group number.

Houses grouped by team in QGIS, image courtesy of Farní charita Litomyšl.

The styled map was uploaded to Mergin, a collaborative mapping platform, making it readily available for viewing interactively on volunteer’s phones using the Input mobile app. Both QGIS and Input integrate closely with Mergin which meant that maps could be adjusted in QGIS with the resulting changes being visible to volunteers shortly thereafter.
Outcomes
Veronika reflects on the solution: “The solution met all our requirements and the maps we’ve prepared can easily be reused in upcoming events, saving us time. The fact that the new maps were made publicly accessible means volunteers can just download them using Input which makes distributing and updating them very easy.”

Volunteer routes and position information shown in Input, screenshot courtesy of Farní charita Litomyšl.

She adds: “All the districts we wanted to visit were distinguished from each other by colour and we were also pleased to be able to clearly mark the areas not to be visited like industrial areas by colouring them in grey.”

Unfortunately COVID meant that Veronika’s plans changed as she explains: “Using these new methods we were able to prepare for the 2021 Three Kings Collection in a short time. Unfortunately however, the COVID situation meant we could not go out on the streets to use the new maps as intended. We hope that in 2022 we’ll be able to more closely evaluate the positives and negatives of the field aspect of the project.”

She adds: “We already see it’s now much easier to allocate areas of the town to our volunteers in a clear and fair manner using QGIS. Producing printed maps for those who prefer them is also now easy and the maps look much more professional. Those who only wanted to use the Input app could see the same information as on the paper maps, but had the advantage of being able to pinpoint their exact location and clearly see the house numbers of each building.”

Example printed map created for volunteers wanting also paper maps, image courtesy of Farní charita Litomyšl.

She concludes: “Overall we found the solution user-friendly, and appreciated being able to discuss the process with Lutra Consulting who helped us solve issues as required. About a third of our volunteers are interested in using Input, which I consider positive.”

The Litomyšl Parish Charity are on Facebook and Instagram.
Download Input Today
2:00
SourcePole: QGIS Cloud: Starting a new feature series for QGIS Cloud Pro customers
sur Planet OSGeo

We are pleased to announce that today we have published a new release of QGIS Cloud. Besides a whole bunch of bug fixes, we have also introduced new features for QGIS Cloud Pro customers. Starting with this release, we will be releasing more features for our QGIS Cloud Pro customers in the coming weeks. The following new features are available for QGIS Cloud Pro users starting today. Import Layer: In the Layers & Legend tool you will now find the possibility to import layers.
06 September 2021
2:00
EOX' blog: VirES for (not only) Swarm - 2021 update
sur Planet OSGeo

A few days ago a new release of the VirES for Swarm service has been successfully deployed in production. The V3.6.0 is the first release of the service under the new ESA contract which assures the service operations for another two years, with a possible extension up to four years. Rather than just ...
04 September 2021
2:00
PostGIS Development: PostGIS 3.1.4, 3.0.4 Released
sur Planet OSGeo
The PostGIS development team is pleased to provide bug fix and performance enhancements 3.1.4 and 3.0.4 for the 3.1, 3.0 stable branches.

3.1.4 This release supports PostgreSQL 9.6-14.
- source download
- NEWS
- PDF docs en
- html doc download
- html online en
- epub doc download
3.0.4 This release works with PostgreSQL 9.5-13 and GEOS >= 3.6 Designed to take advantage of features in PostgreSQL 12+ and Proj 6+
- source download
- NEWS
- PDF docs en
- html doc download
- epub doc download
View all closed tickets for 3.1.4, 3.0.4.

After installing the binaries or after running pg_upgrade:

For PostGIS 3.1, 3.0, 2.5 do below which will upgrade all your postgis extensions.
```
SELECT postgis_extensions_upgrade();
```
For PostGIS 2.4 and below do:
```
ALTER EXTENSION postgis UPDATE;
```
— if you use the other extensions packaged with postgis — make sure to upgrade those as well
```
ALTER EXTENSION postgis_sfcgal UPDATE;
ALTER EXTENSION postgis_topology UPDATE;
ALTER EXTENSION postgis_tiger_geocoder UPDATE;
```
If you use legacy.sql or legacy_minimal.sql, make sure to rerun the version packaged with these releases.
03 September 2021
17:19
OTB Team: OTB release 7.4.0
sur Planet OSGeo

We are happy to announce that OTB 7.4.0 has been released! Ready to use binary packages are available on the package page of the website: OTB-7.4.0-Darwin64.run (Mac OS) OTB-7.4.0-Linux64.run (Linux) OTB-7.4.0-rc1-Win64.zip (Windows 64 bits) It is also possible to checkout the branch with git: git clone [https:] OTB -b release-7.4 The documentation for OTB 7.4.0 […]
01 September 2021
10:00
Paul Ramsey: GeoMob Podcast - PostGIS
sur Planet OSGeo
I neglected to post about this at the time, which I guess is a testament to the power of twitter to suck up energy that might otherwise be used in blogging, but for posterity I am going to call out here:
- I got to go on the GeoMob podcast and talk with Steven Feldman this spring.
- It was cool, Steven is a fellow “FOSS4G Chairpersons” alumnus, having chaired the 2013 edition.
- We covered PostGIS, open source, and even a bit of electoral data and field ops.
Have a listen.
31 August 2021
16:39
Even Rouault: Analyze of OSS-Fuzz related data on GDAL
sur Planet OSGeo
GDAL has now been put under the continuous scrutinity of OSS-Fuzz for more than 4 years. To keep it simple, OSS-Fuzz is a continuous running infrastructure that stresses a software with (not-so-)random data to discover various flaws, and automatically files issues in a dedicated issue tracker, with reproducer test cases and stack traces when available. It is time to use a bit the data accumulated to give a few trends.
First, we can see a total of 1787 issues having been found, which represents on average a bit more than one per day. Out of those, only 38 are still open (so 97.8% have been fixed or are no longer reproducible). Those 1787 issues are out of a total of 37 769 filed issues against all 530 enrolled software, hence representing 4.6 % (so significantly higher than the naive 1 / 530 = 0.2 % proportion that we could expect, at least if all software were of the same size, but GDAL is likely larger than the average). Does that mean that the quality of GDAL is lower than the average of enrolled software, or that it is stressed in a more efficient way... ? Most of GDAL code being about dealing with a lot of file formats, it is the ideal fit for fuzz testing.
We should mention that a number of issues attributed to GDAL actually belong to some of its dependencies: PROJ (coordinate transformation), Poppler (PDF rendering), cURL (network access), SQLite3 (embedded database), Xerces-C (XML parsing), etc. And we reguarly report or fix those issues to those upstream components.
Addressing those issues is now facilitated with the sponsorship program which allows us to spend funded time on such unsexy and usually hard to fund topics, but important to enhance the robustness of the software.
We have run a script that parses git commit logs to identify commits that explicitly reference an issue filed by ossfuzz and tried to analyze the commit message to find the category of the issue that it addresses.
Here's its output:
Category                                                Count Pct
----------------------------------------------------------------------
integer_overflow_signed                                  178 14.67 %
excessive_memory_use                                     174 14.34 %
other_issue                                              114   9.40 %
buffer_overflow_unspecified                              105   8.66 %
excessive_processing_time                                102   8.41 %
null_pointer_dereference                                  93   7.67 %
integer_overflow_unsigned                                 68   5.61 %
division_by_zero_integer                                  54   4.45 %
heap_buffer_overflow_read                                 37   3.05 %
unspecified_crash                                         32   2.64 %
stack_call_overflow                                       31   2.56 %
memory_leak_error_code_path                               23   1.90 %
heap_buffer_overflow_write                                22   1.81 %
division_by_zero_floating_point_unknown_consequence       19   1.57 %
stack_buffer_overflow_unspecified                         19   1.57 %
invalid_cast                                              14   1.15 %
invalid_shift_unspecified_dir                             14   1.15 %
memory_leak_unspecified                                   13   1.07 %
assertion                                                 13   1.07 %
invalid_enum                                              11   0.91 %
division_by_zero_floating_point_harmless                  10   0.82 %
infinite_loop                                             10   0.82 %
integer_overflow_unsigned_harmless                         8   0.66 %
invalid_memory_dereference                                 7   0.58 %
undefined_shift_left                                       7   0.58 %
double_free                                                6   0.49 %
stack_buffer_overflow_read                                 6   0.49 %
use_after_free                                             6   0.49 %
integer_overflow_harmless                                  5   0.41 %
undefined_behavior_unspecified                             3   0.25 %
negative_size_allocation                                   3   0.25 %
unhandled_exception                                        2   0.16 %
invalid_shift_right                                        2   0.16 %
unsigned_integer_underflow                                 1   0.08 %
uninitialized_variable                                     1   0.08 %
----------------------------------------------------------------------
Total                                                   1213

So 1213 commits for 1787-38 fixed issues: the difference is duplicated issues, non-reliably reproducing issues that end up being closed or issues fixed in other code bases than GDAL.
Let's dig into those categories, from most frequently hit to lesser ones:
- integer_overflow_signed: an arithmetic operation on a signed integer whose results overflows its size. This is a undefined behavior in C/C++, meaning that anything can happen in theory. In practice, most reasonable compilers and common CPU architectures implementing complement-to-two signed integers will have a wrap around behavior, and not crash when the overflow occurs. However this has often later consequences, like allocating an array of the wrong size, and having out-of-bounds access.
- excessive_memory_use: this is not a vulnerability by itself. This issue is raised because processes that run under OSSFuzz are limited to 2 GB of RAM usage, which is reasonable given than OSSFuzz manipulates input buffers that are generally large of a few tens of kilobytes. It is thus expected that for those small inputs, RAM consumption should remain small. When that's violated, it is because the code generally trusts too much some fields in the input data that drive a memory allocation, without checking that against reasonable bounds, or the file size. However for some file formats, it is difficult to implement definitive bounds because they allow valid small files that need a lot of RAM to be processed. Part of the remaining open issues belong to that category.
- other_issue: issues that could not be classified under a more precise category. Bonus points for anyone improving the script to analyze the diff and figure from the code the cases where the commit message lacks details! Or perhaps just parse the OSSFuzz issue itself which gives a categorization.
- buffer_overflow_unspecified: an access outside the validity area of some buffer (string, array, vector, etc.), and we couldn't determine if it is a heap allocated or stack allocated, or a read attempt or write attempt. Potentially can result in arbitrary code execution.
- excessive_processing_time: this is when a program exceeds the timeout of 60 second granted by OSS-Fuzz to complete processing of an input buffer. This is often due to a sub-optimal algorithm (e.g. quadratic performance whereas linear can be met), or a unexpected network access. Most of the remaining open issues are in that category. A significant numbers are also in a out-of-memory situation hit by the fuzzer while iterating over many inputs, but often that cannot be reproduced on a individual test case. We suspect heap fragmentation to happen in some of those situations.
- null_pointer_dereference: a classic programming issue: accessing a null pointer, which results in a immediate crash.
- integer_overflow_unsigned: this one is interesting. Technically in C/C++, overflow of unsigned integers is a well-defined behavior. Wrap around behavior is guaranteed by the standards. However we assumed that in most cases, the overflow was unintended and could lead to similar bugs as signed integer overflow, hence we opted in for OSSFuzz to consider those overflows as issues. For the very uncommon cases where the overflow is valid (e.g when applying a difference filter on a sequence of bytes), we can tag the function where it occurs with a __attribute__((no_sanitize("unsigned-integer-overflow"))) annotation
- division_by_zero_integer: an integer divided by zero, with zero being evaluated as an integer. Results in immediate crash on at least x86 architecture
- heap_buffer_overflow_read: read access outside the validity area of a heap allocated data structure. Results generally in a crash.
- unspecified_crash: crash for a unidentified reason. Same bonus point as above to help better categorizing them.
- stack_call_overflow: recursive calls to methods that ends up blowing the size limit of the stack, which results in a crash.
- memory_leak_error_code_path: memory leak that is observed in a non-nominal code path, that is on corrupted/hostile datasets.
- heap_buffer_overflow_write: write access outside the validity area of a heap allocated data structure. Results generally in a crash. Could also be sometimes exploited for arbitrary code execution.
- division_by_zero_floating_point_unknown_consequence: a variable is divided by zero, and this operation is done with floating point evaluation. In C/C++, this is undefined behavior, but on CPU architectures implementing IEEE-754 (that is pretty much all of them nowadays) with default settings, the result is either infinity or not-a-number. If that result is cast to an integer, this results in undefined behavior again (generally not crashing), and various potential bugs (which can be crashing)
- stack_buffer_overflow: a read or write access outside of a stack-allocated buffer. Often results in crashes, and if a write access, can be sometimes exploited for arbitrary code execution.
- invalid_cast: this may be an integer cast to an invalid value for an enumeration (unspecified behavior, which can results in bugs due to not catching that situation later), an instance of a C++ class cast to an invalid type (unspecified behavior, crash likely)
- invalid_shift_unspecified_direction: a left- or right-shift binary operation, generally on a signed integer. For left-shift, this is when this results in setting the most-significant-bit being set (either shifting too much a positive value, which results to a negative value, or shifting a negative value), or shifting by a number of bits equal or greater than the width of the integer. For rigth-shift, this is when shiting by a number of bits equal or greater than the width of the integer. Those undefined behaviors do not result in immediate crashes on common compilers/platforms, but can lead to subsequent bugs.
- memory_leak_unspecified: self explanatory.
- assertion: an assert() in the code is hit. A lot of what we initally think as programming invariants can actually be violated by specially crafted input, and should be replaced by classic checks to error out in a clean way.
- invalid_enum: a particular case of invalid_cast where an invalid value is stored in a variable of a enumeration type.
- division_by_zero_floating_point_harmless: a floating-point division by zero, whose consequences are estimated to be harmless. For example the NaN or infinity value is directly returned to the user and does not influence further execution of the code.
- infinite_loop: a portion of the code is executed in a endless way. This is a denial of service.
- integer_overflow_unsigned_harmless: an example of that could be some_string.substr(some_string.find(' ') + 1) to extract the part of a string after the first space character, or the whole string if there's none. find() will return std::string::npos which is the largest positive size_t, and thus adding 1 to it will result in 0.
- invalid_memory_dereference: generally the same as a heap_buffer_overflow_read.
- invalid_shift_left: mentioned above.
- double_free: a heap-allocated buffer is destroyed twice. Later crash is likely to occur. Could potentially be exploited for arbitrary code execution.
- stack_buffer_overflow_read: mentioned above
- use_after_free: subcase of heap_buffer_overflow_read where one accesses some buffer after it has been freed.
- integer_overflow_harmless: mentioned above, but here, if we exclude the undefined behavior aspect of it, consequences are estimated to be harmless.
- undefined_behavior_unspecified: some undefined behavior of a non identified category, restricted to those caught by the UBSAN analyzer of clang
- negative_size_allocation: a negative size (actually a unsigned integer with its most significant bit set) is passed to a heap memory allocation routine. Not a bug by itself, but often reflects a previous issue.
- unhandled_exception: a C++ exception that propagates up to the main() without being caught. Crash ensured for C code, or C++ callers not expecting it. As the fuzzer programs used by GDAL use the C API, such exception popping up is definitely a bug.
- invalid_shift_right: mentioned above.
- unsigned_integer_underflow: similar as the overflow but going through the negative values. Well defined behavior according to the standards, but often undesirable.
- uninitialized_variable: access to a variable whose content is uninitialized. There are very few instances of that. The reason is probably that we use extensively strict compiler warnings and static code analyzers (cppcheck, clang static analyzer and Coverity Scan), that are very good to catch such issues.
Despite the big number of categories caught by the sanitizers run by OSS-Fuzz, there are some gaps not covered. For example casting an integer (or floating point value) to a narrower integer type with a value that does not fit into the target type. Those are considered as "implementation defined" (the compiler must do something, potentially different from another one, and document what it does), and thus do not enter into what is caught by undefined behavior sanitizers.
PS: For those interested in academic research analyzing outputs of OSSFuzz, you can find this paper (where GDAL actually appears in one figure)
30 August 2021
15:57
GeoSolutions: DHI Announcement
sur Planet OSGeo

You must be logged into the site to view this content.
2:00
Ecodiv.earth: Playing with animal tracking data in QGIS
sur Planet OSGeo
I am currently looking for data I can use in my classes about spatial data analysis. A great source of data I found is the Movebank, a free, online database of animal tracking data hosted by the Max Planck Institute of Animal Behavior. The aim is to help animal tracking researchers to manage, share, protect, analyze and archive their data. This short article provides a nice short introduction to the type of data available on this site.

The data is great for something else I have wanted to do for some time now. That is, trying out the temporal controller in QGIS. This tool offers native temporal support to QGIS. It is the successor of the celebrated TimeManager plugin, and is available since version 3.14. The main developer, Nyal Dawson, made a video demonstrating some of the capabilities of this new tool. Definitely something to check out. Below you can find the steps I followed to create the animated map (you can find the map at the end of this post). Note, click on an image to enlarge it.
Cattle movements
To use the temporal controller, you obviously need temporal data. This can be raster or vector data. The animal tracking data available in the Movebank database is a .csv data layer with a number of columns, including the coordinates and the date-time column. This can be imported as a vector point layer in QGIS.

Study area with the 33 animal tracks. Background image, Bing satellite via the Quickmap services plugin for QGIS. In this study, we’ll focus on the eastern tracks along the main river.

For this post, we use a dataset collected by Moritz et al.¹ for a study about grazing pressure in pastoral systems in the Logone Floodplain in Cameroon². I particularly liked this study because of how it combines different approaches and methods (GPS/GIS, video recordings of animal behavior, and ethnographic methods). But that is something for another time.

The GPS data set consists of 33 tracks, representing the daily movement of individual animals during the day (21 tracks) or night (12 tracks) in three different locations. As mentioned above, the data comes as a .csv file, which we import and subsequently save as a vector layer in a new Geopackage.
Import csv and save in geopackage

Import the csv file in QGIS.

Save the data as the layer cattlemovement in the (new) Geopackage cattlemovementdata.gpkg.

Define the symbology, assigning random colors to each of the tracks. Tracks are identified by the categories in the ‘individual-local-identifier’ column.

Data preparation
The locations of the animals were recorded at 3-second intervals (only if the animal was moving)². However, the date-time stamps provided in the Movebank data file are rounded to whole minutes. Information about the seconds between consecutive measurements is provided separately in the column ‘study-specific measurement.’

Because there are some missing observations, creating complete time-stamps based on this information is a bit tricky. So I will leave that as a challenge for you. For the visualizing of the animal movements, a one-minute time interval is good enough. It does mean we need to compute the average locations per minute first.
Calculate average position per minute
First step is to create a new column tracktime with the combined track ID and date-time stamp. This makes for a unique ID that can be used to group the location points that need to be averaged. Combining the two columns can be done using the expression "individual-local-identifier" || '_' || to_string( "timestamp" ) in the Field calculator. Note that we add the underscore to make it easier later on to split the created strings back in two columns with the original track identifiers and the date-time stamps.

Concatenate the columns with the track ID and the timestamp.

To speed up subsequent calculations, we create an index on the newly created field, using the function Create attribute index in the processing toolbox.

Create an index on the column track_time.

To calculate the arithmetic mean of the coordinates of each tracktime category, we use the Mean coordinates function from the processing toolbox.

Create new layer with average position per track_time category.

The resulting layer does not contain the track ID and date-times. To get this ‘back,’ we need to split the tracktime ID’s we created earlier back into two columns with the track ID’s and the date-time records. To do so, we use the string_to_array() function in the Field calculator; string_to_array("tracktime", "_")[0] to get the track ID’s and string_to_array("tracktime", "_")[1] to get the date-time values.

Extract the track ID’s from the column tracktime.

Extract the date-time records from the column tracktime.

We now have a vector layer cattlemovement_perminute with the location data per minute. The tracks were recorded over a 15-day period, with some longer periods between tracks. To speed things up, and to reduce the length of the animated map, we use a subset of the recorded tracks, e.g., those for the tracks in the Cubuna.
Select and save tracking data for Cubunu

Select features using the ‘select features’ option.

Save the selected features as a new layer using the context menu: right click on the layer cattle movement, and in the context menu, select ‘Export > Save selected Features as’.

Save the new vector layer ‘Cubuna’ in the (existing) Geopackage ‘cattlemovementdata.gpkg’ (of course, you can also save it in a new Geopackage if you prefer that).

Symbologies
In the Layers windows, we duplicate this layer (right-click the layer, and in the context menu, select duplicate layer) and rename this Cubuna_background. The idea is to use the Cubuna layer to show the moving points, and the Cubuna_background layer to keep the points visible, but in another color. To this end, we assigned random fill colors to each of the tracks in Cubuna layer, with white borders for the day tracks, and black borders for the night tracks. For the Cubuna_background day tracks, we assign a semi-transparent white color to the day tracks and a semi-transparent black color to the night tracks.
Define the symbology

Symbology for the point layer that symbolizing the point locations.

Symbology for the point layer symbolizing the tracks.

Temporal controller
The next step is to enable the Dynamic temporal control under the Temporal tab of the Layer Properties window. With the dynamic temporal control enabled, QGIS will display features/points at certain times or time intervals. Depending on the data, there are different configuration options. We use the Single field with Date/Time option with the date_time column as input. We furthermore set the event duration to 1 minute. This defines how long the points will be visible after the start.
Enable the temporal control
The Temporal tab can be found in the Layer properties 1. The date and time for each location is determined by the values in the field date_time. We select the Single Field with Data/Time from the configuration drop down menu 2, and the field date-time to define the date and time 4. Finally, we set the event duration to 1 minute 3.

Endable the dynamic temporal control for the ‘Cubuna’ layer in the Layer properties Window.

We do the same for the ‘Cubuna_background’ layer. Only this time, we select the ‘Accumulate features over time’ option 5. With this option enables, the points will remain visible after activation.

Endable the dynamic temporal control for the ‘Cubuna’ layer in the Layer properties Window.

We can now open the Temporal Control Panel to preview the animated map, change the animation speed, or change the temporal range to be animated.
Preview animated map
The layers under temporal control have a clock symbol next to the layer name in the Layer window 1. The Temporal Control Panel can be opened by clicking on the Clock icon on the Map Navigation Toolbar 2 or through View ? Panels ? Temporal Controller. In the Temporal Controller window, we can now click on the Animated Temporal Navigation (play icon 3) to activate the animation controls. Click the Set to Full Range (refresh icon 4) to automatically set the time range to the match the dataset. Set the step to 1 minute 5. Now we can preview the animation by clicking the Play button 6.

Preview of the animated map with the Temporal controller.

Note that if the animation is too fast, or too slow, you can adjust the frame rate by clicking Temporal Settings (yellow gear icon 7). Decreasing the the frame rate (frames per second) will slow down the animation.

It would be nice if we can add a label that displays the time frame on the map. We can do that using the built in Title Decoration.
Add label with time stamp
The following is based on the tutorial by Ujaval Gandhi³. Go to View ? Decorations ? Title Label.

Adding a title label to the map.

Click the checkbox to enable it and click Insert an Expression button and enter the following expression to display the date and time.

[%format_date(@map_start_time, 'dd MMMM yyyy hh:mm:ss')%]

Here, the variable @map_start_time contains the timestamp of the current time slice being displayed. So we can use that timestamp and format it to display the date and time of occurrence. See the QGIS documentation for more information about the syntax and options.

Define the title label text.

The font type and size, background color and placement can all be adapted to your likening. In the example, I used a white font (Noto Sans Georgian, 22pt) on a 43% transparent black background.

Export the animated map
So now we have an animated map that we can view and explore in QGIS. But what if we want to share the map? The Time Controller has the option to export the frames of the animations as individual png files.
Export the animated map
The first step is to export the map animation. To do so, we select the Export Animation (save icon) in the Temporal control window. In the Export Map Animation dialog, we click on the ... Output directory 1 to choose the directory in which the images will be saved. We use Calculate from layer 2 to set the extent to match that of the Cubuna point layer. Activate the little lock 4, and set the output height (the width will be automatically adjusted) 3. Optionally, the time range can be set, e.g., to limit the video to the first day.

Export map animation.

Once the export finishes, we have a large number of PNG images, each representing a 1-minute step, in the output directory. We can now convert these into an animated image (gif) or a video. Given the large number of png files we just created, the gif file will be very large, and it takes a long time to generate. Creating a video is therefore the better option.

There are various tools, but below we are going to use FFmpeg, a cross-platform solution to record, convert and stream audio and video.
From pngs to video
FFmpeg is a command-line tool. If you are on Windows, you can use the command line (cmd) or Windows PowerShell. Either way, first we need to go to the working directory with the png images. In the console, you type in:
```
cd C:\users\brp\Desktop\movementdata
```
Now we use the FFmpeg function to convert the png files in that folder to a video. With the command below, we create two video’s, one in the popular mp4 format, the other in the mkv format. The most important parameter is the -i, which stands for input, followed by the cattlemovement%04d.png. This part of the code identifies the input files as all the png files in the folder which names start with ‘cattlemovement,’ followed by a 4 digit number.
```
ffmpeg -framerate 60 -i cattlemovement%04d.png -crf 20 cattlemovement2.mp4
ffmpeg -i cattlemovement%04d.png -c:v libx264 -preset slow -crf 22 -c:a copy cattlemovement.mkv
```
I leave it up to you to find out more about the other parameters. This page provides an overview of some of the main options. And on this page is more specifically about the various encoding options. And there is of course the official documentation.

The resulting video is around 8 MB. Which is pretty good, given that all the input png files together were 6.45 GB. An in case you are curious, a gif file would have been around 218 MB large, and it takes a lot more time to create. So, yes, creating a video definitely is a good choice here. But the video, that was what it was all about. Check it out below (if it doesn’t automatically play, hit the play button).
Your browser does not support the video tag. You can watch the video on Youtube.
So how useful is a video like the one above? Not sure to be honest. It does raise some interesting questions. Like, how do the pastoralists decide where to go? They must know the area pretty well given that they need to water their animals (i.e., reach the water holes, here marked by blue dots) on time. And what about those night tracks? I guess that is exactly what I like about this kind of maps, they make you curious about what is going on ?. And check out the article for some answers.
Afterword
Hope you enjoyed reading the post. Want to see more examples? Check out this post by Topi Tjukanov and this tutorial by Ujaval Gandhi, both of which served as inspiration for this post. And there are a lot of inspiring video tutorials on Youtube. And last but not least, thanks to Moritz et al. for providing the data and providing feedback on questions, and the Movebank for the answers to my inquiries.

References 1. Moritz M. Data from: An integrated approach to modeling grazing pressure in pastoral systems: the case of the Logone Floodplain (Cameroon). Published online 2018. doi:10.5441/001/1.J682DS56 2. Moritz M, Soma E, Scholte P, et al. An Integrated Approach to Modeling Grazing Pressure in Pastoral Systems: The Case of the Logone Floodplain (Cameroon). Human Ecology. 2010;38(6):775-789. doi:10.1007/s10745-010-9361-z 3. Gandhi U. Animating time series data (QGIS3). Published online 2019. [https:]]
27 August 2021
19:59
From GIS to Remote Sensing: New publication about the Semi-Automatic Classification Plugin in the Journal of Open Source Software
sur Planet OSGeo

I am very glad to announce that the paper "Semi-Automatic Classification Plugin: A Python tool for the download and processing of remote sensing images in QGIS" has been published in the prestigious Journal of Open Source Software.The paper is freely available at this link.

I am very grateful to the reviewers and editors of the Journal for their valuable work, making an exceptional contribution to the open source initiative.I also invite you to contribute to the Journal, for instance volunteering to review.
This paper is very important as it describes the purpose and characteristics of the Semi-Automatic Classification Plugin.
If you are using the Semi-Automatic Classification Plugin in your research please cite as:Congedo, Luca, (2021). Semi-Automatic Classification Plugin: A Python tool for the download and processing of remote sensing images in QGIS. Journal of Open Source Software, 6(64), 3172, [https:]]
For any comment or question, join the Facebook group or GitHub discussions about the Semi-Automatic Classification Plugin.
26 August 2021
16:58
Fernando Quadro: Lançamento: Combo Python com GIS do Zero
sur Planet OSGeo

Prezado leitor,

Você trabalha com dados geográficos, domina o QGIS, tem vontade de automatizar os seus processos mas não sabe programar?

Então essa é a sua chance, pois a Geocursos acaba de lançar um novo curso que vai ter ensinar a programar em Python do Zero e te levar a automação dos seus processos GIS, criação de plugins, interpolação e muito mais.

Ficou interessado?

Acesse o site e matricule-se!
?
[https:]]
11:00
CARTO Blog: How to do Route Optimization at Scale with CARTO & BigQuery
sur Planet OSGeo

Computing distance metrics is a challenging problem in spatial analysis. When studying urban travel, calculating distances between two locations as the crow flies is the mo...
24 August 2021
10:27
Andrea Antonello: SMASH 1.7.0 is out!
sur Planet OSGeo
We just released version 1.7.0 of SMASH to the stores. This was initially thought as a bugfix release but then we got caught up in the vortex of some advanced users and their well formulated comments, feature requests and bugfix ideas. This lead to a set of new features:
Form enhancements:
Probably the most important feature. Forms can now be used also for postgis and geopackage data sources. Until now it was possible only for project notes.

Autocomplete combos for very long lists of choices:

Sketches are back (well, for those that came from geopaparazzi):

String combos in forms can now be encoded. This means that each item of a combo can have a label and a value. That is another nice feature brought in by the Georepublic people.

Export project images to folder
Another feature asked by geopaparazzi lovers. And here it is:

Contour lines
Mapsforge (or better andromap) maps can now be displayed with contour lines.

Other fixes and little enhancements:
- it is now possible to add points by GPS and map center when editing geopackage/postgis layers
- geopackage layer selection has been improved
- zoom-in when notes are very near has been enhanced
- when selecting multiple notes, previous popups are properly disposed
- tile based layer images now properly update when switching layers
- camera setting, speak resolution) are properly applied
- form notes now always show the label. They didn't when exporting to gpx/kml and in the notes list
- log merging now uses the right master log (the first)
This version is aligned with version 3.2 of the Geopaparazzi Survey Server.

Enjoy!!!
20 August 2021
12:45
GeoTools Team: GeoTools 24.5 released
sur Planet OSGeo

The GeoTools team is pleased to share the availability of GeoTools 24.5 :geotools-24.5-bin.zip geotools-24.5-doc.zipgeotools-24.5-userguide.zipgeotools-24.5-project.zipThis release is published to the OSGeo maven repository, and is made in conjunction with GeoServer 2.18.4. This is a maintenance release and is a recommended upgrade for all users of the GeoTools library.This is the last
2:00
GeoServer Team: GeoServer 2.18.5 Released
sur Planet OSGeo
We are happy to announce GeoServer 2.18.5 release is available for download (zip and war) along with docs and extensions.

This GeoServer 2.18.5 release was produced in conjunction with GeoTools 24.5 and GeoWebCache 1.18.4. This is a maintenance release recommended for production systems. It is also the last release of the 2.18.x series, users are warmly recommendeded to upgrade to 2.19.x, or upgrade to 2.20.0 as it gets released next month, September 2021.

Thanks to everyone who contributed, and to Alessandro Parma (GeoSolutions) and Andrea Aime (GeoSolutions) for making this release.
Improvements and Fixes
This release improves the importer module logging, as well as the documentation on how to enable and use catalog parametrization:
- GEOS-10194 Improve importer LOGGING
- GEOS-10149 Improve Catalog Parametrization documentation
Fixes included in the release
- GEOS-10173 CoverageViewReader’s format not being secured with Geofence-Geoserver
- GEOS-10162 GeoServerOAuthAuthenticationFilter creates Anonymous authentication when preAuthenticated principal is not present
- GEOS-10193 Indirect imports will drop the target table if there is any failure during the import process
For details check the 2.18.5 release notes.
About GeoServer 2.18
Additional information on GeoServer 2.18 series:
- State of GeoServer 2.18 (slides)
- GeoServer Orientation (slides|video)
- Release Notes (2.18.5 | 2.18.4 | 2.18.3 | 2.18.2 | 2.18.1 | 2.18.0 | 2.18-RC)
19 August 2021
17:48
gvSIG Team: 17th International gvSIG Conference: Communication proposals submission
sur Planet OSGeo

The 17th International gvSIG Conference will be held from December 1st to 3rd, being an on-site event again if health situation permits, at School of Engineering in Geodesy, Cartography and Surveying (Universitat Politècnica de València, Spain), under the slogan “gvSIG solutions: Recovering the future“.

Communication proposals submission is now open for both paper and poster, and they can be sent to the email address: conference-contact@gvsig.com. Information regarding to regulations on communication presentations and deadline can be found in the Communications section of the event website.

In addition, registration period for the Conference will be open at the end of September. Registrations will be free of cost (limited capacity) and they will be available through an application form on the Conference web page.

Organizations interested in collaborating in the event can find information in the section: How to collaborate, with different levels of sponsoring.

All the information related to the conference, including workshops information, will be published at gvSIG Blog.

We expect your participation!
17:48
gvSIG Team: 17as Jornadas Internacionales gvSIG: Envío de comunicaciones
sur Planet OSGeo

Las 17as Jornadas Internacionales gvSIG tendrán lugar del 1 al 3 de diciembre de 2021, y volverán de nuevo a la modalidad presencial si la situación sanitaria lo permite, en la Escuela Técnica Superior de Ingeniería Geodésica, Cartográfica y Topográfica (Universitat Politècnica de València, España), bajo el lema “Soluciones gvSIG: Recuperando el futuro”.

A partir de ahora pueden enviarse las propuestas de comunicación, tanto para ponencia como para póster, a la dirección de correo electrónico conference-contact@gvsig.com. Toda la información sobre las normas para la presentación de comunicaciones, así como las fechas límite para el envío de las propuestas, puede consultarse en el apartado ‘Comunicaciones’ de la web de las jornadas.

Por otro lado, el periodo de inscripción a las jornadas se abrirá a finales del mes de septiembre. Las inscripciones serán totalmente gratuitas (con aforo limitado) y se habrán de realizar a través del formulario que se habilitará en la página web de las Jornadas.

Finalmente, las organizaciones interesadas en colaborar en el evento pueden encontrar información en el apartado ‘¿Cómo colaborar?’ de la web de las jornadas, con distintos niveles de patrocinio disponibles.

Toda la información sobre las jornadas, incluyendo los talleres que se impartirán, se irá publicando en el blog de gvSIG.

¡Esperamos vuestra participación!
18 August 2021
8:00
Lutra consulting: Case Study: QGIS Core Development for TUFLOW
sur Planet OSGeo
The case study presents the C++ development of QGIS Desktop to support rendering of 3D results produced by TUFLOW’s 3D capable solver: TUFLOW FV (10 minute read)
Introduction
TUFLOW is a suite of advanced 1D/2D/3D computer simulation software for flooding, urban drainage, coastal hydraulics, sediment transport, particle tracking and water quality. With over 30 years of continuous development, TUFLOW is internationally recognised as one of the industry leaders for hydraulic modelling accuracy, speed and workflow efficiency.

Lutra Consulting Ltd is a leader in software development for pre- and post-processing of hydraulic and meteorological results in open-source QGIS. We also work on mobile data collection Input App and GIS data synchronization service Mergin

In 2019 the TUFLOW team commissioned us to develop post-processing support for their TUFLOW Flexible Mesh format for QGIS 3.12. The format is 3D stacked mesh, which consists of multiple stacked 2D unstructured meshes each extruded in the vertical direction (levels) by means of a vertical coordinate.

At that time QGIS only supported 2D meshes that defined results on vertices and faces. We had been keen to extend the capabilities of the software stack to support 3D mesh data for a long time so this was an exciting opportunity. Part of the task was also to include rendering support for TUFLOW model results on the QGIS 3D view. The delivery of the project was within one QGIS release cycle (less than 6 months time for users to use it on their projects!)

Contact us at info@lutraconsulting.co.uk if you’d like to discuss the benefits of integrating your flood modelling software more tightly with QGIS or you have some custom QGIS development in mind.
C++ Development Process: From requirement to delivery Communicate project with the community first
When doing a substantial change in the QGIS codebase, the developer needs to write a technical specification of the QGIS changes for community discussion. QGIS Core Developers (which Lutra is a part of) can give valuable feedback to the overall technical approach and the wider community can raise some usability issues or enhancement proposals. Most importantly, each part of the QGIS code has its lead maintainers, for example Martin Dobias, our CTO, is the maintainer of QGIS 3D code and Peter Petrik is the maintainer of the Mesh layer code. It is a good practice to address the maintainers’, users’ and other developers’ concerns and feedback to ensure the feature can be implemented in QGIS.

So after a thorough discussion about the requirements with the TUFLOW team and analysis of the existing tools for post-processing and display of the TUFLOW FV format we came up with the QGIS Enhancement: Support of 3D layered meshes

The community reaction was very positive and supportive. Time to start coding!
MDAL to support TUFLOW FV NetCDF format
Mesh Data Abstraction Library MDAL is a C++ library for handling unstructured mesh data. It provides a single data model for multiple supported data formats. MDAL is used by QGIS for data access for mesh layers. If you want QGIS to support your data format, you need to have a driver in MDAL that implements it.

We added support for 3D stacked meshes and the TUFLOW FV format in MDAL. When we develop features in MDAL, we focus on quality code, so
- all changes have a proper code review,
- all code has fully automated tests with more than 90% coverage target
- the documentation and manual testing is done after coding
To implement the TUFLOW FV driver for 3D stacked meshes, we added a new API/interface in MDAL, so we needed to follow up with the QGIS changes in QgsMeshLayer and MDAL data-provider.
QGIS C++ Development to support stacked meshes and visualization in 3D
The implementation of large feature changes is best to split into smaller but self-consistent parts. For example the first pull request added the basic support for the new 3D stacked meshes. Each pull request we do has a screenshot or gif/video with the new functionality preview, follows QGIS Coding Standards, has unit tests where necessary and includes the documentation for the functions/classes added in the public interface. Once the request is merged, the features are next day available in nightly builds on all platforms for testing!
Final Steps: feedback, testing, documentation and presentation
When all the features were in QGIS master, the TUFLOW team used windows nightly builds to test the new features and provide feedback. After a small number of iterations, all issues were resolved and implementation signed.

Shortly the new official QGIS release was published and we started promotion of the new features on our social media channels. Also, the features developed under this contract were promoted in the visual QGIS changelog.
Benefits for TUFLOW to support QGIS Core C++ Development:
- Reduced development and maintenance costs for tools such as the TUFLOW Viewer QGIS Plugin since the new features are part of the QGIS core
- By being part of the QGIS ecosystem it provides opportunities to approach QGIS users in the flooding and coastal modeling industry to use TUFLOW software
- As a project sponsor, the requirements of the new features meet the present and future needs of the TUFLOW user base.
- At the beginning of the project Lutra showed all the current relevant capabilities of QGIS ecosystem, allowing TUFLOW to be aware of the latest and greatest features
- Allowed TUFLOW to solve upstream bugs in QGIS or MDAL due to the open-source nature of the projects
Benefits for TUFLOW users:
Key benefits made available to TUFLOW users include:
- Being able to work with TUFLOW models using open source GIS on all major operating systems
- A full GIS application to support their data pre-processing
- Logical and intuitive workflows
- Visualisation and post-processing of TUFLOW results natively in QGIS via mesh layer
- The development allows interactive plotting features for 3D results, such as 3D profiles and curtains that can be easily extracted, providing an improved user experience
- Ability to use all native QGIS support and development channels in addition to TUFLOW support
- Integration of internal workflows with powerful native QGIS features including projection support, GDAL/OGR integrations, background maps support (e.g. vector tiles) and printed flood maps.
Further Reading
Do you have any questions or would like to see a demo of the QGIS Mesh Layer? Contact us at info@lutraconsulting.co.uk or schedule a demo call calendly.com/saber-razmjooei/15min
Key words
QGIS, migration, optimised, speed up, fast, hydraulic modelling, water, 2D, 3D, open-source, cost reduction, software development, TUFLOW, TUFLOW FV
You may also like... Input, a field data collection app based on QGIS. Input makes field work easy with its simple interface and cloud-based sync. Available on Android and iOS.
17 August 2021
2:00
EOX' blog: Average colors of the world
sur Planet OSGeo

*Couple of weeks ago we have noticed the article getting attention around twitter. As it is using our WMS EOxMaps endpoint we have asked Erin Davis if we could host her idea here. At EOX we endorse brilliant and unique ideas that utilize our tools and data. Thank you for this most interesting contri ...
02 August 2021

2:00

Ecodiv.earth: Compute surface area per region

sur Planet OSGeo

The question

Suppose I have a categorical raster layer. Now I want to create a second raster layer with values that represent the surface area of the categories in the first layer. Below, I test four different methods to see which of these is the fastest.

The first three methods result in a raster layer with values that represent the surface area of the categories (A in figure 1). The fourth option calculates the area for each group of cell that form physically discrete areas (B in figure 1). You can achieve the same with the first three options by first recategorizing the contiguous areas into unique categories. You can do that with the function r.clump.

The raster layer in the left upper corner shows the distribution of two categories, 1 and 2. In the first three options discussed in this post, the surface area is computed per category (A). The fourth option calculates the surface area per physically discrete areas with the same category (B).

Figure 1: The raster layer in the left upper corner shows the distribution of two categories, 1 and 2. In the first three options discussed in this post, the surface area is computed per category (A). The fourth option calculates the surface area per physically discrete areas with the same category (B).

I provide the Python code using the grass.script library, but of course, you can run the same from the command line or using the menu. For the examples, I use the landclass96 raster layer from the North Carolina dataset. You can download the dataset here.

r.area & r.mapcalc

We can use the r.area addon to create a raster layer with values representing the size of the categories in the category_map in terms of number of cells. Next, we multiply this with the surface area per raster cell using r.mapcalc.

# Import the libraries
import grass.script as gs
import datetime

# Set the region
gs.run_command("g.region", raster="landclass96")

# Compute the area per category (repeat 25 times)
begin_time = datetime.datetime.now()

for i in range(1,25):
    # Area per categories (number of cells)
    output1 = "test0_{}a".format(i)
    output2 = "test0_{}b".format(i)
    gs.run_command("r.area", input="landclass96", output=output1)

    # Convert number of cells to m2
    expr = expression="{} = {} * area()".format(output2, output1)
    gs.run_command("r.mapcalc", expression=expr)

# Print the runtime in seconds
runtime01 = (datetime.datetime.now() - begin_time).total_seconds()
print("The runtime is {} seconds".format(runtime01))

# Clean up
gs.run_command("g.remove", flags="f", type="raster", pattern="test0_*",
               quiet=True)

The runtime is 5.03994 seconds

r.stats and r.recode

We can use the r.stats function to compute for each raster category the area. Based on these values, we can then create a recode string and use this as input in the r.recode function to create the map with the surface area per category.

import grass.script as gs
import datetime

def surfaceArea(input, output):
  """ Compute a raster layer with for each raster cell the surface area of the
  category it belong to
  """
  # Compute the area per category
  p = gs.read_command("r.stats", flags="an", input=input, 
                      separator=";").split("\n")
  p = [i.replace('\r', '') for i in p]
  p[:] = [x for x in p if x]
  p = [i.split(";") for i in p]
  
  # Create the recode rules
  a = []
  for i in range(0, len(p)):
      sarea = float(p[i][1])
      a.append("{0}:{0}:{1}".format(p[i][0], sarea))
  rules = "\n".join(a)
  
  # Recod input raster map based on recode rules.
  gs.write_command("r.recode", input=input, output=output, 
                   rules="-", stdin=rules)

# Compute the area per category (repeat 25 times)
begin_time = datetime.datetime.now()

for i in range(1,25):
    # Area per categories (number of cells)
    output1 = "test0_{}".format(i)
    surfaceArea("landclass96", output1)

# Print the runtime in seconds
runtime01 = (datetime.datetime.now() - begin_time).total_seconds()
print("The runtime is {} seconds".format(runtime01))

# Clean up
gs.run_command("g.remove", flags="f", type="raster", pattern="test0_*",
               quiet=True)

The runtime is 4.110168 seconds

It runs faster than the previous options. I am not sure if the number of categories will make a difference though.

r.mapcalc & r.stats.zonal

The third options uses the r.mapcalc and r.stats.zonal functions. First we compute the area of each raster cell. Next, we sum all these values per category.

# Import the libraries
import grass.script as gs
import datetime

# Set the region
gs.run_command("g.region", raster="landclass96")

# Compute the area per category (repeat 25 times)
begin_time = datetime.datetime.now()

for i in range(1,25):
    # Area per categories (number of cells)
    output1 = "test0_{}a".format(i)
    output2 = "test0_{}b".format(i)
    gs.run_command("r.mapcalc", expression = "{} = area()".format(output1))
    gs.run_command("r.stats.zonal", base="landclass96", cover=output1,
                   method="sum", output=output2)

# Print the runtime in seconds
runtime01 = (datetime.datetime.now() - begin_time).total_seconds()
print("The runtime is {} seconds".format(runtime01))

# Clean up
gs.run_command("g.remove", flags="f", type="raster", pattern="test0_*",
               quiet=True)

The runtime is 5.289945 seconds

Slightly slower than the first option. The difference is small, so I ran both options a number of times. Results showed that this option is consistently slower than the first option.

r.to.vect & v.to.db

The fourth option is different, in that the raster layer is converted to a vector layer first, using r.to.vect. Then, the v.to.db function is used to calculate the area per polygon. These values will be used as source for the raster values when converting the vector layer back to a raster layer using the v.to.rast function. Note that this means that areas are calculated for the continuous cluster of cells with the same categories (B in figure 1).

# Import the libraries
import grass.script as gs
import datetime

# Set the region
gs.run_command("g.region", raster="landclass96")

# Compute the area per category (repeat 25 times)
begin_time = datetime.datetime.now()

for i in range(1,25):
    # Area per categories (number of cells)
    output1 = "test0_{}a".format(i)
    output2 = "test0_{}b".format(i)
    gs.run_command("r.to.vect", input="landclass96", output=output1,
                   type="area")
    gs.run_command("v.to.db", map=output1, option="area", columns="area",
                   units="meters")
    gs.run_command("v.to.rast", input=output1, output=output2, 
                   use="attr", attribute_column="area", memory=2000)

# Print the runtime in seconds
runtime01 = (datetime.datetime.now() - begin_time).total_seconds()
print("The runtime is {} seconds".format(runtime01))

# Clean up
gs.run_command("g.remove", flags="f", type="all", pattern="test0_*",
               quiet=True)

The runtime is 81.037101 seconds

This option is clearly much slower. However, when you need to compute multiple statistics per area, if you need to do some follow up calculations, or if you need a vector layer as output, this might still be a good option.

Summary

The combination of r.stats and r.recode is the fastest option. It requires a bit more of coding, but that’s just part of the fun, isn’t it :-). The fourth option is clearly slower, which is largely due to/from the raster to vector conversion. Currently this Google of Summer project works on the parallelization of existing modules for GRASS GIS, including the r.to.* modules. So this may improve in the near feature.

grass.script api

The grass.script package offers a wrapper code to run the same code you would run on the command line. You first need to import the package. In de code below, it is imported under the name gs. Next, you can run the functions you have seen above, using the run_command(). The general syntax is:

gs.run_command('module.name', option1=value1, option2=..., flags='flagletters')

For example, you can use the following code to print the region settings (extent, resolution) and save it under the name 'myregion'.

import grass.script as gs
gs.run_command('g.region', flags='p', save="myregion")

There are also other functions besides run_command(), including read_command(), write_command() and parse_command(). Read more about the Python interface to scripting in the manual.

01 August 2021
22:58
From GIS to Remote Sensing: Image Conversion to Reflectance using the Semi-Automatic Classification Plugin version 7
sur Planet OSGeo

This tutorial is about the image conversion to Radiance at the Sensor’s Aperture or to Top Of Atmosphere (TOA) Reflectance. It is assumed that one has the basic knowledge of SCP and Basic Tutorials.
SCP includes several tools for preprocessing images such as Landsat, Sentinel-2, Sentinel-3. Using satellite images from various sources could require the preprocessing and radiometric correction.
Usually, remote sensing images are delivered as calibrated Digital Numbers (DN), and the conversion to radiance or reflectance can be performed through parameters that are provided with the image.
This tutorials aims to describe how to perform the conversion to TOA reflectance of remote sensing images. The calculation can be performed for all the bands at once in Band calc, knowing the required parameters.

Following the video of this tutorial.

Read more »
2:00
GRASS GIS: Installing GRASS GIS extensions currently failing on some systems
sur Planet OSGeo

Due to a long-term planned re-structuring of the addon repository, the installation of addons through g.extension is currently not working on UNIX-like systems. Installation of addons with the current stable version GRASS GIS 7.8.5 on OSGeo4W (Version 1) is not affected. All the necessary changes in g.extension have been implemented, merged and back-ported. The functionality will be back to normal very soon with the upcoming GRASS 7.8.6 and 8.0.0 releases.
29 July 2021
11:00
CARTO Blog: Extending Spatial Analytics on Snowflake with CARTO
sur Planet OSGeo

Exciting news for Snowflake users! As part of our commitment to enabling geospatial analysis natively within the cloud, today we are announcing the launch of our Spatial Ex...
28 July 2021
22:53
Stefano Costa: IOSACal 0.5, featuring IntCal20 and more
sur Planet OSGeo
After three years of slow paced development, IOSACal 0.5 is here.

As before, the preferred installation method is with pip in a virtual environment. The documentation is at [https:]]

This release brings the new IntCal20 calibration data and several improvements for different use cases, plus one important bug fix. Apart from myself, there were two contributors to this release, I’m grateful to Karl Håkansson and Wesley Weatherbee for their work.

These are the highlights from the release notes:
- the project has moved to Codeberg for source code hosting and issue tracking. The new Git repository is at [https:]] with a default branch name of main
- there is an official Code of Conduct that all contributors (including the maintainter) will need to follow, based on Contributor Covenant
- the documentation has seen some improvements, in particular in the Contributing section. Overall, making contributions easier from both expert and novice users is a major theme in this release.
- interactive use in Jupyter notebooks is made easier with CalibrationCurve that can be created in many ways (such as loading from an arbitrary file, or from a standard calibration curve called by shorthand)
- fixed a bug that made plots with AD/CE setting incorrect (contributed by Karl Håkansson)
- fixed a bug that caused a wrong plot density function for dates 80 BP to 0 BP (contributed by Karl Håkansson)
- add IntCal20 calibration data (contributed by Wesley Weatherbee)
On the technical side:
- the command line interface is now based on the Click library
- most code is now covered by tests, based on pytest
- Python 3.6 or above required
- requires Numpy 1.18 and Matplotlib 3.0
I don’t have big plans for the next release. I would like to add more tests, modernize the code and make it easier to adapt / tinker with. The only major achievement I’m looking forward to is to submit an article about IOSACal to the Journal of Open Source Software.
17:59
Free and Open Source GIS Ramblings: Great label callout lines
sur Planet OSGeo

One of the new features in QGIS 3.20 is the option to trim the start and end of simple line symbols. This allows for the line rendering to trim off the first and last sections of a line at a user configured distance, as shown in the visual changelog entry.

This new feature makes it much easier to create decorative label callout (or leader) lines. If you know QGIS Map Design 2, the following map may look familiar – however – the following leader lines are even more intricate, making use of the new trimming capabilities:

To demonstrate some of the possibilities, I’ve created a set of four black and four white leader line styles:

You can download these symbols from the QGIS style sharing platform: [https:]] to use them in your projects. Have fun mapping!
11:00
CARTO Blog: CKDelta’s international human mobility data now available in CARTO
sur Planet OSGeo

Over the past year the importance of human mobility data has increased significantly, not only as a means to analyze how to mitigate the spread of Covid; but more recently ...
27 July 2021
12:00
CARTO Blog: Making Human Mobility Models Fair, Inclusive, & Private
sur Planet OSGeo

Late in 2020, we announced the creation of CARTO’s Scientific Committee to double down on our efforts to make the work of Spatial Data Scientists more productive and to hel...
11:00
CARTO Blog: Announcing CARTO’s Return to In-Person Events
sur Planet OSGeo

After more than a year of virtual events, we are very pleased to announce that we will be returning to in-person and hybrid events over the coming weeks and months. We hope...
21 July 2021
8:24
From GIS to Remote Sensing: Major Update: Semi-Automatic Classification Plugin v. 7.9.0
sur Planet OSGeo

This post is about a new update of the Semi-Automatic Classification Plugin v. 7.9.0.
Following the changelog:-preprocessing of Landsat and Sentinel-2 bands are now converted to UInt16 with scale 0.0001 to reduce file size-added Landsat 8 band 1 processing-fixed clip multiple rasters by coordinates-fixed Classification report for degree unit

This update changes the data format of processed Landsat and Sentinel-2 bands, which are are now converted to UInt16 with scale 0.0001 to reduce file size. Basically, this allows to virtually have a Float16 band (instead of Float32) which reduces the files size. The processed bands are now almost half the file size of the bands processed with previous version of the Semi-Automatic Classification Plugin, without any significant loss of information.
Also, the Landsat 8 band 1 has been added to the preprocessing workflow and is now converted to reflectance.Other minor fixes were implemented, and the Semi-Automatic Classification Plugin v. 7.9.0 is compatible with the latest version of QGIS.
For any comment or question, join the Facebook group or GitHub discussions about the Semi-Automatic Classification Plugin.
20 July 2021
7:00
Lutra consulting: MDAL gets adopted as an OSGeo Community Project
sur Planet OSGeo

Mesh Data Abstraction Library MDAL proudly joins the OSGeo Community program

We would like to share the excellent news that the OSGeo incubation committee kindly accepted the MDAL project into its Community Program. MDAL is an MIT Licensed C++ Library which integrates into your QGIS installation and is backed by the Lutra Consulting team and the wider community.

MDAL is a low-level library which allows reading unstructured mesh data from various formats. If you’ve never seen a QGIS Mesh Layer, then check out my presentation at FOSS4G 2019.

We kicked-off the MDAL project at the time we were migrating the Crayfish plugin to QGIS version 3. The Crayfish project started in late 2012, has more than 120,000 downloads and opened the way engineers and data scientists to visualize their hydro and meteo-data in QGIS.

QGIS uses MDAL to visualize, analyze and even modify data on unstructured meshes which are used by many hydraulic / numercial modelling solvers. In addition to providing abstraction for complex mesh data structures, MDAL also allows vectoral (e.g. wind speed) and temporal data to be visualised effectively and easily in QGIS.

The MDAL project (and therefore the wider community) has benefitted from generous sponsors such as TUFLOW, 3Di, Hydrotech, DHI, FLO-2D, Artelia, Federal Ministry of Austria for Agriculture, Regions and Tourism and many others. If you’d like to see your formats or workflows supported by QGIS then please consider becoming a sponsor or contact Peter at peter.petrik@lutraconsulting.co.uk

Right now we’re working on some new mesh frame editing tools for QGIS 3.22 (due for release in autumn 2021) and of course support for additional result file formats.
You may also like... Input, a field data collection app based on QGIS. Input makes field work easy with its simple interface and cloud-based sync. Available on Android and iOS.
6:52
GeoTools Team: GeoTools 25.2 Released
sur Planet OSGeo

The GeoTools team is pleased to announce the release GeoTools 25.2: geotools-25.2-bin.zip geotools-25.2-doc.zip geotools-25.2-userguide.zip geotools-25.2-project.zip GeoTools 25.2 is published to repo.osgeo.org for direct build integration. This release is made in conjunction with GeoServer 2.19.2.Repackaged DownloadsThe above GeoTools downloads have been repackaged to include html readme and
19 July 2021
13:00
Fernando Quadro: Como importar arquivos raster para o PostGIS usando o QGIS
sur Planet OSGeo

No post de hoje irei mostrar como é possível adicionar os seus arquivos raster para o banco de dados PostgreSQL/PostGIS de uma forma rápida e prática utilizando o QGIS.

Para fazer isso, você primeiramente deve instalar o plugin “PostGIS Raster Import“, conforme demonstra a imagem abaixo:

Depois de instalado você irá encontrá-lo no menu Banco de dados (Database) do seu QGIS, veja:

Agora basta você clicar na opção “PostGIS Raster Import”, conforme demostra a tela acima, para que você possa então realizar a importação da sua imagem raster.

É importante ressaltar que antes de abrir a tela acima, você tem que ter realizado os seguintes passos:

1) Configurar a conexão do QGIS com o PostGIS
2) Adicionar a imagem raster no seu Layers List

Feito isso, é só você selecionar a imagem e o banco/schema onde deseja salvá-la e apetar o botão “Upload“.

E aí, não é fácil? Agora basta você entrar no seu banco de dados e ver a tabela referente a sua imagem raster.

Se você quer saber como importar o seu arquivo raster através da linha de comando, clique aqui, e veja o vídeo no YouTube.
18 July 2021
2:00
GeoServer Team: GeoServer 2.19.2 Released
sur Planet OSGeo
We are happy to announce GeoServer 2.19.2 release is available for download (zip and war) along with docs and extensions.

This GeoServer 2.19.2 release was produced in conjunction with GeoTools 25.2, this is a stable release recommended for production systems.

Thanks to everyone who contributed, and to Jody Garnett (GeoCat) for making this release.
Improvements and Fixes
New features are included in this release:
- GEOS-5239 Implement (Krovak) North Orientated projection
Notable improvements:
- GEOS-10149 Improve Catalog Parametrization documentation
- GEOS-10098 Upgrade version of wicket and jquery used by GeoServer
- GEOS-10064 Improving WPS Raster Download - download time
- GEOS-10009 Improve logging on lock providers
Fixes included in this release:
- GEOS-10114 Geofence server UI, error when changing the layerType from layer details tab.
- GEOS-10113 Geofence REST NPE when requesting rule with void Layer details
- GEOS-10037 WMTS Multidimensional extension make layers encoding fail on TileLayers not being GeoServerTileLayers
- GEOS-9804 The default style of the layergroup is propagated in the layer as default style
For details check the 2.19.2 release notes.
About GeoServer 2.19
Additional information on GeoServer 2.19 series:
Release notes ( 2.19.2| 2.19.1 | 2.19.0 | 2.19-RC )
17 July 2021

1:14

Martin Davis: JTS IsValidOp Built Back Better

sur Planet OSGeo

In a previous post I described how the JTS Topology Suite operation IsSimpleOp has been completely rewritten to reduce code dependencies, improve performance, and provide a simpler, more understandable implementation. The post points out that the IsValidOp implementation would benefit from the same treatment. This work has now been carried out, with similar benefits achieved.

The original IsValidOp code used the GeometryGraph framework to represent the topology of geometries. This code reuse reduced development effort, but it carried some serious drawbacks:

The GeometryGraph structure was used for many JTS operations, including overlay, buffer, and spatial predicate evaluation. This made the code complex, hard to understand, and difficult to maintain and enhance
The GeometryGraph structure computes the full topology graph of the input geometry, in order to support constructive operations such as overlay and buffer. This makes it slower and more subject to robustness problems. Non-constructive operations such as IsValidOp and IsSimpleOp can compute topology "on-the-fly", which allows short-circuiting processing as soon as an invalidity is found.

The new IsValidOp implementation is more self-contained, relying only on the noding framework and some basic spatial predicates. Using the MCIndexNoder allows short-circuited detection of some kinds of invalidity, which improves performance. And it will be easy to switch to a different noding strategy should a superior one arise.However, dropping GeometryGraph means that the topology information required to confirm validity needs to be computed some other way. The goal is to compute just enough topological structure to evaluate validity, and do that efficiently on an as-needed basis. This required some deep thinking about validity to pare the topology information required down to a minimum. This was assisted by the extensive set of unit tests for IsValidOp, which ensured that all possible situations were handled by the new logic (although there was an untested situation which uncovered a bug late in development.) The resulting algorithm uses some elegant logic and data structures, which are explained in detail below. OGC ValidityJTS implements the OGC Simple Features geometry model. To understand the validity algorithm, it helps to review the rules of geometry validity in the OGC specification:For non-polygonal geometry types, the validity rules are simple;

Coordinates must contain valid numbers
LineStrings must not be zero-length
LinearRings must be simple (have no self-intersections)

For polygonal geometry, on the other hand, the validity rules are quite stringent (sometimes considered too much so!). The rules are:

Rings must be simple (have no self-intersections)
Rings must not cross, and can touch only at discrete points
Holes must lie inside their shell
Holes must not lie inside another hole of their polygon
The interiors of polygons must be connected
In a MultiPolygon, the element interiors must not intersect (so polygons cannot overlap)
In a MultiPolygon, the element boundaries may intersect only at a finite number of points

Validity Algorithm for Polygonal GeometryThe new IsValidOp uses an entirely new algorithm to validate polygonal geometry. It has the following improvements:

It supports short-circuiting when an invalid situation is found, to improve performance
Spatial indexing is used in more places
The code is simpler and more modular. This makes it easier to understand, and easier to adapt to new requirements (e.g. such as the ability to validate self-touching rings described below)

The algorithm consists of a sequence of checks for different kinds of invalid situations. The order of the checks is important, since the logic for some checks depends on previous checks passing.

1. Check Ring Intersections

The first check determines if the rings in the geometry have any invalid intersections. This includes the cases of a ring crossing itself or another ring, a ring intersecting itself or another ring in a line segment (a collinear intersection), and a ring self-touching (which is invalid in the OGC polygon model). This check can use the robust and performant machinery in the JTS noding package. If an invalid intersection is found, the algorithm can return that result immediately.

Kinds of invalid intersections: (i) a self-touch; (ii) collinear; (iii) segment crossing; (iv) vertex crossing

This check is an essential precursor to all the remaining checks. If a geometry has no invalid intersections this confirms that its rings do not self-cross or partially overlap. This means that the results of orientation and point-in-polygon computations are reliable. It also indicates that the rings are properly nested (although it remains to be determined if the nesting of shells and holes is valid).

Intersection search is the most computationally expensive phase of the algorithm. Because of this, information about the locations where rings touch is saved for use in the final phase of checking connected interiors.

2. Check Shell and Hole nestingIf no invalid intersections are found, then the rings are properly nested. Now it is necessary to verify that shells and holes are correctly positioned relative to each other:

A hole must lie inside its shell
A hole may not lie inside another hole.
In MultiPolygons, a shell may not lie inside another shell, unless the inner shell lies in a hole of the outer one.

Ring position can often be tested using a simple Point-In-Polygon test. But it can happen that the ring point tested lies on the boundary of the other ring. In fact, it is possible that all points of a ring lie on another ring. In this case the Point-In-Polygon test is not sufficient to provide information about the relative position of the rings. Instead, the topology of the incident segments at the intersection is used to determine the relative position. Since the rings are known to not cross, it is sufficient to test whether a single segment of one ring lies in the interior or exterior of the other ring.

MultiPolygon with an element where all vertices lie on the boundaryChecking nesting of holes and shells requires comparing all interacting pairs of rings. A simple looping algorithm has quadratic complexity, which is too slow for large geometries. Instead, spatial indexes (using the STRtree) are used to make this process performant. 3. Check Connected Interior

The final check is that the interior of each polygon is connected. In a polygon with no self-touching rings, there are two ways that interior disconnection can happen:

a chain of one or more touching holes touches the shell at both ends, thus splitting the polygon in two
a chain of of two or more touching holes forms a loop, thus enclosing a portion of the polygon interior

To check that these conditions do not occur, the only information needed is the set of locations where two rings touch. These induce the structure of an undirected graph, with the rings being the graph vertices, and the touches forming the edges. The situations above correspond to the touch graph containing a cycle (the splitting situation is a cycle because the shell ring is also a graph vertex). (Equivalently, the touch graph of a valid polygon is a tree, or more accurately a forest, since there may be sets of holes forming disconnected subgraphs.) So a polygon can be verified to have a connected interior by checking that its touch graph has no cycles. This is done using a simple graph traversal, detecting vertices (rings) which are visited twice.

Situations causing a disconnected interior: (i) a chain of holes; (ii) a cycle of holesIf no invalid situations are discovered during the above checks, the polygonal geometry is valid according to the OGC rules.

Validity with Self-touching RingsSome spatial systems allow a polygon model in which "inverted shells" are valid. These are polygon shells which contain a self-touch in a way that encloses some exterior area. They also allow "exverted holes", which contain self-touches that disconnect the hole into two or more lobes. A key point is that they do not allow "exverted shells" or "inverted holes"; self-touches may disconnect the polygon exterior, but not the interior. Visually this looks like:

Left: Inverted shell and exverted hole (valid)Right: Exverted shell and inverted hole (invalid)
This kind of topology is invalid under the OGC polygon model, which prohibits all ring self-intersections. However, the more lenient model still provides unambiguous topology, and most spatial algorithms can handle geometry of this form perfectly well. So there is a school of thought that considers the OGC model to be overly restrictive.To support these systems JTS provides the setSelfTouchingRingFormingHoleValid option for IsValidOp to allow this topology model to be validated. Re-implementing this functionality in the new codebase initially presented a dilemma. It appeared that building the touch graph to check connectivity required computing the geometry of the additional rings formed by the inversions and exversions. This needed a significant amount of additional code and data structures, eliminating the simplicity of the graph-based approach. However, it turns out that the solution is much simpler. It relies on the fact that valid self-touches can only disconnect the exterior, not the interior. This means that self-touches of inverted shells and exverted holes can be validated by the local topology at the self-intersection node. This condition can be tested by the same logic already used to test for nested touching shells. Even better, if the self-touches are valid, then the touch-graph algorithm to check connectivity still works. (This is the same phenomenon that allows most spatial algorithms to work correctly on the inverted/exverted ring model.) Performance

As expected, the new codebase provides better performance, due to simpler code and the ability to short-circuit when an invalidity is found. Here's some performance comparisons for various datasets:

Data	Size	New (ms)	Old (ms)	Improvement
world	244 Polygons, 366K vertices	340	1250	3.7 x
invalid-polys	640 Polygons, 455K vertices	126	334	2.6 x
valid-polys	640 Polygons, 455K vertices	244	487	2 x
australia	1 MultiPolygon, 1,222K vertices	1321	69026	52 x

world is the standard dataset of world country outlines
invalid-polys is a dataset of all invalid polygons. valid-polys is the same dataset processed by GeometryFixer. The timings show the effect of short-circuiting invalidity to improve performance.
australia is a geometry of the Australian coastline and near-shore islands, with 6,697 polygon elements. The dramatic difference in performance reflects the addition of a spatial index for checking nested shells.

Australia and 6,696 islands
Next Steps

The improved IsValidOp will appear in JTS version 1.19. It has already been ported to GEOS, providing similar performance improvements. And since GEOS backs the PostGIS ST_IsValid function, that will become faster as well.

There is one remaining use of GeometryGraph in JTS for a non-constructive operation: the RelateOp class, used to compute all topological spatial predicates. Converting it should provide the same benefits of simpler code and improved performance. It should also improve robustness, and allow more lenient handling of invalid inputs. Watch this space!

16 July 2021
11:00
CARTO Blog: How to Build a Tree Equity Index & Dashboard using BigQuery
sur Planet OSGeo

Like many people who love trees and work in the geospatial field, I was fascinated (and disheartened) by a recent article I read in the New York Times called Since When Hav...
3:52
Tyler Mitchell: New to “geospatial”?
sur Planet OSGeo

This blog post I wrote for Locate Press helps set the stage for those new to the scene of mapping, geography, spatial data, and application development.

The post New to “geospatial”? appeared first on spatialguru.com.
13 July 2021
21:00
MapProxy: New MapProxy 1.13.1 release
sur Planet OSGeo
We are pleased to announce the release of MapProxy 1.13.1.

The latest release is available at: [https:]]

To upgrade within your virtualenv:
```
$ pip install --upgrade --no-deps MapProxy
```
Updated documentation is available at: [https:]]
Improvements
Support cookie management for HTTP sources.
Fixes and changes
Security fix for local file disclosure (#526).
11:00
CARTO Blog: Simplified tileset creation for streamlined app development
sur Planet OSGeo

The demands on Spatial Data Scientists and Developers to produce ever more complex data visualizations and geospatial apps within shorter timeframes are constantly increasi...
12 July 2021
15:42
Fernando Quadro: Curso Online de GeoServer em Agosto
sur Planet OSGeo
Caros leitores,

Gostaria de informá-los que estão abertas as inscrições para mais uma turma do Curso Online de GeoServer que estarei ministrando pela GEOCURSOS. O objetivo do curso é que você aprenda a configurar e compartilhar dados geográficos na internet com o GeoServer. Veja abaixo a nova ementa:
- Introdução aos padrões OGC
- Instalação e configuraç&ao
- Publicação de dados vetoriais
- Publicação de dados PostGIS
- Formatos de saída
- Instalação de Plugins
- Como realizar upgrade de versão
- Cache
- Estilos utilizando SLD
- Substituição de variáveis no SLD
- Utilização da API Rest
- Criação de camadas com SQL View
- Segurança
- Boas práticas
- Preparação do GeoServer para ambiente de produção
- Gerar HeapMap com o padrão WPS
- Como utilizar o plugin Importer
- Aplicação prática com OpenLayers
O curso ocorrerá entre os dias 02 e 12 de agosto das 19:30 as 22:00 (horário de Brasília).

Aqueles que poderem divulgar para seus contatos, agradeço. Quem quiser saber mais informações sobre o curso, pode obtê-las nos seguintes links:
- Site do curso ( [www.geocursos.com.br] )
- Twitter ( [twitter.com] )
- Facebook ( [www.facebook.com] )
- Instagram ( [www.instagram.com] )
11:00
CARTO Blog: #SDSC21: Speak at the largest Spatial Data Science Conference
sur Planet OSGeo

The fifth edition of the Spatial Data Science Conference is fast approaching and we are very excited to be gathering Data Science, Advanced Analytics, & GIS experts fro...
09 July 2021
10:49
geomati.co: Edificios 3D a partir del catastro
sur Planet OSGeo

Estas últimas semanas tuvimos cierta repercusión en redes con una aplicación web ( [https:]] ) que muestra los edificios de toda España en 3D, y permite navegar y simbolizarlos por año de construcción y por uso:

Los edificios de toda España en 3D, simbolizados por años y usos, a partir del catastro [https:]] #GIS #mapping #geomatico #geomaticolabs
— geomatico (@geomati_co) June 2, 2021

¿Cómo la desarrollamos?

Motivación

En geomatico llevamos varios años jugando con los edificios de catastro 3D y de hecho ya teníamos algún visor con toda España. Pero recientemente se generó un poco de hype con unas visualizaciones de cartografía catastral basada en años de construcción y su autor fue Dominic Royé:

El éxito inesperado del mapa de Valencia con muchas peticiones de todos vosotros me ha llevado a ofreceros un formato pdf de Valencia, Barcelona, Madrid y Málaga. ¡Gracias a todos! pic.twitter.com/IetioLkUVj
— Dominic Royé (@dr_xeo) May 4, 2021

Gracias por la motivación Dominic!

Descarga

Catastro ofrece parte de su cartografía (parcelas, edificios y direcciones) mediante un servicio ATOM de descarga.

Para su descarga masiva se empleó la aplicación Catastro Inspire Downloader. Se trata de un desarrollo interno, que liberamos en 2019 bajo licencia GNU, y que permite descargar toda la cartografía inspire de catastro a un geopackage.

Vector Tiles

Para la conversión a MVT, hemos usado ogr2ogr.

Se generaron teselas con cobertura para toda España y con niveles de zoom del 10 al 15. El motivo de empezar en un zoom tan bajo es que queríamos poder mostrar mucha información a la vez y lograr resultados como este:
Oviedo y Gijón a zoom 10
Para poder generar teselas con tanta información hemos tenido que tener mucho cuidado, generando los zooms bajos (10-13) sólo con geometrías de la capa building, y con la capa buildingparts para zooms altos (14 y 15).

Ejemplos de una construcción para cada zoom:
Zoom 10 Zoom 13 Zoom 11 Zoom 15 Zoom 12

Mediante ogr2ogr y su capacidad de ejecutar consultas sql al usarlo, pudimos crear un mbtiles para cada nivel de zoom.

Por último usamos tile-join, que viene incluido en tippecanoe para unir los mbtiles de cada nivel de zoom en una pirámide única.

Y para publicarlo tileserver-gl.

Visor

Finalmente se desarrolló una web basada en MapboxGL y ReactJS, que es el stack que solemos usar en geomatico, con dos estilos de simbolización:
Año de construcción Usos y filtrado por año
Al poderse activar y desactivar capas, permite ver la forma y extensión de cada ciudad en una determinada época.

Además se puede simbolizar por uso por lo que se detectan ejes comerciales o polígonos industriales a simple vista. Para los nostálgicos, los colores de residencial, comercial e industrial coinciden con los de SimCity.

No dudéis en buscar vuestra localidad y viajar por la España del presente o del pasado: [https:]]

La entrada Edificios 3D a partir del catastro se publicó primero en Geomatico.
08 July 2021
11:00
CARTO Blog: The Data Appeal Company POI & Sentiment Data now available in CARTO
sur Planet OSGeo

What influences you the most when it comes to choosing where you might book a table at a restaurant? Is it simply a casual glance at the overall rating of the establishment...
06 July 2021
18:50
GeoSolutions: Free Webinar – Set up and Operate a GeoServer Cluster in K8s
sur Planet OSGeo

You must be logged into the site to view this content.
12:50
Jackie Ng: Announcing: mapguide-react-layout 0.13.3
sur Planet OSGeo
Was I lying when I said I will be taking a short break from all things open source after releasing MapGuide Open Source 4.0 Preview 3?
Technically speaking, no.
This 0.13.3 release is just a few important fixes made since the 0.13.2 release that actually landed a few months ago, but I haven't "pressed the release button" until now. The fixes are:
- A fix for the initialElementVisibility mount option not working for the Aqua template
- A very important fix for inconsistent layer/group state if refreshing the legend after doing some server-side layer/group changes
This release is browser bundle (viewer.zip) only. There is no npm module release for this.
Now back to my self-imposed break.
Download
11:00
CARTO Blog: Z Score Visualization: How to Identify Hotspots with BigQuery
sur Planet OSGeo

Most Data Scientists and Analysts understand that visualizing datasets can be a crucial way for users to engage with data. Knowing where median household income is across a...
05 July 2021
15:38
GeoSolutions: GeoDataLab joins the network of GeoSolutions partners
sur Planet OSGeo

You must be logged into the site to view this content.
02 July 2021
2:00
PostGIS Development: PostGIS 3.1.3
sur Planet OSGeo
The PostGIS Team is pleased to release PostGIS 3.1.3! Best Served with PostgreSQL 14 beta2.

This release is a bug fix release, addressing issues found in the previous 3.1 release.
- #4929, Fix missing error from GetRingEdges when invoked with unexistent topology or edge (Sandro Santilli)
- #4927, Fix PostgreSQL 14 compile FuncnameGetCandidates changes needed to compile against PostgreSQL 14 beta2 or higher (Regina Obe, Julien Rouhaud)
Continue Reading by clicking title hyperlink ..
01 July 2021
11:00
CARTO Blog: Announcing #SDSC21: Telecoms & Utilities Summit
sur Planet OSGeo

Following the success of the two industry-specific #SDSC21 events, the Spatial Data Science in Financial Services Summit & the Spatial Data Science in CPG & Retail ...
30 June 2021
8:29
gvSIG Team: Conociendo la Suite gvSIG: Geomática libre, formación gratuita y casos de éxito alrededor del mundo
sur Planet OSGeo

Ya está disponible la ponencia dedicada a presentar la Suite gvSIG, organizada por SIGGMA Red Global.
29 June 2021
16:41
gvSIG Team: Disponible la ponencia «Rompiendo las barreras ¿necesarias? para implantar con éxito Infraestructuras de Datos Espaciales»
sur Planet OSGeo

En el marco de la Red CYTED IDEAIS (Asistentes Inteligentes para las Infraestructuras de Datos Espaciales) tuvo lugar hace unos días el seminario titulado «gvSIG Online: rompiendo las barreras ¿necesarias? para implantar con éxito Infraestructuras de Datos Espaciales», estando ya disponible la grabación del mismo, para todos aquellos interesados en el tema.

Durante la ponencia se tratan diversos temas, algunos no exentos de polémica, desde la importancia de las IDE a analizar si estas han fracasado, como parece se quiere hacer ver desde ciertos ámbitos de negocio, multinacionales de software privativo de por medio.

Por supuesto, se habla,y mucho, de gvSIG Online y de cómo está solución en software libre está multiplicando la aparición de Infraestructuras de Datos Espaciales en todo tipo de ámbitos y geografías.

Si os he despertado el interés, podéis ver la ponencia completa aquí:
28 June 2021
8:50
gvSIG Team: Sistema de administración de información topográfica en la Secretaría de Obras y Servicios (SOBSE) del Gobierno de Ciudad de México
sur Planet OSGeo

Hoy os traemos otro proyecto resultante de la colaboración entre la Asociación gvSIG y la Universidad Autónoma del Estado de México, en este caso realizado con gvSIG Online. La alumna, María Fernanda Cruz Gutiérrez, ha aprovechado sus prácticas profesionales para poner en marcha un sistema de administración de información topográfica en la Secretaría de Obras y Servicios (SOBSE) del Gobierno de Ciudad de México, mediante el uso de una Infraestructura de Datos Espaciales con tecnología gvSIG Online.

El proyecto se planteó para solucionar la problemática que enfrenta la SOBSE, que de manera continua genera nueva información, debido al constante cambio de la infraestructura en la ciudad, sin contar con un registro controlado de todos los proyectos y, por tanto, no existiendo un sistema que indique la existencia y el avance de dichos proyectos.

Para este proyecto se utilizó la información del proyecto Bosque de Chapultepec, ya que actualmente, el Gobierno de la Ciudad de México lleva acabo el Plan Maestro para la mejora y rehabilitación de este emblemático espacio para los mexicanos y pulmón para el mundo.

Damos acceso al documento que explica toda la problemática y proceso seguido con gvSIG Online para la puesta en marcha de la solución, junto un enlace a un geoportal resultante del trabajo.

Documentación / tutorial

Geoportal
27 June 2021
13:18
Free and Open Source GIS Ramblings: QGIS Atlas on steroids
sur Planet OSGeo

Today’s post is a video recommendation. In the following video, Alexandre Neto demonstrates an exciting array of tips, tricks, and hacks to create an automated Atlas map series of the Azores islands.

Highlights include:

1. A legend that includes automatically updating statistics

2. A way to support different page sizes

3. A solution for small areas overshooting the map border

You’ll find the video on the QGIS Youtube channel:

This video was recorded as part of the QGIS Open Day June edition. QGIS Open Days are organized monthly on the last Friday of the month. Anyone can take part and present their work for and with QGIS. For more details, see [https:]]
25 June 2021
18:58
Oslandia: (Fr) QSoccer : QGIS, football, what else ?
sur Planet OSGeo

Enclosure: [download]

Sorry, this entry is only available in French.
11:00
CARTO Blog: How to Visualize Urban Growth with Spatial Extension for BigQuery
sur Planet OSGeo

The urban growth of metropolitan areas around the world can be affected by a number of factors. During the industrial revolution the explosion in job availability fueled mu...
24 June 2021
11:00
CARTO Blog: Delivering Geospatial Datasets on the Leading Cloud Data Platforms
sur Planet OSGeo

The CARTO Data Observatory continues to evolve, giving Developers and Spatial Data Scientists unparalleled access to thousands of curated public and premium location based ...
23 June 2021
9:58
GeoTools Team: GeoTools 24.4 released
sur Planet OSGeo

The GeoTools team is pleased to share the availability of GeoTools 24.4 :geotools-24.4-bin.zip geotools-24.4-doc.zipgeotools-24.4-userguide.zipgeotools-24.4-project.zipThis release is published to the osgeo maven repository, and is made in conjunction with GeoServer 2.18.4. This is a maintenance release and is a recommended upgrade for all users of the GeoTools library.We would like to
2:00
GeoServer Team: GeoServer 2.18.4 Released
sur Planet OSGeo
We are happy to announce GeoServer 2.18.4 release is available for download (zip and war) along with docs and extensions.

This GeoServer 2.18.4 release was produced in conjunction with GeoTools 24.4 and GeoWebCache 1.18.4. This is a maintenance release recommended for production systems.

Thanks to everyone who contributed, and to Alessandro Parma (GeoSolutions) and Andrea Aime (GeoSolutions) for making this release.
Improvements and Fixes
This release includes support for the Krovak North Orientated projection. In addition to this new features, a few notable improvements are included:
- Upgrade version of wicket and jquery used by GeoServer.
- SLDService can now limit max unique values for uniqueInterval classification vector data (to avoid generating too many rules).
- Better logging in lock management and parameters extractor
Fixes included in this release:
- GEOS-10057 Escape style editor page user input
- GEOS-10056 Rename schemaless-mongo plug-in to mongodb-schemaless
- GEOS-10055 Escape SRS demo page user input
- GEOS-10051 Fix edge cases in the elevation parser
- GEOS-10049 Schemaless-features layer with name different from the mongo collection throws exception
- GEOS-10048 Schemaless-features mongoDB layer not present in WMS capabilities
- GEOS-10031 GWC loses GridSets bounds when importing data through the Importer plugin.
- GEOS-9748 Rendering process fails if vendor option sortByGroup is used
For details check the 2.18.4 release notes.
About GeoServer 2.18
Additional information on GeoServer 2.18 series:
- State of GeoServer 2.18 (slides)
- GeoServer Orientation (slides|video)
- Release Notes ( 2.18.4 | 2.18.3 | 2.18.2 | 2.18.1 | 2.18.0 | 2.18-RC)
2:00
SourcePole: QGIS Cloud: Fixed legend in QGIS Cloud QWC2 with CSS
sur Planet OSGeo

With QGIS Cloud Pro it is possible to change the appearance and behaviour of the QGIS Cloud Web Client via CSS. You can easily manipulate the colour of frames and fonts, etc. An example that is not obvious is displaying the legend in a fixed location on the map. In this way, the legend can be made a fixed part of the map in QGIS Cloud QWC2. In the basic configuration of QGIS Cloud QWC2 the legend of a layer is not permanently displayed.
22 June 2021
9:00
3liz: QGIS Processing R 3
sur Planet OSGeo
Le plugin QGIS Processing R version 3.0
Le plugin QGIS Processing R permet de développer des scripts avec le langage R pour le module traitement de QGIS.

Le plugin QGIS Processing R a été développé suite au travail de réorganisation du code du module traitement de QGIS 3. North Road a extrait et adapté le code du module traitement de QGIS 2 pour QGIS 3.

Une nouvelle version majeure a été publiée. Cette version intègre des améliorations développées par 3Liz sur commande de l'Ifremer pour la plateforme Sextant.

Depuis la version 2.0.0 du plugin QGIS processing R, nous avons réalisé de nombreux correctifs qui concernaient principalement le support des sorties d'algorithme :
- [Bugfix] CSV Output Table destination was not in results
- [BUGFIX] Processing R algorithms do not have enough outputs
- [Bugfix] Support file destination and output
- Folder destination path added in input commands
- Fix return output file destination value
Les améliorations importantes de la version 3.0.0 concernent les possibilités de description des algorithmes :
- Utilisation de la documentation des paramètres depuis le fichier d'aide
- Définition d'une nouvelle ligne de métadonnées display_name pour le libellé de l'algorithme
- Utilisation de la chaîne de caractère de description pour les paramètres des algorithmes
Amélioration de la documentation des scripts
Depuis la version 3.16 de QGIS, il est possible de définir une aide pour les paramètres d'un algorithme. Cette possibilité est disponible pour les plugins ajoutant un fournisseur d'algorithme, les scripts Python et les modèles de traitements.

Avec la version 3.0.0 du plugin QGIS processing R, l'aide pour les paramètres peut-être défini dans le fichier d'aide du script. Ce fichier d'aide est un fichier JSON. Le nom du paramètre sert de clé pour définir l'aide de celui-ci.

Par exemple pour un algorithme dont les paramètres polyg et RPLOTS, le document d'aide contiendra ces clés
```
{
  "ALG_DESC": "Test help.",  // Description de l'algorithme
  "ALG_CREATOR": "Me",  // Créateur de l'algorithme
  "polyg": "A polygon layer", // Aide du paramètre polyg
  "RPLOTS": "Plot output", // Aide du paramètre RPLOTS
  "ALG_HELP_CREATOR": "Me2" // Créateur de l'aide
}
```
L'aide des paramètres apparaitra sous forme de Tooltip des champs de saisie de la fenêtre de l'algorithme. Il sera utilisé comme description des paramètres dans la description des algorithmes publiés en OGC Web Processing Service (wps) avec py-qgis-wps.
Définition du titre de l'algorithme
Le titre d'un algorithme basé sur un script R est défini par le plugin de la façon suivante : 1. Le premier nom possible est déduit du nom du fichier du script R, les _ sont remplacés par des espaces. Le nom du fichier sert d'identifiant pour l'algorithme. 2. Le second nom possible est déduit de la ligne de métadonnées (ligne commençant par ##) name, les _ sont remplacés par des espaces. La valeur de la ligne de métadonnées name sert d'identifiant à l'algorithme. 3. Le troisième nom possible est la valeur de la ligne de métadonnées display_name. L'identifiant de l'algorithme sera la valeur de la ligne de métadonnées name ou le nom du fichier.

Avec la version 3.0.0 du plugin QGIS processing R, il est possible de dissocié clairement le titre de l'algorithme de son identifiant.
Description avancée des paramètres
La description des paramètres d'un algorithme basé sur un script R repose sur les lignes de métadonnées. Ces lignes commencent par ##.

Par défaut la description des paramètres se fait selon la structure imaginée par Victor Olaya pour les scripts Python dans la version pour QGIS 2 du module Traitement. Un paramètre se décrit de la façon suivante param_name=[optional] param_type [default_value/values/from_variable]. Cette structure s'appuie sur la définition des méthodes asScritCode / fromScriptcode des classes de paramètres de Processing (toutes les classes filles de QgsProcessingParameterDefinition).

Les entrées peuvent donc ressembler à ceci :
- ##Layer=vector spécifie qu'il y aura une variable Layer qui sera un couche vectorielle
- ##Size=number 10 spécifie qu'il y aura une variable Size qui sera numérique, et que la valeur par défaut de Size sera 10
- ##X=Field Layer spécifie qu'il y aura une variable X sera le nom du champ pris dans la couche vectorielle du paramètre Layer
Le script R test_algorithm_2.rsx qui permet de tester que le plugin analyse correctement la description des paramètres, présente d'autres exemples de paramètres.

Le défaut de cette description compacte des paramètres est qu'elle ne permet pas de les configurer complètement. Par exemple il n'est pas possible d'ajouter une description ou une aide.

Pour remédier à cela, nous avons décider de réutiliser une autre façon de décrire les paramètres déjà disponible dans le module Traitement de QGIS. Cette description avancée des paramètres a été conçu pour les fournisseur d'algorithmes que sont GDAL, GRASS7, SAGA et Orpheo Toolbox.

Les paramètres sont décrit de la façon suivante QgsProcessingParameter|name|description|other_parameters_separated_by_pipe. other_parameter_separated_by_pipe contient les autres paramètres d'initialisation du paramètre d'entré de l'algorithme.

Les entrées peuvent donc ressembler à ceci :
- ##QgsProcessingParameterFeatureSource|INPUT|Vector layer spécifie qu'il y aura une variable INPUT qui sera un couche vectorielle dont la description est Vector layer
- ##QgsProcessingParameterNumber|SIZE|Aggregation Size|QgsProcessingParameterNumber.Integer|10 spécifie qu'il y aura une variable Size qui sera numérique de type entier, que sa description est Aggregation Size, et que la valeur par défaut de Size sera 10
- ##QgsProcessingParameterField|FIELDS|Attributes|None|INPUT|-1|False|False spécifie qu'il y aura une variable FIELDS sera le nom du champ pris dans la couche vectorielle du paramètre INPUT et que sa description est Attributes
Le seul défaut de cette façon de décrire les entrées de l'algorithme est qu'elle nécessite de connaître les classes de paramètres de Processing (toutes les classes filles de QgsProcessingParameterDefinition).
Conclusion
L'ensemble de ces améliorations permettent de construire des algorithmes dont l'interface quelle soit graphique dans QGIS bureautique, en ligne de commande avec qgis_process, ou en mode Web avec la norme WPS et py-qgis-wps, est plus conviviale pour les différents utilisateurs.

D'ailleurs les procédés mise en oeuvre au sein du plugin QGIS Processing R pourrait très bien être adapté à d'autres langages de programmation comme Julia.
9:00
3liz: QGIS Processing R 3
sur Planet OSGeo
QGIS Processing R plugin version 3.0
The QGIS-processing-R plugin, let's you write R scripts to be processed by/in QGIS

The QGIS-processing-R plugin was developed after some refactoring of teh qgis processing in QGIS 3. North Road adapted and reused some of the QGIS 2 code to make this happen in QGIS 3.

A new major version was released. This version contains fixes developed by 3liz for Ifremer's Sextant platform.

Since version 2.0.0 of QGIS-processing-R, we've fixed mostly output related bugs :
- [Bugfix] CSV Output Table destination was not in results
- [BUGFIX] Processing R algorithms do not have enough outputs
- [Bugfix] Support file destination and output
- Folder destination path added in input commands
- Fix return output file destination value
The major addenda to version 3.0.0 are based around description of the algorithms:
- Documentation of the parameters from the help file
- New metadata entry display_name for the name of the algorithm
- Usage of the description string as a parameter of the algorithms.
Better Scripts documentation
Since version 3.16 of qgis, it is possible to define help for the parameter of an algorithm. This feature is available for plugins providing algorithm, python scripts and processing models.

Version 3.0.0 of the R processing qgis plugin, parameter help can be defined in the help file for said scripts. The help file is a json file. The name of the parameter is the key to define its help.

Let's look at an example for an algorithm whose parameters and polyg and RPLOTS, the help file would contain the following keys:
```
{
  "ALG_DESC": "Test help.",  // Algorithm's description
  "ALG_CREATOR": "Me",  // Algorithm's creator
  "polyg": "A polygon layer", // polyg parameter help
  "RPLOTS": "Plot output", // RPLOTS parameter help
  "ALG_HELP_CREATOR": "Me2" // Algorithm help's creator
}
```
The help for parameter will appear in the form of a tooltip on the input field in the window of the algorithm. It will be used as a description for the parameters in the algorithm published as an OGC Web Processing Service WPS with py-qgis-wps.
Defining the algorithm title
The title of a R script algorithm is defined like so by the plugin:
1. The first possible title is based on the name of the R script file _ are replaced by spaces. The file name also serves as an ID for the algorithm.
2. The second possible title is read from the metadata (lines starting with ## ) name, as above the _ are replaced by spaces. The name metadata serves as an ID for the algorithm.
3. THe third and last possibility is the display_name metadata entry. The ID will either be deducted from the file name or the name metadata.
With version 3.0.0 of the R processing qgis plugin, you can clearly identify the algorithm tile and its ID.
Advanced parameter description
Parameter description in a R based algorithm rely on metadata. These lines start with ##.

Parameter description use the structure developed by Victor Olaya in the QGIS 2 of the processing module. A parameter is explained with the following metadata sequence param_name=[optional] param_type [default_value/values/from_variable]. This structure relies onf the asScritCode / fromScriptcode from the processing class parameters (all the children classes of QgsProcessingParameterDefinition).

Entries can look like this
- ##Layer=vector there will be a Layer parameter and it will be a vector layer
- ##Size=number 10 there will be a Size parameter, it will be a numeric value and it's default value will be 10
- ##X=Field Layer There will be a variable named X whose field name will be taken from the Layer parameter
The R script test_algorithm_2.rsx let you test the plugin and will properly analyse parameter descriptions. It also contains other parameter examples.

There is one issue with this compact description of parameters : it's incomplete. For instance, you can't add a description, or an help entry.

To fix this, we decided to follow what other processing modules for QGIS were particularly : GDAL, GRASS7, SAGA and Orpheo Toolbox.

Parameters are described as such QgsProcessingParameter|name|description|other_parameters_separated_by_pipe. other_parameter_separated_by_pipe contains the other initialization parameter for the algorithm.

Entries can look like this:
- ##QgsProcessingParameterFeatureSource|INPUT|Vector layer There will be an INPUT variable. INPUT is a vector layer and it's description is Vector Layer.
- ##QgsProcessingParameterNumber|SIZE|Aggregation Size|QgsProcessingParameterNumber.Integer|10 A numeric variable named Size, whose description will be Aggregation Size a and default value will be 10.
- ##QgsProcessingParameterField|FIELDS|Attributes|None|INPUT|-1|False|False Specifies that there is a FIELDS variable whose name will be taken from the INPUT vector parameter, and it's description is Attribute.
The only issue with this technique is that you eed now all the classes for Processing parameters (all the children classes of QgsProcessingParameterDefinition)
To conclude
All these features will let you build algorithms, that will be way easier to use either on the desktop, command line with qgis_process or using the web with WPS and py-qgis-wps.

What we did to have R scripts in QGIS-processing-R could be adapted to other programming languages like Julia.
21 June 2021
11:00
CARTO Blog: Authoritative Environmental Remediation Mapping in NYC
sur Planet OSGeo

This post was originally published on eSpatially New York by Sam Wear and has been reproduced with permission.
11:00
CARTO Blog: Join CARTO at Mobile World Congress MWC21 Barcelona
sur Planet OSGeo

With in-person events making a welcome return this year, we are very pleased to announce that CARTO will be attending Mobile World Congress (MWC) Barcelona taking place nex...
20 June 2021
20:33
gvSIG Team: VCSGis I, usando un control de versiones con mi información cartográfica personal.
sur Planet OSGeo
¿Quién no ha tenido que recurrir a una copia perdida, en alguna carpeta del ordenador, con nuestros datos, para rescatar información tal y como estaba hace unos meses? No es que sea algo que ocurra todos los días, pero de vez en cuando se da y entonces suele causarnos algún dolor de cabeza. Y más aún si solo tenemos que recuperar algunos registros de una capa que borramos o modificamos hace semanas por accidente y queremos recuperar solo esos.

En los últimos años, en otros contextos que no están relacionados con la gestión de cartografía, ya va siendo normal encontrarnos con sistemas de control de versiones (VCS, del inglés Version Control System) para gestionar la información. Sin embargo, en los entornos SIG, no es tan habitual, sobre todo por la escasa o nula oferta que podemos encontrar en entornos no privativos. Pues bien, a partir de gvSIG Desktop 2.6 podremos disponer de un sistema de control de versiones, VCSGis, en un software libre y que podremos utilizar directamente sin instalar nada más que el propio gvSIG Desktop.

Entonces, si tengo instalado (o una portable) gvSIG Desktop 2.6…

¿Cómo puedo empezar a usar el control de versiones sobre mis tablas y capas ?
- Lo primero será crear un repositorio para el control de versiones. Algo así como un espacio en el que se almacenarán todos mis datos… y los cambios que voy haciendo sobre ellos. En jerga gvSIG le llamaremos un repositorio VCSGis
- Lo segundo, crear una copia de trabajo vinculada a dicho repositorio. Será sobre esa copia de trabajo sobre la que trabajaremos habitualmente.
- Tercero… cargar nuestras tablas y capas en la copia de trabajo y sincronizarla con el repositorio VCSGis.
A partir de ahí, simplemente seguiremos trabajando de forma normal con gvSIG Desktop e iremos sincronizando con el repositorio de vez en cuando, normalmente al inicio o fin de nuestra sesión de trabajo.

Esto, dicho así, a algunos podrá parecerles algo complicado, pero nada mas lejos de la realidad. Voy a ir contándolo con un poquito mas de detalle en este post, solo un poquito, que no quiero alargarme demasiado.

Creación de un repositorio personal

El repositorio VCSGis no es más que una base de datos con una serie de tablas especiales, donde VCSGis almacena nuestra información. Para nuestro uso personal, normalmente será suficiente con usar el gestor de base de datos H2 que viene incluido con gvSIG Desktop. Para ello, simplemente accederemos al menú:
```
Herramientas -> VCSGis -> Administración -> Inicializar un repositorio.
```
Nos solicitará que seleccionemos una conexión a una base de datos e inicializará el repositorio VCSGis en ella.

Creación de una copia de trabajo

Lo segundo que teníamos que hacer… crear una copia de trabajo vinculada a ese repositorio. La copia de trabajo no es más que otra base de datos, normalmente en formato H2Spatial, donde estarán nuestras tablas, con las que trabajaremos, y una serie de tablas para poder mantener la información sincronizada con el repositorio.

Crear una copia de trabajo es también una tarea muy sencilla. Accederemos a la opción de menú:
```
Herramientas -> VCSGis -> Inicializar copia de trabajo.
```
Nos pedirá que seleccionemos la conexión a la base de datos del repositorio, y un nombre de archivo en el que crear nuestra copia local.

Estos dos pasos, crear el repositorio y la copia local, normalmente los haremos una sola vez. Una vez ya creados y configurados, podemos trabajar con ellos, sin necesidad de volver a crear otros.

Añadir capas y guardarlas en el repositorio

Ya tenemos nuestro repositorio y nuestra copia de trabajo. Solo hemos tardado unos pocos minutos. Ahora cargaremos nuestras capas en la copia local y las sincronizaremos con el repositorio.

Cargaremos en una Vista nuestra capa… por ejemplo, yo tengo por aquí una de provincias de España (esp_provincias). No voy a contar como cargar una capa en una Vista de gvSIG Desktop, seguro que ya sabéis. Con la capa cargada en la Vista, seleccionaremos la opción de menú:
```
Herramientas -> VCSGis -> Añadir a la copia de trabajo.
```
En el cuadro de diálogo que se muestra indicaremos nuestra copia de trabajo y, en la pestaña Capas, seleccionaremos la capa que queremos cargar de entre las existentes en la Vista de gvSIG Desktop. Y, por último, pulsaremos el botón de “Añadir a la copia de trabajo”. Una vez terminado el proceso, cerraremos el diálogo.

Como resultado tendremos cargada en la Vista nuestra capa… ¡¡ dos veces !!

Es normal. Estamos viendo nuestra capa original y una copia que se ha creado en… nuestra copia de trabajo. Eliminaremos la capa original de la Vista y, a partir de ese momento, trabajaremos con la que está en nuestra copia de trabajo.

Pero aún no hemos terminado del todo este proceso. Todavía tenemos que sincronizar nuestra copia de trabajo con el repositorio. Algo que sigue siendo muy fácil. Seleccionaremos la opción de menú:
```
Herramientas -> VCSGis -> Mostrar cambios
```
Seleccionaremos nuestra copia de trabajo y veremos, en la pestaña Copia de trabajo, que aparece la capa que acabamos de añadir. Solo tenemos que marcarla (haciendo clic en el check de esta), y pulsar el botón con la flechita azul que dice “commit”. Y al terminar ya podemos cerrar la ventana.

Guardar mi capa de Provincias en el repositorio ha llevado menos de un minuto. Y hacer todos los pasos, desde el comienzo del artículo, me ha llevado menos de 5. Si la capa a añadir a nuestro repositorio personal es muchísimo mas grande puede tardar algo mas, pero solo será durante esa carga inicial donde notaremos la pesadez de la capa.

Realizar modificaciones en nuestras capas

¿Y ahora, qué tendría que hacer para trabajar con mi capa?

Si hemos cerrado gvSIG Desktop, cuando lo volvamos a abrir tenemos que cargar de nuevo la capa. También fácil. Sacaremos el dialogo de Añadir capa y seleccionaremos la pestaña VCSGis. Seleccionaremos nuestra copia local, y nos mostrará las capas que tenemos disponibles, podremos seleccionar la nuestra y cargarla en la Vista.

Una vez cargada… trabajamos con ella como solemos hacer, si precisamos modificarla entramos en edición, la modificamos y terminamos edición. Tantas veces como necesitemos. Durante un rato nos olvidamos que se trata de una capa que esta en un sistema de control de versiones y trabajamos con ella como con cualquier capa de gvSIG en base de datos. Cuando hayamos terminado de trabajar con ella… seleccionamos la herramienta de Mostrar cambios. Indicamos nuestra copia de trabajo, marcamos nuestra capa en la lista de capas de esa copia de trabajo y pulsamos el botón Commit. Como hicimos cuando añadimos la capa al repositorio. Y nuestros cambios se integrarán en él.

El proceso de modificación de nuestra capa, y sincronización con el repositorio, lo repetiremos tantas veces como necesitemos, y de esa forma dispondremos de un histórico de cómo se encontraba la capa en cada momento.

Recuperar una versión anterior de mis datos

Y un día, de repente, nos pasa. ¡Oh! ¡Nos acabamos de dar cuenta que ya debe hacer un par de semanas que borramos un registro!. Debí borrar por error la provincia de Almería, y no me había dado cuenta hasta hoy. Y lo peor es que he estado trabajando sobre otras zonas de la capa y no quiero perder los cambios. Es ahí donde te acuerdas que llevas trabajando un tiempo con un sistema de control de versiones. Y que puedes utilizarlo para recuperar los datos de hace dos semanas y mezclarlos con tus cambios.

En general siempre podrás recuperar una versión de tus capas desde la ventana de “Obtener copia local (checkout)” que encontraras en la opción de menú:
```
Herramientas -> VCSGis -> Obtener copia local (checkout)
```
Pero antes de seguir… asegurate que no tienes cambios por sincronizar con el repositorio, que todos tus cambios sobre la capa que quieres trabajar están guardados, subidos, en el repositorio. Si ya no tienes ningún cambio en tu copia local, volvemos a la ventana de “Obtener copia local (checkout)”.

Seleccionaremos nuestra copia de trabajo, nuestra capa, marcaremos el check de “Sobrescribir tabla”, y pulsaremos en el botón de revisión para seleccionar que revisión queremos recuperar, en mi caso la revisión 1, que era la última en la que aún estaba la provincia de Almería. Finalmente, pulsaremos en el botón de “Obtener copia local (checkout)” y cuando termine, cerraremos este diálogo.

Y ahora… nuestra capa en la copia local está en el estado en que estaba la revisión que he seleccionado… y…

¿Dónde están los cambios que hice desde entonces ?

¡¡¿Los he perdido?!!

No. No hay que asustarse. Están en el repositorio. Solo tenemos que ir a la ventana de cambios, seleccionar nuestra copia de trabajo e ir a la pestaña de Repositorio. Seleccionaremos nuestra capa y pulsaremos en el botón de “Descargar cambios remotos de la tabla seleccionada” y en la tabla de la derecha tendremos todos los cambios que hemos realizado desde la revisión que tenemos ahora en la copia local. Podremos seleccionar cuales queremos descargar y cuales no, y luego subiremos el estado en que dejemos nuestra capa al repositorio.

Una pequeña anotación. Si en la lista de cambios seleccionamos un registro, y tenemos en la Vista activa la capa en cuestión, podemos utilizar los botones Centrar y Zoom, para ver cómo estaba y mostrará la información gráfica del registro.

Lo he contado todo muy rápido, dar una pincelada rápida de lo que sería trabajar con el sistema de control de versiones de gvSIG Desktop VCSGis. Se pueden hacer muchas más cosas de lo que he contado, pero este articulo ya ha salido muy largo. Lo dejamos para futuros post.

Importante de cara a acercarse a VCSGis… dos conceptos a recordar:
- Repositorio VCSGis. Donde se guardan todos nuestros datos.
- Copia de trabajo (ligada a un repositorio). Donde tenemos una copia de una versión de nuestros datos con la que trabajamos.
Y otra cosa importante… si tenemos que hacer copia de nuestros datos lo haremos de la base de datos del repositorio, normalmente dos ficheros (.mv.db y .trace.db) y lo haremos cuando no este gvSIG Desktop arrancado

Espero que os haya servido, o como mínimo que haya sido interesante.
19 June 2021
19:26
Jackie Ng: Announcing: MapGuide Open Source 4.0 Preview 3
sur Planet OSGeo
Here is the long awaited third preview release of MapGuide Open Source 4.0.
Refer to the release notes for download links and an overview of what's new and change since the last preview release.
For MapGuide users on Linux who use Java, you will be glad to hear that Java support is back and fully operational with this release (no more 403 errors from Tomcat). Restoring Java support on Linux came at a small price, we now no longer ship MapGuideApi.jar as the Java wrapper to the MapGuide API. We now only ship MapGuideApiEx.jar which has been in all MapGuide Open Source releases since 2.5 and this wrapper fixes most of the "cruftiness" of the original Java wrapper as described in this RFC where it was first introduced.
For those who like to swap the bundled GDAL dll on windows with a version with an expanded suite of raster/vector driver support, this release will make this process more seamless:
- Our internal GDAL version is now 2.4.4, the latest in the 2.x series.
- Our internal xalan/xerces dlls now have a "fdo" suffix in their dll name, so you are no longer forced to overwrite these dlls when overlaying an external GDAL dll from gisinternals and introduce potential instability as a result.
- All of our FDO providers that link to GDAL/OGR now only use their C API to avoid any potential ABI incompatibilities from replacing our internal GDAL dll with an external one that may not be built with the same MSVC compiler version as ours.
Other than that, Preview 3 is mostly a roll up of fixes to MapGuide/FDO since the last preview release to tide things over while work is still ongoing to support PHP7 in our MapGuide API to clear the obstacle to a final 4.0 release.
But before then, as of this release I will be taking a short break from all things open source. I am mildly burned out all things considered and a good solid month or two away from all things open source should hopefully be enough time to recharge the batteries.
18 June 2021
12:11
gvSIG Team: Clipping overlapping polygons on the same layer
sur Planet OSGeo

Sometimes we can have a layer where we have overlapping polygons, and we need to clip one of them so that there is no overlap (for example a large parcel with an internal parcel, where we really have the polygon of the large parcel without the gap).

For this, the Difference geoprocess can be applied on gvSIG, but with a specific configuration and steps. In this video you can see better how it would be applied:
12:06
gvSIG Team: Recortar polígonos superpuestos en una misma capa
sur Planet OSGeo

En ocasiones podemos tener una capa donde tenemos polígonos superpuestos, y necesitamos que uno de ellos esté recortado para que no haya superposición (por ejemplo una parcela grande con una parcela interna, donde realmente tenemos el polígono de la parcela grande sin el hueco).

Para ello se puede aplicar el geoproceso Diferencia de gvSIG, pero con una configuración específica, y unos pasos concretos. En este vídeo podéis ver mejor cómo se aplicaría:
0:55
GeoTools Team: GeoTools 25.1 Released
sur Planet OSGeo

The GeoTools team is pleased to announce the release GeoTools 25.1: geotools-25.1-bin.zip geotools-25.1-doc.zip geotools-25.1-userguide.zip geotools-25.1-project.zip GeoTools 25.1 is published to repo.osgeo.org for direct build integration. This release is made in conjunction with GeoServer 2.19.1 and GeoWebCache 1.19.1.DuplicatingStyleVisitor vendor optionsThe SLD vendor options
17 June 2021
15:19
GeoSolutions: GeoSolutions Participation at FOSS4G 2021
sur Planet OSGeo

You must be logged into the site to view this content.
11:00
CARTO Blog: CARTO announced as a Google Cloud Edge partner for Communications Service Providers
sur Planet OSGeo

Last year, Google Cloud announced a new initiative bring partner solutions to the network edge, enabling a wide range of clients in industries such as CPG, Retail, and Manu...
16 June 2021
7:00
Lutra consulting: Mergin CE (open source) released
sur Planet OSGeo

We’d like to share some exciting news with you about our cloud-based geo-data synchronisation service, Mergin.

In this post we’ll talk both about Mergin the online managed service (Mergin Cloud) and also about the software stack that powers it (the Mergin Software Stack).
Mergin CE
The Mergin Software Stack has been developed and maintained at Lutra Consulting over the past 3 years to power our Mergin Cloud service and has been maturing nicely in production.

We believe a sync service for supporting field-based GIS activities has been a missing piece of the open geospatial puzzle, and as strong advocates of open source software, we’re now sharing the Mergin Software Stack with the community. Therefore, on the 14th of June we released Mergin CE on GitHub. The CE stands for Community Edition.

The release means a fully open solution for field data collection and synchronisation is now possible using QGIS, Input app and Mergin CE.

Mergin CE is released under the AGPL licence and we are open to contributions from others. Looking forward to seeing what the open source community has to offer!

Mergin CE gives you the freedom to deploy, host and manage your own Mergin server on your own infrastructure, giving you complete control over your data. Mergin CE comes without commercial support.

Our main efforts are still very much focussed on the continuous improvement of Mergin Cloud, making it an awesome fully managed service for our customers.

We also now provide Mergin EE (Enterprise Edition) for those who want an on-premises deployment but with extra features like Active Directory integration, commercial support, and/or prefer a licence other than AGPL.
Changes to Mergin Cloud
Releasing Mergin CE got us taking another look at Mergin Cloud’s Community (free of charge) tier. That’s why from today we’re updating Mergin Cloud’s Terms of Service so its free tier can no longer be used to store projects for commercial use. Mergin accounts storing projects for commercial use should now purchase a paid subscription after their initial 14 day evaluation period.

A common surveying setup is a single paid account (providing extra storage for projects) and a handful of free tier accounts used by surveyors for collecting field data. This is still possible because the new Terms only require that the Mergin account hosting/storing/owning the commercial project has a paid subscription.

For example, consider two users: Fred (who uses a free account) and Penny (who uses a paid account). Penny is permitted to use the project Penny/Survey for commercial purposes as it resides on her paid account. Fred (who uses a free account) is permitted to collaborate on the commercial project Penny/Survey as it resides on Penny’s paid account. However, Fred may not use the project Fred/Survey2 for commercial use as it resides on his free account.

In light of the release of Mergin CE, we feel it is fair to encourage those using Mergin Cloud’s free tier for commercial gain to support us with one of our affordable subscriptions. The link also has a number of frequently asked questions relating to this change.
You may also like... Input, a field data collection app based on QGIS. Input makes field work easy with its simple interface and cloud-based sync. Available on Android and iOS.
15 June 2021
13:53
geomati.co: Adquisición de imágenes satélite de alta resolución, ¡contacte con ventas!
sur Planet OSGeo

Jornadas SIG Libre 2021
La entrada Adquisición de imágenes satélite de alta resolución, ¡contacte con ventas! se publicó primero en Geomatico.
13:09
geomati.co: El servicio para desarrolladores de Transports Metropolitans de Barcelona
sur Planet OSGeo

Jornadas SIG Libre 2021

La entrada El servicio para desarrolladores de Transports Metropolitans de Barcelona se publicó primero en Geomatico.
11:00
CARTO Blog: Analyzing Water Access in Brazil during the COVID-19 Pandemic
sur Planet OSGeo

With over 17 million cases, and close to 500,000 deaths, Brazil has suffered the world’s third worst COVID-19 outbreak outside the United States and India and its second-de...
12 June 2021
16:35
Volker Mische: Video uploads for an online conference
sur Planet OSGeo
This blog post should give some insights on what happens behind the scenes in preparation of an online conference, and I also hope that some of the scripts I created might be useful for others as well. We were using pretalx for the submissions and Seafile for video uploads. Both systems are accessed over their HTTP API.

This year’s FOSSGIS 2021 conference was a pure online conference. Though it had the same format as every year. Three days of conference, with four tracks in parallel. This leads to about 100 talks. I joined the organizing team about 10 weeks before the conference took place. The task sounded easy. The speakers should be able to upload their talks prior to the conference, so that during the conference less could go wrong.

All scripts are available at [https:]] licensed under the MIT License.
The software
The speakers submitted their talks through pretalx, a conference management system I highly recommend. It is open source and has an active community. I’ve worked on/with it over the past few to make it suitable for OSGeo conferences. The latest addition is the public community voting plugin, which has been used for the FOSS4G 2021 as well as this conference. pretalx has a great HTTP API to get data out of the system. It doesn’t yet have much support for manipulating the data, but pull-requests are welcome.

For storing the video files, Seafile was used. I haven’t had any prior experience with it. It took me a bit to figure out, that the Python API is for local access only and that the public API is a pure HTTP API. You can clearly see that their API is tailored to their use in their web interface and not really designed for third party usage. Nonetheless, it guarantees that you can do everything via the HTTP API, that can be done through the web UI.

My scripts are heavily based on command line tools like b2sum, curl, cut, jq and jo, hence a lot of shell is used. For more complex data manipulation, like merging data, I use Python.
The task
The basic task is providing pre-recorded videos for a conference that were uploaded by the speakers themselves. The actual finer grained steps are:
- Sending the speakers upload links
- Looking through the videos to make sure they are good
- Re-organizing the files suitable to be played back according to the schedule
- Make the final files easily downloadable
- Create a schedule which lists the live/pre-recorded talks
Sending upload links
In Seafile you can create directories and make them publicly available so that people can upload files. Once uploaded, you won’t see what else in that directory. In order to be able to easily reference the uploaded videos back to the corresponding talk, it was important to create one dedicated directory per talk, as you won’t know which filenames people will use for their videos.

The speakers will receive an email containing dedicated upload links for each of their talks. See the email_upload_links directory for all the scripts that are needed for this step.
pretalx
First you need to get all the talks. In pretalx that’s easy, go to your conference, e.g. [https:]] . We only care about the accepted talks, which can be done with selecting a filter. If you access it through curl, you’ll get a JSON response like that one: [https:]] . pretalx returns 25 results per request. I’ve created a script called pretalx-get-all.py that automatically pages through all the results and concatenates them.

A talk might be associated with multiple speakers. Each speaker should get an email with an upload link. There were submissions that are not really talks in the traditional sense, so people shouldn’t get an email. The query for jq looks like that:

[.results[] | select((.submission_type[] | contains("Workshop")) or (.submission_type[] == "Anwendertreffen / BoF") | not) | { code: .code, speaker: .speakers[].code, title: .title, submission_type: .submission_type[]}]

The submissions contain only the speaker IDs and names, but not other details like their email address. We query the speakers API (e.g. [https:] and post-process the data again with jq, as we care about their email addresses.

You can find all the requests and filter in the email_upload_links/upload_talks_to_seafile.sh script.
Seafile
Creating and upload link is a two-step process in Seafile. First create the directory, then creating a public accessible upload link for the directory. The directories are named after the pretalx ID of the talk (Full script for creating directories).
Creating emails
After acquiring the data, the next step is to process the data and creating the individual emails. Combining the data is done with the combine_talks_speakers_upload_links.py script, where the output is again post-processed with jq. The data_to_email.py script takes that data output and a template file to create the actual email as files. The template file is used as a Python format string, where the variables a filled with the data provided.

Those email files are then posted to pretalx, so that we can send them over their email system. That step is more complicated as currently there is no API in pretalx to do that. I logged in through the web interface and manually added a new email, while having the developer tools open. I then copied the POST request “as cURL” to have a look at the data it sent. There I manually extracted the session and cookie information in order to add emails from the command line. The script that takes the pre-generated emails and puts them into pretalx is called email_to_pretalx.sh.
Reviewing the uploaded videos
Once a video is uploaded, it gets reviewed. The idea was, that the speakers don’t need to care too much about the start and the end of the video, e.g. when they start the recording and there is a few seconds of silence while switching to the presentation. The reviewer will cut the beginning and end of the video and also convert it to a common format.

We wanted to preserve the original video quality, hence we use LosslessCut and converted it then to the Matroska format. The reviewers would also check that the video isn’t longer than the planned slot.

See the copy_uploads directory for all the scripts that are needed for this step.
pretalx
The reviewers get a file with things to check for each video file. We get the needed metadata again from pretalx and post-process it with jq. As above for the emails, there is again a template file which (this time) generates Markdown files with the information for the reviewers. The full script is called create_info_files.sh.
Seafile
Once videos are uploaded they should be available for the reviewers. The uploaded files are the primary source, hence it makes sense to always make copies of the talks, so that the original uploads are not lost. The sync_files_and_upload_info.sh script copies the talks into a new directory (together with the information files), which is then writeable for the reviewers. They will download the file, review it, cut it if needed, convert it to Matroska and upload it again. Once uploaded, they move the directory into one called fertig (“done” in German) as an indicator that no one else needs to review it.

I run the script daily as a cron job, it only copies the new uploads. Please note that it only checks the existence on a directory level. This means that if a talk was reviewed and a speaker uploads a new version of the talk, it won’t be copied. That case didn’t often happen often and speakers actually let us know about it, so it’s mostly a non-issue (also see the miscellaneous scripts section for more).

Last step is that someone looks through the filled out markdown files to check if everything was alright, respectively make sure that e.g. the audio volume is fixed, or asks the speaker for a new upload. The then checked videos are moved to yet another directory, which then contains all the talks that are ready to be streamed.
Re-org files for schedule
So far, the video files were organized by directories that are named after the pretalx ID of the talk. For running the conference we used OBS for streamer. The operator would need to play the right video at the right time. Therefore, it makes sense to sort them by the schedule. The cut_to_schedule.sh script does that re-organization, which can be found in the cut_to_schedule directory.
pretalx
To prevent accidental inconsistencies, the root directory is named after the current version of the pretalx schedule. So if you publish a new version of the schedule and run the script again, you’ll get a new directory structure. The video files still have an arbitrary name, chosen by the uploader/reviewer, we want a common naming scheme instead. The get_filepath.py script creates such a name that also sorts chronologically and contains all the information the OBS operators need. The current scheme is <room>/day<day-of-the-conference>/day<day-of-the-conference>_<day-of-the-week>_<date>_<time>_<pretalx-id>_<title>.mkv.
Seafile
The directories do not only contain the single final video, but also the metadata and perhaps the original video or a presentation. The file we actually copy is the *.mkv file which was modified last, which will be the cut video. The get_files_to_copy.sh script creates a list of the files that should be copied, it will only list the files that weren’t copied yet (based on the filename). The copy_files.sh script does the actual copying and is rather generic, it only depends on a file list and Seafile.
Easily downloadable files
Seafile has a feature to download a full directory as zip file. I originally planned to use that. It turns out that the size of the files can be too large, I got the error message Unable to download directory "day1": size is too large.. So I needed to provide another tool, as I didn’t want that people would need to click and download all individual talks.

The access to the files should as easy as possible, i.e. the operators that need the files shouldn’t need a Seafile account. As the videos also shouldn’t be public, the compromise was using a download link secured with a password. This means that an authentication step is needed, which isn’t trivial. The download_files.sh script does login and then downloads all the files in that directory. For simplicity, it doesn’t do recursively. This means that any stage would need to run this script for each day.

I also added a checksum check for more robustness. I created those checksums manually with running b2sum * > B2SUMS in each of the directories and then uploaded them to Seafile.
List of live/pre-recorded talks
Some talks are recorded and some are live, the list_recorded_talks.py script, creates a Markdown file that contains a schedule with that information, including the lengths of the talks if they are pre-recorded. This is useful for the moderators to know how much time for questions will be. At the FOSSGIS we have 5 minutes for questions, but if the talk runs longer, there will be less time.

You need the schedule and the length of the recorded talks. This time I haven’t fully automated the process, it’s a bit more manual than the other steps. All scripts can be found in the list_recorded_talks directory.

Get the schedule:
```
curl [https:] > schedule.json
```
For getting the lengths of the videos, download them all with the download script from the Easily downloadable files section above. Then run the get_length.sh script in each of the directories and output then into a file. For example:
```
cd your-talks-day1
/path/to/get_lengths.sh > ../lengths/day1.txt
```
Then combine the lengths of all days into a single file:
```
cat ../lengths/*.txt > ../talk_lengths.txt
```
Now you can create the final schedule:
```
cd ..
python3 /path/to/list_recorded_talks.py schedule.json talk_lengths.txt
```
Here’s a sample schedule from the FOSSGIS 2021.
Miscellaneous Scripts Speaker notification
The speakers didn’t get feedback whether their video was correctly uploaded/processed (other than seeing a successful upload in Seafile). A short time before the conference, we were sending out the latest information that speakers needs to know. We decided to take the chance to also add information whether their video upload was successful or not, so that they can contact us in case something with the upload didn’t go as they expected (there weren’t any issues :).

It is very similar to sending out the email with the upload links. You get the information about the speakers and talks in the same way. The only difference is we now also need the information whether the talk was pre-recorded or not. We get that from Seafile:
```
curl --silent -X GET --header 'Authorization: Token <seafile-token>' 'https://seafile.example.org/api2/repos/<repo-id>/?p=/<dir-with-talks>&t=d'|jq --raw-output '.[].name' > prerecorded_talks.txt
```
The full script to create the emails can be found at email_speaker_final.sh. In order to post them to pretalx, you can use the email_to_pretalx.sh script and follow the description in the creating emails section.
Number of uploads
It could happen that people upload a new version of the talk. The current scripts won’t recognize that if a previous version was already reviewed. Hence, I manually checked the directories for the ones with more than one file in it. This can easily be done with a single curl command to the Seafile HTTP API:
```
curl --silent -X GET --header 'Authorization: Token <seafile-token>' 'https://seafile.example.org/api2/repos/<repo-id>/dir/?p=/<dir-with-talks>&t=f&recursive=1'|jq --raw-output '.[].parent_dir'|sort|uniq -c|sort
```
The output is sorted by the number of files in that directory:
```
  1 /talks_conference/ZVAZQQ
  1 /talks_conference/DXCNKG
  2 /talks_conference/H7TWNG
  2 /talks_conference/M1PR79
  2 /talks_conference/QW9KTH
  3 /talks_conference/VMM8MX
```
Normalize volume level
If the volume of the talk was too low, it was normalized. I used ffmpeg-normalize for it:
```
ffmpeg_normalize --audio-codec aac --progress talk.mkv
```
Conclusion
Doing all this with scripts was a good idea. The less manual work the better. It also enabled me to process talks even during the conference in a semi-automated way. I created lots of small scripts and sometimes used just a subset of them, e.g. the copy_files.sh script, or quickly modified them to deal with a special case. For example, all lightning talks of a single slot (2-4) were merged together into one video file. That file of course then isn’t associated with a single pretalx ID any more.

During the conference, the volume level of the pre-recorded talks was really different. I think for next time I’d like to do some automated audio level normalization after the people have uploaded the file. It should be done before reviewers have a look, so that they can report in case the normalization broke the audio.

The speakers were confused whether the upload really worked. Seafile doesn’t have an “upload now” button or so, it does it’s JavaScript magic once you’ve selected a file. That’s convenient, but was also confusing me, when I used it for the first time. And if you reload the page, you also won’t see that something was uploaded already. So perhaps it could also be automated that speakers get an email “we received your upload” or so.

Overall I’m really happy how the whole process went, there weren’t major failures like lost videos. I also haven’t heard any complaints from the people that needed to use any of the videos at any stage of the pipeline. I’d also like to thank all the speakers that uploaded a pre-recorded video, it really helped a lot running the FOSSGIS conference as smooth as it was.
10 June 2021
11:00
CARTO Blog: Building a Spatial Model to Classify Global Urbanity Levels
sur Planet OSGeo

Decision-makers in the private and public sector are trying to understand our rapidly changing use of urban areas. The way we shop and travel; what we expect from our livin...
09 June 2021
11:00
CARTO Blog: How to use Angular & CARTO to Build Scalable Spatial Apps
sur Planet OSGeo

Angular is one of the most popular frameworks for building web applications with a huge community of developers. It includes powerful features for building scalable applica...
7:00
Lutra consulting: Geodiff version 1.0
sur Planet OSGeo
We are excited to announce that the geodiff library has finally reached version 1.0. We have started to develop geodiff back in 2019 as a part of our efforts to allow synchronisation of changes between the Input mobile app and Mergin platform.

At the core, geodiff library provides functionality to:
- compare a pair of GeoPackage databases and create “diff” files containing changes between them
- apply a “diff” file to a GeoPackage database
- rebase changes in a “diff” file
- invert, concatenate diffs and other utility functions
Thanks to the above low-level operations, any changes to data stored in spatial/non-spatial tables in GeoPackages can be easily transferred to others and applied. And thanks to the “rebase” functionality - inspired by source code management systems like git - we can automatically merge changes from multiple users capturing data offline in Input/Mergin (see our recent blog post that covers rebasing for more).

The library is written in C++, providing stable C API and offering Python bindings as well (look for pygeodiff package in pip). It also comes with a command line interface tool geodiff covering all major features. The whole package has a very permissive MIT license.
Support for drivers
Initially, geodiff library only worked with SQLite / GeoPackage files. This has changed with the version 1.0 - geodiff supports drivers, allowing use of different database backends to compare and apply diffs. In the 1.0 release we have added PostGIS driver in addition to SQLite/GeoPackage driver.

This means that users can compare tables or apply diffs in PostGIS databases using the same APIs as with GeoPackages. And not only that - diff files are compatible across different drivers. That means it is possible to take a diff file from a GeoPackage and apply it to PostGIS database!

Using the PostGIS driver we were able to create mergin-db-sync tool as a companion to Mergin platform. With DB sync, one can keep a local PostGIS database always in sync with a project in Mergin, supporting automatic transfer of changes from Mergin to PostGIS and the other way round as well - from PostGIS to back Mergin.
Try it
The library is hosted on GitHub in lutraconsulting/geodiff repository. We would love to hear your feedback!
Stay tuned for more!
As announced earlier, next week we will be open sourcing Mergin, our platform for easy sharing of spatial data in teams (whether they are in office or in the field). If you have not heard about Mergin platform yet, please have a look at the Mergin website, try Mergin plugin for QGIS and Input app, a mobile app based on QGIS for iPhone/iPad and Android devices. Since the initial release in early 2019, Mergin and Input have been used by thousands of users around the world.

At Lutra Consulting, we are dedicated to improving free and open source software for geospatial. We will be releasing Mergin as open source to solve another missing piece in the puzzle, providing open source end-to-end solution for mobile data capture for QGIS users. Watch our blog and Twitter for further updates!
08 June 2021
12:49
GeoSolutions: Free Webinar – A DevOps Perspective on GeoServer: Monitoring, Metering, Logging and Troubleshooting a GeoServer Installation
sur Planet OSGeo

You must be logged into the site to view this content.
10:35
gvSIG Team: Seminario virtual: gvSIG Online, rompiendo las barreras necesarias para implantar con éxito Infraestructuras de Datos Espaciales
sur Planet OSGeo

Os invitamos al cuarto seminario online de la Red CYTED IDEais, que se realizará el jueves 24 de junio. En ella hablaremos de la solución gvSIG Online, una plataforma en software libre para implantar Infraestructuras de Datos Espaciales, y de los motivos de su éxito, al romper las principales barreras que impiden disponer de soluciones informáticas para gestionar eficientemente la información geográfica de cualquier organización.

Os podéis inscribir en [https:]]
07 June 2021
18:11
GeoSolutions: FedGeoDay
sur Planet OSGeo

You must be logged into the site to view this content.
04 June 2021
13:21
Free and Open Source GIS Ramblings: MovingPandas v0.7 released!
sur Planet OSGeo
The latest v0.7 release is now available from conda-forge.

New features include:
- Functions to convert Trajectories to GeoDataFrames (points, line segments, or whole trajectories)
- Clip and intersection now return TrajectoryCollection objects
As always, all tutorials are available from the movingpandas-examples repository and on MyBinder:

Skip to page: 1 2 3 ... 14

← Blogs GeoRezo.net

Communauté	Ressources	L'emploi	Le marché	L'association	Fils RSS
Forum Blogs Wiki Planet Carte des membres Sites amis	Agenda Biblio Netvibes Fiches AMO-CNIG Paris PCGIS Téléchargements	Offres d'emploi Banque de CV Carte des CV Formations Démarche Métiers	Geo-Entreprises Geo-Communiqué Appels d'offres	L'association Qui sommes-nous ? Nous aider Bienfaiteurs Partenaires Historique Statuts	Tout le site Job Géomatique Services GeoBlogs ...	Faire un don Mentions légales

Le portail francophone de la géomatique

Feeds

Autres planets

Enclosure: [download]