Le portail francophone de la géomatique

Canaux

4381 éléments (136 non lus) dans 55 canaux

Dans la presse (78 non lus)

• Cybergeo (30 non lus)
• Revue Internationale de Géomatique (RIG)
• SIGMAG & SIGTV.FR - Un autre regard sur la géomatique (5 non lus)
• Mappemonde (30 non lus)
• Dans les algorithmes (13 non lus)

Du côté des éditeurs (9 non lus)

• Imagerie Géospatiale
• Toute l’actualité des Geoservices de l'IGN (1 non lus)
• arcOrama, un blog sur les SIG, ceux d ESRI en particulier (8 non lus)
• arcOpole - Actualités du Programme
• Géoclip, le générateur d'observatoires cartographiques
• Blog GEOCONCEPT FR

Toile géomatique francophone (49 non lus)

• Géoblogs (GeoRezo.net)
• Conseil national de l'information géolocalisée (1 non lus)
• Geotribu (1 non lus)
• Les cafés géographiques (2 non lus)
• UrbaLine (le blog d'Aline sur l'urba, la géomatique, et l'habitat)
• Icem7
• Séries temporelles (CESBIO) (9 non lus)
• Datafoncier, données pour les territoires (Cerema) (1 non lus)
• Cartes et figures du monde
• SIGEA: actualités des SIG pour l'enseignement agricole
• Data and GIS tips
• Neogeo Technologies (10 non lus)
• ReLucBlog
• L'Atelier de Cartographie
• My Geomatic
• archeomatic (le blog d'un archéologue à l’INRAP)
• Cartographies numériques (14 non lus)
• Veille cartographie (1 non lus)
• Makina Corpus (6 non lus)
• Oslandia (4 non lus)
• Camptocamp
• Carnet (neo)cartographique
• Le blog de Geomatys
• GEOMATIQUE
• Geomatick
• CartONG (actualités)

Géomatique anglophone

• Planet Geospatial - http://planetgs.com
• Google Maps Mania
• All Points Blog
• Directions Media - Podcasts
• Navx
• James Fee GIS Blog
• Open Geospatial Consortium (OGC)
• Planet OSGeo

Blogs GeoRezo.net

• Parcell'air
• Le coin de l'open-source géospatial
• INSPIRE by clouds
• Les GéoBlogs
• Infobulle
• Le blog SIG & URBA
• Blog Interopérabilité & GéoInformation

opensource

• 29 March 2024
• 10:19

  Oslandia: (Fr) En direct des Journées Utilisateurs QGIS-fr !

  sur Planet OSGeo

  Sorry, this entry is only available in French.

• 28 March 2024
• 14:52

  En direct des Journées Utilisateurs QGIS-fr !

  sur Oslandia

  Une belle partie de l’équipe est présente pendant les Journées Utilisateurs QGIS-fr les 27 et 28 mars à Grenoble pour animer 5 ateliers et 2 conférences avec des clients : nouveautés QGIS 3D, créer et publier un joli projet sur QWC, cartographie avancée avec QGIS, initiation au déploiement rationalisé de QGIS avec PowerShell et QDT, collecter vos données sur le terrain avec QField, …

  Oslandia est Mécène Or des Rencontres utilisateurs QGIS-fr 2024. Au fil des projets réalisés et des expériences, Oslandia a acquis un statut d’acteur majeur français sur QGIS.

  Editeur open source QGIS depuis 2011, Oslandia contribue activement à la communauté, comme pendant ces deux jours

  • 
  • 
  • 
  • 
  • 

• 11:00

  Mappery: Scotland’s Geology

  sur Planet OSGeo
  

  I am not sure who pointed me to this magnificent geological map of Scotland which was shared by Europe Says who said “Geologically correct map of Scotland. 30 years of collecting!”

  MapsintheWild Scotland’s Geology

• 27 March 2024
• 11:00

  Mappery: 3D Globe Jigsaw

  sur Planet OSGeo
  

  Javier Jimenez Shaw shared this beauty “3D globe jigsaw puzzle in my living room. 30 cm diameter. Unfortunately it is not produced anymore.” Amazing object, I have never seen anything like this before, have you?

  It turns out that Ravensburger make a newer version of a 3D globe which you can buy here or from other online places that we can do without boosting

  MapsintheWild 3D Globe Jigsaw

• 26 March 2024
• 20:10

  GeoSolutions: GeoSolutions at FedGeoDay in Washington, DC

  sur Planet OSGeo

  You must be logged into the site to view this content.

• 11:00

  Mappery: Stone Town, Zanzibar

  sur Planet OSGeo
  

  Stephen Mather, a good friend of Mapppery, shared this “Here’s one from Stone Town, Zanzibar, November of 2016. I think it’s up top of Emerson Spice.”

  

  You might say “not very wild” but I love the idea of a hotel called Emerson Spice, sounds pretty wild to me.

  MapsintheWild Stone Town, Zanzibar

• 7:00

  [Equipe Oslandia] Jean, ingénieur SIG

  sur Oslandia

  Après un diplôme d’ingénieur obtenu à Centrale Lille, Jean s’engage dans une thèse en Morphologie mathématique, orientée sur le traitement d’images numériques, aux Mines de Paris. Après sa thèse, il poursuit pendant 12 ans sa collaboration avec son entreprise d’accueil. Il travaille sur de nombreux projets de R&D et sur l’écriture d’algorithmes de traitements d’images ou sur des algorithmes de données SIG géolocalisées.

  Il découvre les SIG, QGIS, et … Oslandia, identifié comme un acteur majeur dans la communauté QGIS !

  « La culture open source m’intéresse, j’ai toujours utilisé des outils et logiciels OS et je faisais d’ailleurs de la contribution à titre perso. J’avais par ailleurs envie de travailler dans une société dans laquelle je pouvais être davantage partie prenante des décisions et des actions »

  Jean est ingénieur SIG chez Oslandia depuis 2022 et dispose d’une solide expérience en C++, le langage de programmation sur lequel est basé QGIS et sur le visualisateur QT. Il met à disposition ses compétences sur des projets variés comme le visualiseur de données 3D pour le CEA, de nouvelles fonctionnalités pour améliorer le chargement et la visualisation de nuages de points sur QGIS pour EDF,… ou encore la visualisation de données de l’IFREMER qui repose sur QGIS server.

  Projet emblématique

  Jean a développé avec son collègue Florent un plugin pour l’IFREMER « QDuckDB » permettant de lire des bases de données DuckDB, qui stockent des infos spatiales (points, polygones, lignes, …), dans QGIS.
  Ce plugin permet aujourd’hui de partager des fichiers « parquet » utilisés de plus en plus notamment par l’INSEE.
  « Comme tout est en open source, d’autres utilisateurs peuvent proposer de nouvelles fonctionnalités, on peut imaginer plein d’évolutions possibles ! »

  Technologies de prédilection

  Langages C, C++ et Python

  Philosophie

  Tout ce que je développe peut servir à la communauté, j’aime l’idée de contribuer à un bien commun.

  Oslandia en 1 mot

  Transparence !

• 25 March 2024
• 11:00

  Mappery: Birds Eye View

  sur Planet OSGeo
  

  Jachym Cepicky shared this “Fish eye View from Sn?žka, hand drawn”

  MapsintheWild Birds Eye View

• 10:20

  OTB Team: OTB works with QGis 3.36

  sur Planet OSGeo
  The OTB Provider QGis plugin is now available on QGis plugin catalog. Since QGis version 3.36, the plugin previously packaged is no longer in QGis package. To use OTB with QGis 3.36 you need to install plugin from QGis plugin catalog (“Extensions menu –> Install/Manage Extensions” and type OTB in not-installed tab). Then follow plugin […]

• 9:51

  Py3dtiles v7.0.0 est de sortie ! Des fonctionnalités, et une communauté qui se développe

  sur Oslandia

  var spector; var captureOnLoad = false; var captureOffScreen = false; window.__SPECTOR_Canvases = [];

  (function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;

  if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;

  OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);

  if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false); captureOnLoad = false; } } }

  return context; } }

  HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);

  if (captureOffScreen) { var found = false; for (var i = 0; i

  var spector; var captureOnLoad = false; var captureOffScreen = false; window.__SPECTOR_Canvases = [];

  (function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;

  if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;

  OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);

  if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false); captureOnLoad = false; } } }

  return context; } }

  HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);

  if (captureOffScreen) { var found = false; for (var i = 0; i

  var spector; var captureOnLoad = false; var captureOffScreen = false; window.__SPECTOR_Canvases = [];

  (function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;

  if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;

  OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);

  if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false); captureOnLoad = false; } } }

  return context; } }

  HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }

  if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }

  var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);

  if (captureOffScreen) { var found = false; for (var i = 0; i

  Py3dtiles est une librairie et un outil Python en ligne de commande pour générer, lire et modifier des 3D Tiles. On peut l'utiliser seul ou l'intégrer dans sa propre application Python.

  La version 7.0.0 vient de sortir, il est temps de faire une petite rétrospective sur les dernières années !

  La communauté et un nouveau mainteneur

  Nous accueillons un nouveau mainteneur : Lorenzo Marnat (Liris). Le Liris a très significativement contribué à py3dtiles et a mené un travail de R&D conséquent sur leur fork et via l'application py3dtilers. Lorenzo réalise depuis quelques mois le travail d'intégration dans le tronc commun, véritable travail de fourmi ô combien nécessaire. L'intégrer à l'équipe était donc l'étape logique dans  ce processus.

  Cela signifie que py3dtiles n'est plus un projet uniquement Oslandien ! Ceci constitue une étape très importante dans le développement d'un projet réellement communautaire et nous sommes très heureux de l'avoir dans l'équipe.

  En conséquence, certains changements ont été adoptés afin que py3dtiles soit plus indépendant d'Oslandia. Nous espérons ainsi favoriser les contributions externes et l'implication d'autres entitées qu'Oslandia et le Liris:

  • Le dépôt de code a été déplacé vers sa propre organisation: [https:]] . Nous en avons profité pour renommer la branche principale en main à la place de master (afin de s'approcher du défaut de GitLab).
  • Le site web est maintenant hébergé sur [https:]] . Une redirection de l'ancien site a été mise en place, mais nous conseillons tout de même de mettre à jour vos signets web.
  • Nous avons maintenant un document décrivant la gouvernance: GOVERNANCE.md, qui décrit le fonctionnement de la communauté.
  • Et nous avons un canal de discussion instantané sur matrix.org !

  

  Lidar HD de l'ign converti en 3dtiles avec py3dtiles et visualisé avec giro3d

  Les évolutions fonctionnelles Améliorations du support de la spécification

  En version 2, py3dtiles souffrait encore de l'absence de ces quelques classes décrivant les concepts 3Dtiles, et qui sont maintenant présentes en version 7 :

  • BoundingVolumeBox
  • TileSet
  • Tile
  • Extension

  Les feature tables sont maintenant supportées pour les b3dm en plus des pnts.

  Nouveaux formats

  Py3dtiles supporte maintenant les fichiers PLY (en nuage de points uniquement) et LAZ.

  Le support XYZ et CSV a été amélioré, avec une auto-détection du format du CSV.

  py3dtiles merge

  Il s'agit d'une nouvelle commande permettant de générer un tileset à partir de 2 autres tilesets. Pour l'instant la génération des tuiles racines est assez naïve, mais devrait très bien fonctionner avec les nuages de points.

  Autres fonctionnalités

  Il est maintenant possible d'exporter les classifications des nuages de points dans les pnts.

  Le support des batch tables a été ajouté.

  Les évolutions techniques Des évolutions de packaging Les dépendances optionnelles

  Avec le support de formats additionnels, le nombre de dépendances de py3dtiles augmente de façon significative. Nous avons créé des sections de dépendances optionnelles, afin d'éviter de demander aux utilisateurs d'installer des librairies pour des formats qu'ils n'utilisent pas.

  Image Docker

  Nous publions maintenant des images docker sur le gitlab registry et docker hub.

  Support Windows

  Un premier travail pour supporter Windows a été effectué, mais du travail reste à accomplir pour produire un .exe facilitant le déploiement.

  La qualité du code

  De gros efforts ont été effectués pour rendre la contribution plus agréable et améliorer globalement la qualité du code. Des analyseurs automatiques de code ont été mis en place, notamment des linters et un SonarCloud.

  Nous avons fait un effort spécifique pour typer nos déclarations de fonctions et variables avec les nouvelles possibilités qu'offre les versions modernes de Python.

  À venir

  Le point principal sera le support des géométries dans le processus de conversion multiprocessus lancé par py3dtiles convert. Cela permettra ensuite d'avoir un support des formats géométriques, en particulier l'IFC ! (Mais également, l'amélioration du support PLY, des tables PostGIS, des OBJ, etc.).

  D'autres améliorations sont bien sûr dans les cartons.

  Impliquez-vous !

  Py3dtiles est un logiciel communautaire et se portera mieux si vous participez ! Tester, ouvrir des tickets, voire contribuer ou financer sont des actions qui sont très utiles pour le projet. Le guide de contribution de la communauté est ici. Alternativement, n'hésitez pas à nous contacter pour en discuter !

• 24 March 2024
• 11:00

  Mappery: The Meanderings of the River Ahr

  sur Planet OSGeo
  

  Anton van Tetering shared this “Map of the meanders of the river Ahr on the wall of restaurant Ruland in Altenahr, Germany. Just like many other buildings in the Ahr-valley, this restaurant was severely damaged in the flood catastrophe of July 2021 which killed at least 135 people in this valley alone.”

  MapsintheWild The Meanderings of the River Ahr

• 1:00

  SourcePole: FOSSGIS 2024

  sur Planet OSGeo

  Sourcepole hat an der FOSSGIS 2024 in Hamburg verschiedene Themen mit Vorträgen abgedeckt:

  • QGIS Web Client 2 (QWC2) - Neues aus dem Projekt
  • QGIS Server Plugins
  • BBOX: Kompakter OGC API Server für Features, Tiles und mehr
• 23 March 2024
• 11:00

  Mappery: Pinocchio Theme Park

  sur Planet OSGeo
  

  Ian Wagner shared this pic of a map of Italy in a Pinocchio themed park in South Korea. Who knew Pinocchio was a thing there?

  MapsintheWild Pinocchio Theme Park

• 0:00

  Ecodiv.earth: An addon to download the AHN data in GRASS GIS

  sur Planet OSGeo
  The r.in.ahn addon

  In the previous post, I introduced the ‘Actueel Hoogtebestand Nederland’. To start with a small correction, the version 4 I mentioned isn’t the latest version. Version 5 is being rolled out and is already available for the northern part of the country. But for now, let’s focus on version 4.

  In the previous post, I presented some steps to download the AHN for a specific area and import it in GRASS GIS. Downloading was easy using the r.in.wcs addon. However, a few extra steps were required to ensure the imported data would align with the extent and resolution of the original AHN data.

  Easy, but why not make it easier yet? So, as it was a rainy day anyway, I used the code presented earlier and wrapped it up in the addon r.in.ahn. Let’s see how to download the DTM for the Land van Cuijk again, but this time using the new addon.

  ©

  
  

  Download the DTM for a selected area

  Note that this addon only works in locations with the coordinate reference system RD New (EPSG 28992). This is that the CRS of the original data, and the addon is meant to ensure you download the data as it is. This is akin to how the r.in.gdal import function works. If you want to import and reproject the data on the fly (similar to the r.import function), you can use the r.in.wcs addon.

  This example shows the steps to download the 0.5-meter resolution DTM for the Land van Cuijk. You’ll need to install the r.in.wcs and r.in.ahn addons ^{1 2}.

  • GUI

  Install the required addons.

  First step is to import the Python libraries. Note, this will not be repeated with the next scripts.

  import grass.script as gs

  Now, you can install the two addons using the g.extension function.

  gs.run_command("g.extension", extension="r.in.wcs")
  gs.run_command("g.extension", extension="r.in.ahn")

  Install the two addons using the g.extension function.

  g.extension extension=r.in.wcs
  g.extension extension=r.in.ahn

  You need the g.extension function to install addons. In the main menu, go to Settings > Addons extension > Install extension from addon. Alternatively, type in g.extension on the command line. The example below is for r.in.wcs. Repeat this step for r.in.ahn.

  Figure 1: The g.extension function, started from the command line. Figure 1: The g.extension function, started from the command line.

  Now, download the administrative boundaries of the Dutch municipalities, and extract the boundaries of the “Land van Cuijk”.

  • GUI

  Download layer with administrative boundaries of the neighborhood.

  gs.run_command(
      "v.in.wfs",
      url="https://service.pdok.nl/cbs/wijkenbuurten/2022/wfs/v1_0?",
      output="municipalities",
      name="gemeenten",
  )

  Next, extract the boundaries of the municipality of “Land van Cuijk”

  gs.run_command(
      "v.extract",
      input="municipalities",
      where="naam = 'Land van Cuijk'",
      output="LandvanCuijk",
  )

  Get the vector layer with the boundaries of the municipality.

  v.in.wfs url="https://service.pdok.nl/cbs/wijkenbuurten/2022/wfs/v1_0?" \
      output=municipalities name=gemeenten

  Next, extract the boundaries of the municipality of “Land van Cuijk”

  v.extract input=municipalities where="naam = 'Land van Cuijk'" \
      output="LandvanCuijk"

  Type in v.in.wfs on the command line or in the console. You can also find the function under main menu > File > Import vector data. This opens the following screen (you need to fill in parameters in two tabs):

  Figure 2: Download the vector layer with the municipality boundaries. Define the base URL and the name of the output layer. Figure 2: Download the vector layer with the municipality boundaries. Define the base URL and the name of the output layer. Figure 3: Download the vector layer with the municipality boundaries. Fill in the name of the WFS layer to download. Figure 3: Download the vector layer with the municipality boundaries. Fill in the name of the WFS layer to download. Figure 4: Extract the boundaries of the municipality of Land van Cuijk. Select the name of the vector layer with municipalities and give the name of the output layer. Figure 4: Extract the boundaries of the municipality of Land van Cuijk. Select the name of the vector layer with municipalities and give the name of the output layer. Figure 5: Extract the boundaries of the municipality of Land van Cuijk. Fill in the query, which defines which features you want to select and save. Tip: Use the convenient query builder. Figure 5: Extract the boundaries of the municipality of Land van Cuijk. Fill in the query, which defines which features you want to select and save. Tip: Use the convenient query builder.

  Now, set the region to match the extent of the municipality. Note, you do not need to be concerned with the resolution; r.in.ahn will adjust the resolution and extent to make sure the imported data aligns perfectly with the original AHN data. This is done by setting the resolution to 0.5 meters and subsequently extending the region’s extent until it aligns with the original AHN data layer.

  • GUI

  Set the region to match the vector layer LandvanCuijk.

  gs.run_command("g.region", vector="LandvanCuijk")

  Get the vector layer with the boundaries of the municipality.

  g.region vector=LandvanCuijk

  Type in g.region on the command line or console, or open the function’s window via menu | Settings | Computational region | Set region.

  Figure 6: Set the region to match the extent of the vector layer LandvanCuijk. Figure 6: Set the region to match the extent of the vector layer LandvanCuijk.

  Now, you can run the r.in.ahn function to import the layer. Note that by default, the addon will change the region you just defined. It will set the resolution to 0.5 meters (this is the resolution of the AHN data you are about to download). It will furthermore expand the extent so that it aligns perfectly with the AHN data.

  • GUI

  Import the DTM using the r.in.ahn function.

  gs.run_command("r.in.ahn", product="dtm", output="dtm_05")

  Get the vector layer with the boundaries of the municipality.

  r.in.ahn product=dtm output=dtm_05

  Type in r.in.ahn on the command line or console. A third way is shown in the image below. Open the Tools tab and go to Addons. The function should be available there.

  Figure 7: Open the r.in.ahn plugin, select the product to download (dtm or dsm) and provide the output layer name. Figure 7: Open the r.in.ahn plugin, select the product to download (dtm or dsm) and provide the output layer name. Download whole tiles

  If you set the -t flag, the function will import the DTM or DSM for all 6.5×5 km AHN tiles that overlap with the current region. In addition, a vector polygon layer will be created with the tile boundaries.

  • GUI

  Define the region for which you want to download the data, and import the DSM using the r.in.ahn function. Set the -t flag to download the DTM for the area covered by the tiles that overlap with the region.

  # Set the region
  gs.run_command("g.region", n=412572, s=411280, w=188911, e=190085)
  
  # Import the tile(s) that include the selected region 
  gs.run_command("r.in.ahn", product="dtm", flags="t",
                  output="dtm_05_subset")

  # Set the region
  g.region n=412572 s=411280 w=188911 e=190085)
  
  # Import the tile(s) that include the selected region 
  r.in.ahn -t product=dtm output=dtm_05_subset)

  Open the g.region addon by typing g.region on the command line, in the console, or using the menu. Fill in the northern, southern, western, and eastern limits of the area for which you want to download the data.

  Figure 8: Set the region bounds. Figure 8: Set the region bounds.

  Type in r.in.ahn on the command line or console. Or go to the Tools tab and go to Addons. The function should be available there. Fill in the required fields, like in the previous examples. Next, go to the Optional tab and select Download whole tiles.

  Figure 9: Open the r.in.ahn plugin, select the product to download (DTM or DSM) and provide the output layer name. Figure 9: Open the r.in.ahn plugin, select the product to download (DTM or DSM) and provide the output layer name.

  The extent of the imported layer covers the 6.5×5 km AHN tile. In addition to the raster layer, you’ll have a vector layer with the boundary of the downloaded tile(s). This vector layer has the same name but with the suffix *_tiles*.

  You should be aware that running the function will adjust the computational region so that it aligns with the imported data. You can avoid this by setting the -g flag, as illustrated in Figure 10.

  Figure 10: A: The downloaded 6.5 x 5 km AHN tiles that intersect with the user-defined region, here indicated by the orange outline. In addition, a vector layer with the boundaries of the tiles is created. The red outline shows the adjusted region extent after running the function. The blue outlines show the boundaries of the downloaded tiles. B: The same, but with the -g flag set. With this flag set, the user-defined region (red outline) will not be altered . Figure 10: A: The downloaded 6.5 x 5 km AHN tiles that intersect with the user-defined region, here indicated by the orange outline. In addition, a vector layer with the boundaries of the tiles is created. The red outline shows the adjusted region extent after running the function. The blue outlines show the boundaries of the downloaded tiles. B: The same, but with the -g flag set. With this flag set, the user-defined region (red outline) will not be altered . Footnotes

  1. You are expected to be familiar with GRASS GIS and the concept of region used in GRASS GIS. If you are new to GRASS GIS, you are warmly recommended to first check out the GRASS GIS Quickstart and the explanation about the GRASS GIS database.??

  2. Downloading the DTM for the whole municipality will take a while. If you want to speed things up, you can work with a smaller area by using your own vector data.??

• 22 March 2024
• 11:00

  Mappery: A map lover’s birthday present

  sur Planet OSGeo
  

  Gregory Marler said “I got a scarf for my birthday, it’s got 2 country maps on it! Would @mappery count this as a map in the wild? At the least it is being worn beside my wild/unkempt beard.”

  The answer is definitely “Yes”

  Who can work out the country that is not UK? (Greg can’t answer)

  MapsintheWild A map lover’s birthday present

• 9:40

  Jackie Ng: Avalonia UI Test Drive

  sur Planet OSGeo

  As the title implies, this blog post is about my experience test driving Avalonia UI.

  So why am I doing this?

  I've been getting growing questions lately about whether MapGuide Maestro works on Linux via Mono. 

  Sadly I no longer emphasize anything regarding Mono compatibility because.

  • WinForms support (in legacy .net Framework 4.x) on Mono is pretty much a hack.
  • And since we've moved away from legacy .net Framework to .net 6.0, the combination of WinForms + .net 6.0 is probably an unsupported combination (you don't use Mono to run .net core/5.0+ applications, you use Microsoft's official SDK/runtime). I'm also not too keen to waste time and resources to test and find out.

  The best and practical approach for a multi-platform MapGuide Maestro would be to at a minimum to rewrite the UI in a library/framework where support on non-Windows platforms is a first-class citizen.

  And in terms of .net multi-platform UI frameworks, there's only one logical choice: Avalonia UI

  While it is not in my immediate plans to rewrite MapGuide Maestro's UI in Avalonia, I wanted to at least explore the feasibility of building such a UI even if all the actual functionality is mocked up, just to see how easy or difficult the whole process is.

  Hence the motivation for this post.

  

  So why Avalonia?

  Avalonia is effectively the "spiritual successor" to WPF, and adopts most of the same patterns and practices when building UIs for Avalonia.

  I had first heard about Avalonia when it was formerly known as Perspex and at the time, from the screenshots of example Perspex applications on Windows and non-Windows platforms, it was clear at that point in time the range of possible applications one can build with Perspex was quite limited and building an application like Maestro on top of Perspex was not feasible.

  Just recently, I had heard about the framework now known as Avalonia again and this time round there was a lot more positive buzz around it, so I gave it another look and was much more impressed at its capabilities and richer suite of UI controls to build applications with.

  Our objective 

  My objective with this Avalonia learning exercise was to build a minimal multi-document interface skeleton application, mimicking the primary functionality (UI-wise) of MapGuide Maestro.

  • Being able to present a login UI to connect to a MapGuide Server
  • Present MapGuide Server resources in a tree view
  • Open resources in a region of tabbed editor panels and being able to close them.

  This is a crude wireframe of the kind of UI I wanted to build.
  If this kind of UI looks familiar, yes it's basically the UI for tools like:

  • Visual Studio Code
  • Azure Data Studio
  • Azure Storage Explorer
  • any many others like them!

  MapGuide Maestro is an IDE-like application (in terms of UI), so my first instinct is to look for a Visual Studio like docking library for Avalonia. However, I've been using Visual Studio Code more often than full Visual Studio as my daily driver for coding and the VSCode UI has become my default UI that I want to replicate for any IDE-like application with a multi-document interface.
  The benefit of such a UI, is that it doesn't require an explicit VS-style window docking control like I have for the current WinForms-based MapGuide Maestro. I can already see the controls needed to build such a UI
  Any UI toolkit worth its salt should to able to provide these basic controls.
  This is a proof-of-concept, so we won't be using the existing Maestro API to talk to actual MapGuide Servers. Instead such functionality will be mocked up for this application. The main purpose of this exercise is to see if Avalonia provides enough of the base UI elements to build a hypothetical version of MapGuide Maestro on top of.
  It turns out this exercise was fraught with several challengesChallenge #1: Getting familiar with Avalonia conceptsThe first challenge was simply getting familiar with Avalonia concepts. Being someone who did .net desktop app development primarily in Windows Forms, I skipped over WPF, and its XAML-based variants/successors like Silverlight, Xamarin Forms, UWP, and MAUI, and Avalonia being a "spiritual successor" to WPF meant that I didn't have a potential conceptual head start on Avalonia that one might have if they already had experience with WPF and its XAML-based derivatives.
  However, I was familiar with the MVVM pattern and data-binding, which is used heavily in Avalonia. I already had experience in knockout.js building/maintaining some of our web apps in my day job, and these concepts learned from knockout.js mostly translate cleanly 1:1 to Avalonia.
  The other Avalonia concepts I'll have to figure out as we go along.
  Challenge #2: WebAssembly (WASM) supportBefore I begin, I must take the MapGuide-knowledgable readers of this post back in time, way back to when MapGuide Open Source 1.0 was released.
  Do you remember how this new (at the time), re-invented version of MapGuide was released, but the only authoring option at the time was to buy a license of Autodesk MapGuide Studio? Not a pretty look if you are offering a free and open source web map GIS server, but the authoring tools are not?
  Some members of the MapGuide community were aware of this glaring discrepancy and created a web-based equivalent of MapGuide Studio called Web Studio built fully with HTML/JS/CSS. Unfortunately, Web Studio was really bare-bones in terms of authoring capabilities and the code being written in the pre-historic era of javascript (this was circa 2006-2007) which did not make it conductive to external contribution. React, TypeScript and friends weren't around then, so trying to enhance Web Studio with new features was extremely challenging. I once tried to add at least a generic XML text editor fallback for Web Studio so you had something to edit various resources where Web Studio did not provide a dedicated editor UI for, but alas this was just too challenging for me and I gave up on such an idea.
  But eventually another user of the MapGuide community solved this problem more directly by developing and releasing a v1.0 of a windows .net desktop application that you all know as MapGuide Maestro. As an aside, I am not the original author of MapGuide Maestro in case you're wondering, I merely took over development and maintenance of Maestro from the 2.1 release onwards.
  Anyways, back to the topic at hand, when I created the new Avalonia application with the provided project template, I was most surprised to see that the generated solution came with a project that compiled to WebAssembly (WASM) that was ready to run in your web browser!
  This was a mind-blowing revelation for me from a conceptual standpoint. It means our hypothetical MapGuide Maestro built on Avalonia could not only exist as a regular desktop application, but the WASM build of this application could be dropped in the the wwwroot of a MapGuide Web tier installation and you would now have a modern version of Web Studio, but much more powerful and capable, because it is just MapGuide Maestro ... now in your web browser!
  Since our starter project template includes a functioning WASM browser target. I now had a strong incentive to keep this target active and working, because the prospect of being able to run MapGuide Maestro in a web browser is a very tempting proposition. Therefore, the choice of libraries and APIs I use is constrained by my new requirement of being able to work in a browser/WASM environment.
  For example, I originally wanted to use MVVMDialogs to simplify working with dialogs (Maestro has lots of dialogs, so I figure such a library could be useful), but I couldn't get this library to work in a WASM environment with some of my testing dialogs, so this was a no-go. Since this was just a proof-of-concept, there wasn't a need to have working dialog system, but it does mean if this were to go beyond a proof-of-concept and into an actual application where we will inevitably have to present a dialog of some sort, I'd have to come with a paradigm that can work in both desktop and browsers.
  Another problem with this WASM target is that I can't seem to debug it in Visual Studio. You can launch the WASM target in the debugger and spawn a new browser window to launch your app, but any breakpoints you stick in your C# code are not being hit. I'm not sure if this a shortcoming or a broken feature, but it is somewhat concerning if we were to go full steam ahead with support WASM as a compilation/deployment target.Challenge #3: "Large scale" MVVMAlthough I already knew the MVVM pattern from knockout.js, my scope of usage was mostly limited to using knockout.js to building "islands" of interactive client-side content on primarily server-generated web pages. So I didn't really have an idea of how to apply such a pattern on a full blown Single Page Application (SPA), which is pretty much what we're trying to achieve (conceptually) in Avalonia. By the time I was building SPAs proper, I had moved on the popular stuff like React, which is how I gained the knowledge needed to build a modern replacement map viewer for MapGuide and my usage of knockout.js fell by the wayside as a result, so I never figured out the answer for how to do large scale MVVM.
  The main problem was that in a large scale MVVM, how do view models communicate with each other without a tight parent-child coupling?
  I deduced that for starters, we definitely need to use dependency injection. Various view models will need to access different services and if we had a root view model with explicit nested child view models (each with their own service requirements), it would be an absolute pain to have to setup these various view models. Using a DI container means we can offload this concern to it and we can focus on just asking the DI container for a particular view model and it will setup all the required services for it for us provided we register everything properly with the DI container.
  For better WASM support, I wanted a dependency injection container that is not driven by reflection to make the code more friendlier to app trimming. We want to be able to app trim on publish so that we can eliminate unused code and reduce the final binary size. This is most desirable for the WASM target as app trimming means smaller binaries, which means smaller payloads to download in a web browser. StrongInject was chosen for this reason as it was a "compile-time" DI container that can verify all your dependencies are registered properly before running the application through the magic of source generators, generating all the necessary registration and validation code for you.
  
  Finally, to be able to communicate between view models without necessary parent-child coupling, the messenger facility of the MVVM toolkit can be used. With this messenger facility, we simply:
  

  • Have select view models be recipients of certain messages
  • Have our application services (that various view model commands call) send these messages.
  • Relevant recipients get notified and update themselves (and their bound UIs) accordingly as a result.

  I don't know if this is the proper usage of MVVM pattern in a "large scale" application, but it makes sense internally in my mind.Challenge #4: TabControl binding of heterogenous/polymorphic contentOur proof-of-concept app has a main tab region where tabs of various document content are shown. I figured out easily that their TabControl component is supposed to be data-bound to an observable collection of view models, but what really stumped me was how bind this control to an observable collection of polymorphic editor view models?
  The reason is because the tab content we want to show is not homogenous. One open editor tab could be for a layer, one for a map, one for a feature source, etc, etc. So we need to be able to show different tabs on the same tab control. 
  Avalonia documentation is pretty scant on this topic. All examples I found assume homogenous series of tab content, which is not our case.
  Just for laughs, since AI has been hyped for soon taking away everyone's jobs (even us devs), I figured I'd ask huggingface chat (as a guest), how would you solve this problem?
  
  Unfortunately, the provided code sample does not work out of the box. It clearly assumed Avalonia = WPF and gave me a WPF-based solution. The giveaway was the Avalonia TabControl does not have an ItemTemplateSelector, but the WPF TabControl does.
  But Avalonia sharing many conceptual similarities with WPF meant that although the answer provided wasn't correct, parts of the answer were applicable and did lead me down to further avenues of inquiry and eventually I found the solution: It was to define a data template for every possible derived tab view model class in the same UserControl where the TabControl was specified.Final challenge: Avalonia VS designerThis wasn't so much a challenge, rather an annoyance. The Avalonia designer in Visual Studio has some teething issues

  • Intellisense/autocomplete is somewhat flaky when writing binding expressions and when you're doing a lot of data-binding, having the editor giving you and incomplete or outdated list of properties you can bind to becomes annoying. A full project build generally fixes this, but it is annoying having to do this every time I add new observable properties or commands to an existing view model class.
  • It's also not rename-aware, so observable property or command renames will result in stale binding expressions, causing havoc with the designer and have to be manually fixed up in the XAML. Choose your observable property names wisely I suppose, because renaming them afterwards is painful.

  The end result and overall thoughtsA week later from that post, after addressing and/or navigating around these various challenges, we have a functional skeleton application!
  
  
  
  
  And if these screenshots don't convince you, thanks to being able to deploy as a WASM target, I deployed a copy to GitHub pages, so you can see this app for yourself right in your WASM-enabled web browser!
  
  The source code for this app can be found here. One day this may form the basis of a new (true) multi-platform version of MapGuide Maestro, but for now this lies as a potentially useful starting point for building a tabbed-multi-document editor application with Avalonia.
  So what did I think of Avalonia from this little experiment? 

  • I like it mostly. My pre-existing experience on knockout.js helped greatly with picking up MVVM and data-binding. My initial prediction of a VSCode-style UI layout being buildable turned out to be true.
  • I like the default (project template provided) choice of MVVM Toolkit for applying the MVVM pattern. I like their heavy use of source generators to make adding new observable properties and commands to a view model being a simple case of tacking [ObservableProperty] on a field or tacking [RelayCommand] to a private method and having the source generator generate all of the boilerplate code for you (and it's a lot of boilerplate!).
  • The revelation that Avalonia has a WASM deployment target was both exciting and "cramping my style". It meant that certain libraries I wanted to use (eg. The MVVM dialogs library) could not be used and it wasn't clear what would work in a WASM browser environment and what wouldn't. Which leads to ...
  • Documentation is lacking in some areas. What really stumped me for a while was how do a TabControl bound to a collection of polymorphic or heterogenous tab view models. Their provided examples completely failed to tell me how to do this. I suppose if I came into this with existing WPF experience, this wouldn't have been so difficult as most of the concepts and patterns seem to be mostly transferable, but I happened to have skipped WPF and its bajillion XAML-based derivatives, so I didn't have this pre-existing knowledge to fall back on. Through perseverance and looking at the source code for many existing Avalonia applications on GitHub, I was finally able to determine that data templates was the solution.

  So all-in-all, this was a fun and useful exercise and you get a useful starting point app from this effort!
  Now I better get back onto this MapGuide/FDO work.

• 21 March 2024
• 17:47

  GIScussions: Your Map Inside

  sur Planet OSGeo
  

  A few weeks ago I recorded a Geomob Podcast with Ana Lucía González Paz about her beautiful flipbook, A Map Inside. You can read the book in a few minutes and then you can listen to the podcast

  [https:]]

  Towards the end of each podcast, I give my guest the opportunity to go off piste and talk about a subject that they choose (in the past we have talked about digital privacy, mental health and open source sustainability to mention just a few). Ana said that she would like to ask me to describe my Map Inside and you can hear how I replied at the end of the podcast.

  After we recorded the podcast, I was chatting with Ana and we thought that it would be fun to get other people to share their Map Inside. Everyone has a Map Inside connected to memories, people, special moments, would you like to share yours? Just record a short audio clip in mp3 format running for 60 to 120 seconds and mail it to me (if you don’t know my email use the Contact Form to reach me or find me at Mastodon). Assuming we get a few responses, Ana and I will put together an episode of the podcast with a selection of your Maps Inside.

  Hope to hear from you with your Map Inside

• 11:00

  Mappery: Route Map Not Available

  sur Planet OSGeo
  

  Kaakapoo shared this “A lack of #MapsintheWild today”

  I’m sure this will prompt some debate as to whether the absence of a Map qualifies as an entry here, but you know the rules (editors are always right)

  MapsintheWild Route Map Not Available

• 20 March 2024
• 15:19

  Jorge Sanz: Interview at Geomob Podcast

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  

  Earlier this week an episode of the Geomob Podcast was published where Steven Feldman interviews yours truly. It was a lot of fun to chat with Steven about Elastic, my experience in the geospatial industry, and Open Source in general. I could also advocate a bit about data privacy and digital identity which is a topic that has picked my interest even more lately with all the shit that is hitting that social network we all know about.

  If you want to learn a bit about Elastic and Geo this is maybe a good opportunity to get a condensed gist of why would anyone want to store and analyze geospatial data in Elasticsearch, a few compelling use cases and so on.

  [https:]]

  Cheers!

  Reply by mail or from the fediverse

• 11:00

  Mappery: Fushimi Inari-taisha Park

  sur Planet OSGeo
  

  Raf shared this beautiful map from Fushimi Inari-taisha park in Kyoto.

  MapsintheWild Fushimi Inari-taisha Park

• 1:00

  Camptocamp: Camptocamp at FOSSGIS 2024

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  Camptocamp will join other geospatial professionals at the FOSSGIS conference in Hamburg, Germany from March 20 to 23, 2024.
• 19 March 2024
• 20:12

  GeoTools Team: GeoTools 31.0 released

  sur Planet OSGeo
  GeoTools 31.0 released The GeoTools team is pleased to announce the release of the latest stable version of GeoTools 31.0: geotools-31.0-bin.zip geotools-31.0-doc.zip geotools-31.0-userguide.zip geotools-31.0-project.zip This release is also available from the OSGeo Maven Repository and is made in conjunction with GeoServer 2.25.0 and

• 14:43

  CityBuilder : faciliter la reconstruction 3D

  sur Oslandia
  Contexte

  Oslandia participe aux côtés d’Eviden au projet CP4SC, mené dans le cadre de l’AMI Cloud lancé en 2021 par la Banque Publique d’Investissement.

  Le sigle CP4SC signifie Cloud Platform for Sustainable Cities et son objectif est d’aider les gouvernements à mettre en œuvre des politiques ambitieuses vers l’atteinte de la neutralité carbone par ingestion des données issues de différentes sources comme la mobilité, la gestion de l’énergie ou l’observation de la terre et de l’environnement

  De quoi s’agit-il ?

  La visualisation 3D de bâtiments est un attendu de nombreux acteurs de la planification urbaine, attendu qui se heurte à deux écueils :

  • les données 3D structurées à grande échelle sont peu nombreuses
  • il n’existe pas de solution logicielle mature permettant de travailler à grande échelle, même si certains éditeurs proposent des outils propriétaires capables de travailler à l’échelle des bâtiments

  Cependant, la disponibilité et la diffusion de nuages de points de grande taille, prend beaucoup d’ampleur ces dernières années : les méthodes et outils de levés terrain ont beaucoup évolué et de nombreux acteurs en ont profité pour acquérir des nuages de points (y compris à l’échelle nationale comme c’est le cas en France avec la couverture Lidar en cours de constitution par l’IGN).

  Mais si les nuages de points peuvent être acquis rapidement, ils ne sont pas immédiatement exploitables pour tous les types d’analyse.

  L’objectif d’Oslandia à travers le projet est donc de proposer une chaine industrielle de traitement permettant de créer des données structurées depuis des nuages de points, ainsi que des logiciels permettant d’exploiter ces informations, l’ensemble sous licence opensource à gouvernance ouverte bien entendu !

  Nous avons déja présenté ici les outils Giro3D et Piero qui permettent la visualisation des données spatiales 3D. Nous allons maintenant parler génération de CityJSON !

  CityBuilder

  Parmi les différentes actions menées par Oslandia dans le cadre du projet, CityBuilder simplifie la reconstruction de données 3D géoréférencées. Notre objectif dans un premier temps est de proposer un plugin QGIS pour faciliter l’accès des utilisateurs aux fonctionnalités des outils sous-jacents.

  En effet CityBuilder exploite :

  • la bibliothèque opensource geoflow, développée par l’université de Delft et la société 3DGI. Geoflow a notamment été utilisé pour générer le bâti 3D de l’ensemble des Pays-Bas
  • la cartographie du sol et sursol LIDAR produite par l’IGN
  • les fonctionnalités de visualisation 3D de QGIS

  Concernant la démarche projet, nous avons travaillé initialement sur la première version prototypale de CityBuilder conjointement à un projet de développement informatique (PDI), séquence des cycles Master1 Géomatique et Ingénieur (2e année) de l’ENSG mené en partenariat avec Oslandia.

  En 2024 les travaux ont constitué en amélioration du plugin afin d’utiliser au maximum les outils natifs à QGIS, optimiser ses performances et réduire sa dette technique. Nous avons également intégré une version du code utilisable en ligne de commande.

  

  Geoflow a donc été intégré dans un processing QGIS intégré à la barre d’outils de processing QGIS.

  Geoflow permet de générer un fichier de sortie JSON à partir d’un fichier de données de nuage de point et un autre de données d’emprise de bâtiments. Nous utilisons la dernière version de geoflow permettant d’avoir un niveau de detail (LOD Level of Detail) allant jusqu’au LOD2.2.

  Pour la version ubuntu l’image docker de geoflow utilisé est celle de l’IGN.

  Des données 3D, et maintenant ?

  La visualisation des données générées peut se faire directement dans QGIS. Ceci est notamment possible grâce aux travaux menés sur le sujet par Oslandia depuis deux ans, qui consistent en une reprise de la dette technique embarquée, l’ajout de tests, des correctifs d’anomalies et le développement de nombreuses fonctionnalités bas niveau qui permettent aujourd’hui de disposer d’une version bien plus stable de QGIS 3D.

  Le projet CP4SC étant cloud native, il s’appuie sur Giro3D et son application de visualisation, Piero pour afficher l’ensemble des données spatiales y compris 3D : les données urbaines reconstruites peuvent donc être aussi consultées sur le web.

  Démonstration Contactez-nous !

  Le sujet vous intéresse ? Vous souhaitez mutualiser les efforts de développement sur ces sujets ? Vous voudriez incorporer ces fonctionnalités sur vos plateformes IT ? N’hésitez pas à nous contacter pour en discuter : infos+3d@oslandia.com

  

  Financé par l’Union européenne – Next Generation EU dans le cadre du plan France Relance

• 11:00

  Mappery: Drinking Longitude

  sur Planet OSGeo
  

  Javier asks whether this qualifies as a map in the wild? And we say “Why not?”

  The blurb on the bottle should say “This wine will coordinate well with food from any latitude”

  MapsintheWild Drinking Longitude

• 7:00

  [Témoignage Client] Pierrick Yalamas, Auvergne-Rhône-Alpes Énergie Environnement – TerriSTORY®

  sur Oslandia

  Pierrick Yalamas est Directeur intelligence territoriale et observatoires à Auvergne-Rhône-Alpes Énergie Environnement. Initiateur et coordinateur au niveau national du consortium TerriSTORY®, portant l’outil d’aide au pilotage de la transition écologique et énergétique du même nom, il pilote l’équipe de l’agence régionale AURA-EE qui travaille sur le projet. Il revient sur les enjeux du projet ainsi que la collaboration avec les équipes d’Oslandia qui ont travaillé sur les volets techniques et fonctionnels dès 2018.

  A quels enjeux répond ce projet ?

  En tant qu’Agence régionale, nous sommes opérateurs depuis une vingtaine d’années d’Observatoires copilotés par l’Etat et la Région. Notre mission : collecter, produire, traiter et diffuser des données sur le climat, l’énergie, les déchets, les ressources, … afin de les mettre à disposition des territoires pour les accompagner sur les enjeux écologiques.
  Avant TerriSTORY®, nous disposions de tableaux et documents mis en forme qui s’avéraient insuffisants pour aider les territoires à passer à l’action.

  Avec TerriSTORY®, nous disposons aujourd’hui d’un véritable outil d’aide à la décision qui permet de :

  • Rendre les données plus appropriables, grâce aux technologies de datavisualisation, à des personnes non initiées aux enjeux énergies / climat, notamment les élus et décideurs du territoire.
  • Repositionner la transition écologique dans des enjeux de transition territoriale plus globale grâce au croisement de données sur l’énergie avec des données sur les mobilités, les ressources, les bâtiments, … Nous proposons aujourd’hui une approche systémique.
  • Donner les clés permettant de construire une trajectoire et établir des scénarios pour mesurer les différents impacts en termes énergétique, carbone, mais aussi économique ou sur la qualité de l’air.
  • Proposer des outils de pilotage des trajectoires et permettre un pilotage coordonné, dans une logique d’articulation entre les différents territoires.

  TerriSTORY® aujourd’hui ?

  L’outil a été initié en Auvergne-Rhône-Alpes et nous avons proposé à d’autres Régions de mutualiser les développements. Il est aujourd’hui mis à disposition de tous dans 6 régions qui ont accès au module dataviz mais aussi au module « Stratégie territoriale » pour aider au pilotage de la trajectoire.

  Comment s’est passée la collaboration avec les équipes d’Oslandia ?

  La collaboration s’est très bien passée. Nous avons travaillé en mode très agile avec la contrainte d’un budget limité au départ. Nous avons instauré une relation de confiance au cours de laquelle Oslandia a initié les développements et a formé nos équipes en interne pour qu’elles s’approprient les technologies. J’ai apprécié que cela se passe en totale coopération. Oslandia nous a également fait bénéficier de son expérience pour préparer le passage en open-source qui a eu lieu début 2023.

• 1:00

  GeoServer Team: GeoServer 2.25.0 Release

  sur Planet OSGeo

  GeoServer 2.25.0 release is now available with downloads (bin, war, windows), along with docs and extensions.

  This is a stable release of GeoServer recommended for production use. GeoServer 2.25.0 is made in conjunction with GeoTools 31.0, and GeoWebCache 1.25.0.

  Thanks to Peter Smythe for making this release. Thanks to Levy Steve, Peter Smythe, Jody Garnett, and Mark Prins for testing the 2.25.0 release.

  Security Considerations

  This release addresses several security vulnerabilities, all of which require admin access.

  • If you have updated to GeoServer 2.24.2 Release or GeoServer 2.23.5 Release you are already patched.
  • If you are working with a commercial support provider that volunteers with the geoserver-security email list they are already informed.

  Vulnerabilities:

  • CVE-2023-51444 Arbitrary file upload vulnerability in REST Coverage Store API (High).
  • CVE-2023-41877 GeoServer log file path traversal vulnerability (High).
  • CVE-2024-23634 Arbitrary file renaming vulnerability in REST Coverage/Data Store API (Moderate).
  • CVE-2024-23643 Stored Cross-Site Scripting (XSS) vulnerability in GWC Seed Form (Moderate).
  • CVE-2024-23821 Stored Cross-Site Scripting (XSS) vulnerability in GWC Demos Page (Moderate).
  • CVE-2024-23819 Stored Cross-Site Scripting (XSS) vulnerability in MapML HTML Page (Moderate).
  • CVE-2024-23818 Stored Cross-Site Scripting (XSS) vulnerability in WMS OpenLayers Format (Moderate).
  • CVE-2024-23642 Stored Cross-Site Scripting (XSS) vulnerability in Simple SVG Renderer (Moderate).
  • CVE-2024-23640 Stored Cross-Site Scripting (XSS) vulnerability in Style Publisher (Moderate).
  • CVE-2023-51445 Stored Cross-Site Scripting (XSS) vulnerability in REST Resources API (Moderate).

  We would like to thank everyone who contributed to reporting, verifying and fixing the above vulnerabilities (see each CVE for appropriate credits). A special thank you to Steve Ikeoka for reporting most of the issues and doing the majority of the actual fixes.

  The use of the CVE system allows the GeoServer team to reach a wider audience than blog posts. See the project security policy for more information on how security vulnerabilities are managed.

  Upgrade Notes

  We have a number of configuration changes when updating an existing system:

  • The longstanding ENTITY_RESOLUTION_ALLOWLIST setting has been recommended as a way to control the locations available for external entity resolution when parsing XML documents and requests.

    The default has changed from * (allowing any location) to allowing the recommended www.w3.org, schemas.opengis.net, www.opengis.net locations used for OGC Web Services, along with the inspire.ec.europa.eu/schemas location used by our friends in Europe.

  • The FreeMarker Template HTML Auto-escaping is now enabled by default.

  • The spring security firewall is now enabled by default.

  • A new configuration setting is available to limit content served from the geoserver/www folder.

    If you have not met the www folder before it is used to share content, and there is a tutorial serving static files.

  • We do add recommendations to production considerations over time, if you have not checked that page in a while please review.

  Thanks to Steve Ikeoka and Jody Garnett for these improvements.

  JTS fast polygon intersection enabled by default

  The JTS Next Generation polygon intersection algorithm has been enabled by default, which will improve performance of a number of operations, including WPS processes and the vector tiles generation. We deem the functionality well tested enough that it should be opened to the majority of users, even if it’s still possible to turn it off by adding the -Djts.overlay=old.

  

  MapML Extension

  The MapML extension is receiving a number of updates and improvements, with more to come in the following months. It’s now possible to declare “Tiled CRS” as the CRS for a layer, with the implication not just of the CRS, but also of the gridset that will be used by the MapML viewer:

  

  This portion builds on top of the work done months ago to support astronomical CRSs, which allows GeoServer to support multiple CRS authorities.

  The MapML preview links are now using the new MapML output format, while the old dedicated REST controller has been removed. This allows for better integration of the MapML format in the GeoServer ecosystem. The MapML viewer has also been updated to the latest version:

  

  Thanks to Joseph Miller and Andrea Aime (GeoSolutions) for this work, and Natural Resources Canada for sponsoring it.

  Community Module Updates

  Much of the new activity in GeoServer starts as a community module. We’d like to remind you that these modules are not yet supported, and invite you to join the effort by participating in their development, as well as testing them and providing feedback.

  Raster Attribute Table community module

  Developed as part of GEOS-11175, the Raster Attribute Table community module uses the GDAL Raster Attribute Table (RAT) to provide a way to associate attribute information for individual pixel values within the raster, to create styles as well as to provide a richer GetFeatureInfo output.

  

  

  For more information see the user guide.

  We’d like to thank Andrea Aime (GeoSolutions) for the development and NOAA for sponsoring.

  Graticules for WMS maps

  The graticules community module, developed as part of GEOS-11216, provides a datastore generating graticules for WMS maps, along with a rendering transformation that can be used to label them. The module can be used to draw a graticule in WMS maps, as well as to download them as part of WFS (or in combination with the WPS download module).

  

  

  We’d like to thank Ian Turton for development and GeoSolutions for sponsoring the work.

  GeoServer monitor Kafka storage

  The monitoring Kafka storage module, developed as part of GEOS-11150, allows storing the requests captured by the monitoring extension into a Kafka topic.

  

  We’d like to thank Simon Hofer for sharing his work with the community. To learn more about the module, how to install and use it, see the user-guide.

  JWT Headers

  The JWT headers module has been developed as part of GEOS-11317.

  

  The module is a new authentication filter that can read JWT Headers, as well as general JSON payloads and simple strings, to identify a user, as well as to extract their roles. The combination of Apache mod_auth_openidc with geoserver-jwt-headers-plugin provides an alternative to using the geoserver-sec-oauth2-openid-connect-plugin plugin.

  We’d like to thank David Blasby (GeoCat) for this work on this module.

  Developer Updates ResourceStore / Paths API Change

  Developers should keep in mind some important maintenance work performed by Niels Charlier on the use absolute and relative paths in the ResourceStore. See the Developers Guide for more information.

  This does not affect end users.

  Experimental Java 21 support

  GeoServer, along with GeoTools and GeoWebCache, are now tested to build and pass tests with Java 21.

  This is not yet an endorsement to run GeoServer in production with Java 21. We are looking ahead at the 2024 roadmap, and are making sure the basics are covered for the newer Java releases.

  Full Release notes

  New Feature:

  • GEOS-11225 [AuthKey] AuthKey synchronize the user/group automatically

  MapML:

  • GEOS-10438 ENTITY_RESOLUTION_ALLOWLIST property not parsing empty setting
  • GEOS-11207 Refactor MapML MVC controller as GetMap-based operation with standard parameter format
  • GEOS-11221 mkdocs preflight rst fixes
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11297 Escape WMS GetFeatureInfo HTML output by default
  • GEOS-11300 Centralize access to static web files

  Improvement:

  • GEOS-11306 Java 17 does not support GetFeature lazy JDBC count(*)
  • GEOS-11130 Sort parent role dropdown in Add a new role
  • GEOS-11142 Add mime type mapping for yaml files
  • GEOS-11148 Update response headers for the Resources REST API
  • GEOS-11149 Update response headers for the Style Publisher
  • GEOS-11152 Improve handling special characters in the Simple SVG Renderer
  • GEOS-11153 Improve handling special characters in the WMS OpenLayers Format
  • GEOS-11155 Add the X-Content-Type-Options header
  • GEOS-11173 Default to using [HttpOnly] session cookies
  • GEOS-11176 Add validation to file wrapper resource paths
  • GEOS-11213 Improve REST external upload method unzipping
  • GEOS-11222 Include Conformance Class for “Search” from OGC API - Features Part 5 proposal
  • GEOS-11226 Enable JTS OverlayNG by default
  • GEOS-11246 Schemaless plugin performance for WFS
  • GEOS-11247 Avoid HTML annotations special status in APIBodyProcessor
  • GEOS-11248 Move version header handling from APIBodyMethodProcessor to APIDispatcher
  • GEOS-11260 JNDI tutorial uses outdated syntax
  • GEOS-11288 Improve input validation in ClasspathPublisher
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11298 When a Raster Attribute Table is available, expose its attributes in GetFeatureInfo
  • GEOS-11327 Add warning about using embedded data directories
  • GEOS-11334 Update MapML viewer to release 0.13.1

  Bug:

  • GEOS-11050 jdbc-store broken by changes to Paths.names
  • GEOS-11051 Env parametrization does not save correctly in AuthKey extension
  • GEOS-11145 The GUI “wait spinner” is not visible any longer
  • GEOS-11182 Avoid legends with duplicated entries
  • GEOS-11187 Configuring a raster with NaN as NODATA results in two NaN in the nodata band description
  • GEOS-11190 GeoFence: align log4j2 deps
  • GEOS-11203 WMS GetFeatureInfo bad WKT exception for label-geometry
  • GEOS-11224 Platform independent binary doesn’t start properly with default data directory
  • GEOS-11250 WFS GeoJSON encoder fails with an exception if an infinity number is used in the geometry
  • GEOS-11278 metadata: only selected tab is submitted
  • GEOS-11312 Used memory calculation fix on legend WMS request
  • GEOS-11266 csw-iso: missing fields in summary response
  • GEOS-11312 Inconsistent Memory Units in Legend Image Creation
  • GEOS-11335 A layer in an authority other than EPSG may fail to reload after restart

  Task:

  • GEOS-11242 Remove the Xalan library
  • GEOS-11315 Revert to CORS commented out
  • GEOS-11318 Update postgresql to 42.7.2
  • GEOS-11134 Feedback on download bundles: README, RUNNING, GPL html files
  • GEOS-11141 production consideration for logging configuration hardening
  • GEOS-11159 Update mapfish-print-lib 2.3.0
  • GEOS-11180 Update ImageIO-EXT to 1.4.9
  • GEOS-11181 Update jai-ext to 1.1.25
  • GEOS-11186 Fix maven enforcer failFast
  • GEOS-11220 Upgrade Hazelcast from 5.3.1 to 5.3.6
  • GEOS-11245 Update OSHI from 6.2.2 to 6.4.10
  • GEOS-11316 Update Spring version to 5.3.32

  For the complete list see 2.25.0 release notes.

  Community Updates

  Community module development:

  • GEOS-11305 Add layer information in the models backing STAC
  • GEOS-11146 Fix MBTiles output format test
  • GEOS-11184 ncwms module has a compile dependency on gs-web-core test jar
  • GEOS-11209 Open ID Connect Proof Key of Code Exchange (PKCE)
  • GEOS-11212 OIDC accessToken verification using only JWKs URI
  • GEOS-11219 Upgraded mail and activation libraries for SMTP compatibility
  • GEOS-11293 Improve performance of wps-lontigudinal-profile
  • GEOS-11216 Create a datastore to produce graticules for WMS maps.

  Community modules are shared as source code to encourage collaboration. If a topic being explored is of interest to you, please contact the module developer to offer assistance.

  About GeoServer 2.25 Series

  Additional information on GeoServer 2.25 series:

  • GeoServer 2.25 User Manual
  • GeoServer 2024 Roadmap Plannings

  Release notes: ( 2.25.0 | 2.25-RC )

• 1:00

  GeoServer Team: GeoServer 2.25.0 Release

  sur Planet OSGeo

  GeoServer 2.25.0 release is now available with downloads (bin, war, windows), along with docs and extensions.

  This is a stable release of GeoServer recommended for production use. GeoServer 2.25.0 is made in conjunction with GeoTools 31.0, and GeoWebCache 1.25.0.

  Thanks to Peter Smythe for making this release. Thanks to Levy Steve, Peter Smythe, Jody Garnett, and Mark Prins for testing the 2.25.0 release.

  Security Considerations

  This release addresses several security vulnerabilities, all of which require admin access.

  • If you have updated to GeoServer 2.24.2 Release or GeoServer 2.23.5 Release you are already patched.
  • If you are working with a commercial support provider that volunteers with the geoserver-security email list they are already informed.

  Vulnerabilities:

  • CVE-2023-51444 Arbitrary file upload vulnerability in REST Coverage Store API (High).

  • CVE-2023-41877 GeoServer log file path traversal vulnerability (High).

  • CVE-2024-23634 Arbitrary file renaming vulnerability in REST Coverage/Data Store API (Moderate).

  • CVE-2024-23643 Stored Cross-Site Scripting (XSS) vulnerability in GWC Seed Form (Moderate).

  • CVE-2024-23821 Stored Cross-Site Scripting (XSS) vulnerability in GWC Demos Page (Moderate).

  • CVE-2024-23819 Stored Cross-Site Scripting (XSS) vulnerability in MapML HTML Page (Moderate).

  • CVE-2024-23818 Stored Cross-Site Scripting (XSS) vulnerability in WMS OpenLayers Format (Moderate).

  • CVE-2024-23642 Stored Cross-Site Scripting (XSS) vulnerability in Simple SVG Renderer (Moderate).

  • CVE-2024-23640 Stored Cross-Site Scripting (XSS) vulnerability in Style Publisher (Moderate).

  • CVE-2023-51445 Stored Cross-Site Scripting (XSS) vulnerability in REST Resources API (Moderate).

  We would like to thank everyone who contributed to reporting, verifying and fixing the above vulnerabilities (see each CVE for appropriate credits). A special thank you to Steve Ikeoka for reporting most of the issues and doing the majority of the actual fixes.

  The use of the CVE system allows the GeoServer team to reach a wider audience than blog posts. See the project security policy for more information on how security vulnerabilities are managed.

  Upgrade Notes

  We have a number of configuration changes when updating an existing system:

  • The longstanding ENTITY_RESOLUTION_ALLOWLIST setting has been recommended as a way to control the locations available for external entity resolution when parsing XML documents and requests.

    The default has changed from * (allowing any location) to allowing the recommended www.w3.org, schemas.opengis.net, www.opengis.net locations used for OGC Web Services, along with the inspire.ec.europa.eu/schemas location used by our friends in Europe.

  • The FreeMarker Template HTML Auto-escaping is now enabled by default.

  • The spring security firewall is now enabled by default.

  • A new configuration setting is available to limit content served from the geoserver/www folder.

    If you have not met the www folder before it is used to share content, and there is a tutorial serving static files.

  • We do add recommendations to production considerations over time, if you have not checked that page in a while please review.

  Thanks to Steve Ikeoka and Jody Garnett for these improvements.

  JTS fast polygon intersection enabled by default

  The JTS Next Generation polygon intersection algorithm has been enabled by default, which will improve performance of a number of operations, including WPS processes and the vector tiles generation. We deem the functionality well tested enough that it should be opened to the majority of users, even if it’s still possible to turn it off by adding the -Djts.overlay=old.

  

  MapML Extension

  The MapML extension is receiving a number of updates and improvements, with more to come in the following months. It’s now possible to declare “Tiled CRS” as the CRS for a layer, with the implication not just of the CRS, but also of the gridset that will be used by the MapML viewer:

  

  This portion builds on top of the work done months ago to support astronomical CRSs, which allows GeoServer to support multiple CRS authorities.

  The MapML preview links are now using the new MapML output format, while the old dedicated REST controller has been removed. This allows for better integration of the MapML format in the GeoServer ecosystem. The MapML viewer has also been updated to the latest version:

  

  Thanks to Joseph Miller and Andrea Aime (GeoSolutions) for this work, and Natural Resources Canada for sponsoring it.

  Community Module Updates

  Much of the new activity in GeoServer starts as a community module. We’d like to remind you that these modules are not yet supported, and invite you to join the effort by participating in their development, as well as testing them and providing feedback.

  Raster Attribute Table community module

  Developed as part of GEOS-11175, the Raster Attribute Table community module uses the GDAL Raster Attribute Table (RAT) to provide a way to associate attribute information for individual pixel values within the raster, to create styles as well as to provide a richer GetFeatureInfo output.

  

  

  For more information see the user guide.

  We’d like to thank Andrea Aime (GeoSolutions) for the development and NOAA for sponsoring.

  Graticules for WMS maps

  The graticules community module, developed as part of GEOS-11216, provides a datastore generating graticules for WMS maps, along with a rendering transformation that can be used to label them. The module can be used to draw a graticule in WMS maps, as well as to download them as part of WFS (or in combination with the WPS download module).

  

  

  We’d like to thank Ian Turton for development and GeoSolutions for sponsoring the work.

  GeoServer monitor Kafka storage

  The monitoring Kafka storage module, developed as part of GEOS-11150, allows storing the requests captured by the monitoring extension into a Kafka topic.

  

  We’d like to thank Simon Hofer for sharing his work with the community. To learn more about the module, how to install and use it, see the user-guide.

  JWT Headers

  The JWT headers module has been developed as part of GEOS-11317.

  

  The module is a new authentication filter that can read JWT Headers, as well as general JSON payloads and simple strings, to identify a user, as well as to extract their roles. The combination of Apache mod_auth_openidc with geoserver-jwt-headers-plugin provides an alternative to using the geoserver-sec-oauth2-openid-connect-plugin plugin.

  We’d like to thank David Blasby (GeoCat) for this work on this module.

  Developer Updates ResourceStore / Paths API Change

  Developers should keep in mind some important maintenance work performed by Niels Charlier on the use absolute and relative paths in the ResourceStore. See the Developers Guide for more information.

  This does not affect end users.

  Experimental Java 21 support

  GeoServer, along with GeoTools and GeoWebCache, are now tested to build and pass tests with Java 21.

  This is not yet an endorsement to run GeoServer in production with Java 21. We are looking ahead at the 2024 roadmap, and are making sure the basics are covered for the newer Java releases.

  Full Release notes

  New Feature:

  • GEOS-11225 [AuthKey] AuthKey synchronize the user/group automatically

  MapML:

  • GEOS-10438 ENTITY_RESOLUTION_ALLOWLIST property not parsing empty setting
  • GEOS-11207 Refactor MapML MVC controller as GetMap-based operation with standard parameter format
  • GEOS-11221 mkdocs preflight rst fixes
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11297 Escape WMS GetFeatureInfo HTML output by default
  • GEOS-11300 Centralize access to static web files

  Improvement:

  • GEOS-11130 Sort parent role dropdown in Add a new role
  • GEOS-11142 Add mime type mapping for yaml files
  • GEOS-11148 Update response headers for the Resources REST API
  • GEOS-11149 Update response headers for the Style Publisher
  • GEOS-11152 Improve handling special characters in the Simple SVG Renderer
  • GEOS-11153 Improve handling special characters in the WMS OpenLayers Format
  • GEOS-11155 Add the X-Content-Type-Options header
  • GEOS-11173 Default to using [HttpOnly] session cookies
  • GEOS-11176 Add validation to file wrapper resource paths
  • GEOS-11213 Improve REST external upload method unzipping
  • GEOS-11222 Include Conformance Class for “Search” from OGC API - Features Part 5 proposal
  • GEOS-11226 Enable JTS OverlayNG by default
  • GEOS-11246 Schemaless plugin performance for WFS
  • GEOS-11247 Avoid HTML annotations special status in APIBodyProcessor
  • GEOS-11248 Move version header handling from APIBodyMethodProcessor to APIDispatcher
  • GEOS-11260 JNDI tutorial uses outdated syntax
  • GEOS-11288 Improve input validation in ClasspathPublisher
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11298 When a Raster Attribute Table is available, expose its attributes in GetFeatureInfo
  • GEOS-11327 Add warning about using embedded data directories
  • GEOS-11334 Update MapML viewer to release 0.13.1

  Bug:

  • GEOS-11050 jdbc-store broken by changes to Paths.names
  • GEOS-11051 Env parametrization does not save correctly in AuthKey extension
  • GEOS-11145 The GUI “wait spinner” is not visible any longer
  • GEOS-11182 Avoid legends with duplicated entries
  • GEOS-11187 Configuring a raster with NaN as NODATA results in two NaN in the nodata band description
  • GEOS-11190 GeoFence: align log4j2 deps
  • GEOS-11203 WMS GetFeatureInfo bad WKT exception for label-geometry
  • GEOS-11224 Platform independent binary doesn’t start properly with default data directory
  • GEOS-11250 WFS GeoJSON encoder fails with an exception if an infinity number is used in the geometry
  • GEOS-11278 metadata: only selected tab is submitted
  • GEOS-11312 Used memory calculation fix on legend WMS request
  • GEOS-11266 csw-iso: missing fields in summary response
  • GEOS-11312 Inconsistent Memory Units in Legend Image Creation
  • GEOS-11335 A layer in an authority other than EPSG may fail to reload after restart

  Task:

  • GEOS-11242 Remove the Xalan library
  • GEOS-11315 Revert to CORS commented out
  • GEOS-11318 Update postgresql to 42.7.2
  • GEOS-11134 Feedback on download bundles: README, RUNNING, GPL html files
  • GEOS-11141 production consideration for logging configuration hardening
  • GEOS-11159 Update mapfish-print-lib 2.3.0
  • GEOS-11180 Update ImageIO-EXT to 1.4.9
  • GEOS-11181 Update jai-ext to 1.1.25
  • GEOS-11186 Fix maven enforcer failFast
  • GEOS-11220 Upgrade Hazelcast from 5.3.1 to 5.3.6
  • GEOS-11245 Update OSHI from 6.2.2 to 6.4.10
  • GEOS-11316 Update Spring version to 5.3.32

  For the complete list see 2.25.0 release notes.

  Community Updates

  Community module development:

  • GEOS-11305 Add layer information in the models backing STAC
  • GEOS-11146 Fix MBTiles output format test
  • GEOS-11184 ncwms module has a compile dependency on gs-web-core test jar
  • GEOS-11209 Open ID Connect Proof Key of Code Exchange (PKCE)
  • GEOS-11212 OIDC accessToken verification using only JWKs URI
  • GEOS-11219 Upgraded mail and activation libraries for SMTP compatibility
  • GEOS-11293 Improve performance of wps-lontigudinal-profile
  • GEOS-11216 Create a datastore to produce graticules for WMS maps.

  Community modules are shared as source code to encourage collaboration. If a topic being explored is of interest to you, please contact the module developer to offer assistance.

  About GeoServer 2.25 Series

  Additional information on GeoServer 2.25 series:

  • GeoServer 2.25 User Manual
  • GeoServer 2024 Roadmap Plannings

  Release notes: ( 2.25.0 | 2.25-RC )

• 18 March 2024
• 20:16

  Free and Open Source GIS Ramblings: Getting started with pygeoapi processes

  sur Planet OSGeo

  Today’s post is a quick introduction to pygeoapi, a Python server implementation of the OGC API suite of standards. OGC API provides many different standards but I’m particularly interested in OGC API – Processes which standardizes geospatial data processing functionality. pygeoapi implements this standard by providing a plugin architecture, thereby allowing developers to implement custom processing workflows in Python.

  I’ll provide instructions for setting up and running pygeoapi on Windows using Powershell. The official docs show how to do this on Linux systems. The pygeoapi homepage prominently features instructions for installing the dev version. For first experiments, however, I’d recommend using a release version instead. So that’s what we’ll do here.

  As a first step, lets install the latest release (0.16.1 at the time of writing) from conda-forge:

  conda create -n pygeoapi python=3.10
  conda activate pygeoapi
  mamba install -c conda-forge pygeoapi

  Next, we’ll clone the GitHub repo to get the example config and datasets:

  cd C:\Users\anita\Documents\GitHub\
  git clone [https:] 
  cd pygeoapi\

  To finish the setup, we need some configurations:

  cp pygeoapi-config.yml example-config.yml  
  # There is a known issue in pygeoapi 0.16.1: [https:] 
  # To fix it, edit the example-config.yml: uncomment the TinyDB option in the server settings (lines 51-54)
  
  $Env:PYGEOAPI_CONFIG = "F:/Documents/GitHub/pygeoapi/example-config.yml"
  $Env:PYGEOAPI_OPENAPI = "F:/Documents/GitHub/pygeoapi/example-openapi.yml"
  pygeoapi openapi generate $Env:PYGEOAPI_CONFIG --output-file $Env:PYGEOAPI_OPENAPI

  Now we can start the server:

  pygeoapi serve

  And once the server is running, we can send requests, e.g. the list of processes:

  curl.exe [localhost:5000] 

  And, of course, execute the example “hello-world” process:

  curl.exe --% -X POST [localhost:5000] -H "Content-Type: application/json" -d "{\"inputs\":{\"name\": \"hi there\"}}"

  As you can see, writing JSON content for curl is a pain. Luckily, pyopenapi comes with a nice web GUI, including Swagger UI for playing with all the functionality, including the hello-world process:

  

  It’s not really a geospatial hello-world example, but it’s a first step.

  Finally, I wan’t to leave you with a teaser since there are more interesting things going on in this space, including work on OGC API – Moving Features as shared by the pygeoapi team recently:

  

  So, stay tuned.

• 20:12

  GRASS GIS: 2024 GRASS GIS Community meeting in Prague!

  sur Planet OSGeo
  The GRASS GIS team announces the annual Community Meeting!! The GRASS GIS Community Meeting will take place from June 14 to 19, 2024, at the NC State European Center in Prague, Czech Republic. Community meetings are great opportunities to support the development of GRASS GIS! Join us Write code Write documentation Translation Website design and content Integrations with other software (QGIS, GDAL, R, etc.) Plan for the future The community meeting is a get-together where supporters, contributors, power users and developers make decisions and tackle larger problems related to the project, discuss and fix bugs, draw the project roadmap and work on new features.
• 13:00

  Fernando Quadro: Geoprocessamento no Agronegócio

  sur Planet OSGeo

  O geoprocessamento na agricultura reúne tecnologias e métodos essenciais para coletar, tratar e analisar diversos dados sobre a produção agropecuária.

  Com isso o produtor pode ter acesso a imagens e mapas precisos, além de poder traçar planejamentos mais eficientes. Assim consegue aumentar a produtividade e se tornar mais competitivo.

  Por isso, o investimento em tecnologias de geoprocessamento na agricultura é considerado fundamental para o produtor que quer melhorar seus resultados.

  Mas, como isso pode ajudar o agricultor na prática? Vamos citar abaixo alguns benefícios:

  Acesso a informações mais detalhadas sobre cada talhão
  Identificação de tendências de produtividade
  Permitir o trabalho com parceiros de negócio
  Identificação de pragas e doenças
  Controle de plantas daninhas

  O uso do WebGIS vem sendo uma tendência que cresce a cada dia nesse setor. Sua possibilidade de interação e disponibilização de informações para o usuário é um elemento fundamental que faz com que este tipo de sistema de informação geográfica conectado à internet seja uma importante vertente para o futuro das geotecnologias.

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

• 11:00

  Mappery: No Cigars!

  sur Planet OSGeo
  

  Reinder sent this pic, he said “In Amsterdam, they named the Balthasar Floriszstraat after a 17th C. mapmaker. In this street I ran into a rather peculiar world map. The caption says ‘No Cigars'”

  MapsintheWild No Cigars!

• 1:00

  Camptocamp: Camptocamp Heads to FOSSGIS 2024

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  The Camptocamp team is gearing up for another great experience at the FOSSGIS conference.
• 17 March 2024
• 11:00

  Mappery: Rishikesh Hostel

  sur Planet OSGeo
  

  Elizabeth is back in Rishikesh and sent thios pic from the lobby of her hostel

  MapsintheWild Rishikesh Hostel

• 0:00

  Ecodiv.earth: Download AHN data in GRASS GIS

  sur Planet OSGeo

  

  The AHN

  The ‘Actueel Hoogtebestand Nederland’ (AHN, version 4) is the latest digital elevation model (DEM) of the Netherlands. It includes a digital terrain model (DTM) and a digital surface model (DSM). The former represents the bare ground surface without any features such as buildings, vegetation, or other structures, while the latter includes these features.

  Both layers can be downloaded at 0.5 or 5 meter resolution in tiles of 6.5 by 5 km. Downloading one tile, which is approximately 500 MB, is doable. However, if you need more tiles, the arguably easier way is to download the data using the WCS (Web Coverage Service) protocol, which allows you to choose what part of the available data to download based on spatial constraints.

  Import the DTM

  This example shows the steps to download the 0.5 meter resolutiom DTM for the Land van Cuijk, a municipality in which our research group Climate-robust Landscapes is carrying out several studies. The first step is to get the r.in.wcs addon. With this addon, you can use the WCS protocol to download data ^{1 2}.

  • Step 1
  • GUI

  Install the r.in.wcs addon.

  First step is to import the Python libraries. Note, this will not be repeated with the next scripts.

  import grass.script as gs

  Now, you can install the r.in.wcs addon using the g.extension function.

  gs.run_command("g.extension", extension="r.in.wcs")

  You need the g.extension function to install addons. In the main menu, go to Settings > Addons extension > Install extension from addon. Alternatively, type in g.extension on the command line. This will open the window shown below.

  

  The g.extension function, started from the command line.

  The r.in.wcs addon imports the raster layers using the resolution and extent of the current region. A crucial step, therefore, is to set the extent and resolution of the region so that it aligns perfectly with that of the AHN layer.

  • Step 2
  • GUI

  Set the extent and resolution to match those of the AHN.

  gs.run_command("g.region",
      n=618750, 
      s=306250, 
      w=10000, 
      e=280000, 
      res=0.5)

  Type in g.region on the command line or in the console. You can also find the function under main menu > Settings > Computational region > set region. This opens the following screen:

  

  Set the bounds

  

  Set the resolution

  With this settings, you align the region with the AHN data set.

  Next, download the administrative boundaries of the Dutch municipalities, and extract the boundaries of the “Land van Cuijk”.

  • Step 3
  • GUI

  Download layer with administrative boundaries of the neighborhood.

  gs.run_command(
      "v.in.wfs",
      url="https://service.pdok.nl/cbs/wijkenbuurten/2022/wfs/v1_0?",
      output="municipalities",
      name="gemeenten",
  )

  Next, extract the boundaries of the municipality of “Land van Cuijk”

  gs.run_command(
      "v.extract",
      input="municipalities",
      where="naam = 'Land van Cuijk'",
      output="LandvanCuijk",
  )

  Type in v.in.wfs on the command line or in the console. You can also find the function under main menu > File > Import vector data. This opens the following screen (you need to fill in parameters in two tabs):

  

  Download the vector layer with the municipality boundaries. Define the base URL and the name of the output layer.

  

  Download the vector layer with the municipality boundaries. Fill in the name of the WFS layer to download.

  

  Extract the boundaries of the municipality of Land van Cuijk. Select the name of the vector layer with municipalities and give the name of the output layer.

  

  Extract the boundaries of the municipality of Land van Cuijk. Fill in the query, which defines which features you want to select and save. Tip: Use the convenient query builder.

  Now, you can set the region to match the extent of the vector layer, while taking care that the region aligns perfectly with the DTM.

  • Step 4

  Set the region to the correct extent and resolution.

  First, get the north, south, east, and west coordinates of the bounding box of the vector layer and of the region’s extent.

  region_tiles = gs.parse_command("g.region", 
      flags="gu")
  region_munic = gs.parse_command("v.info", 
      flags="g", 
      map="LandvanCuijk")

  Now, adjust the northern boundary of the bounding box of the vector layer so that it aligns with the AHN tiles.

  from math import floor
  
  n = float(region_tiles["n"]) - floor(
      (float(region_tiles["n"]) - float(region_munic["north"]))
  )
  s = float(region_tiles["s"]) + floor(
      (float(region_munic["south"]) - float(region_tiles["s"]))
  )
  w = float(region_tiles["w"]) + floor(
      (float(region_munic["west"]) - float(region_tiles["w"]))
  )
  e = float(region_tiles["e"]) - floor(
      (float(region_tiles["e"]) - float(region_munic["east"]))
  )
  gs.run_command("g.region", n=n, s=s, e=e, w=w)

  And finally, import the DTM layer. Warming, this may take some time.

  • Step 5
  • GUI

  Import the DTM for the defined region.

  gs.run_command(
      "r.in.wcs",
      url="https://service.pdok.nl/rws/ahn/wcs/v1_0?",
      coverage="dtm_05m",
      urlparams="GetMetadata",
      output="dtm_05",
  )

  The maximum floating-point value (3.4028235e+38) is not recognized as a NULL value. So use the setnull parameter in the r.null function to specify that this value has to be set to NULL.

  gs.run_command("r.null", 
      map="dtm_05", 
      setnull=3.4028235e+38)

  If this does not work (it didn’t for me), you can use the r.mapcalc function to set this value to NULL.

  gs.run_command("r.mapcalc", 
      expression="dtm_05m = if(dtm_05m > 1000,null(),dtm_05m)",
      overwrite=True)

  

  Fill in the WCS service URL

  

  Get the overage name to request

  To make it a bit easier, I combined steps 2, 4, and 5 in a new addon r.in.ahn. It is a bit rough around the edges (it only works in a Location with CRS RD New), but it serves its goal. I have submitted it to the GRASS GIS addon repository, so I hope it will be available in a week or so.

  Footnotes

  1. You are expected to be familiar with GRASS GIS and the concept of region used in GRASS GIS. If you are new to GRASS GIS, you are warmly recommended to first check out the GRASS GIS Quickstart and the explanation about the GRASS GIS database.??

  2. Downloading the DTM for the whole municipality will take a while. If you want to speed up things, you can work with a smaller area by using your own vector data.??

• 16 March 2024
• 11:00

  Mappery: Contour Insoles for Hill Climbers

  sur Planet OSGeo
  

  Walter Schwartz said “Every Wednesday my hiking group covers about 15 km of distance and 500 meters of elevation, almost always “in the wild.” As one of us changed into hiking shoes I spotted this insole. It’s a kind of map that has seen plenty of wild!”

  I think we may have had a similar insole picture in the past but this is such a great pic even if it is a repeat.

  MapsintheWild Contour Insoles for Hill Climbers

• 15 March 2024
• 11:00

  Mappery: Cape Geography Wine

  sur Planet OSGeo
  

  Rollo was drinking this tasty South African Malbec from the Cape Geography Co and was inspired to send us a pic before he finished the bottle!

  MapsintheWild Cape Geography Wine

• 8:42

  GRASS GIS: Cite GRASS with DOI

  sur Planet OSGeo
  Cite GRASS GIS and your geospatial data in scientific works - now with Digital Object Identifiers (DOI)! The GRASS GIS project celebrated its 40th birthday last year. Over the decades, GRASS GIS has spread around the globe and has enabled generations of researchers to conduct geospatial research in many fields of science. As a new feature, reflecting the current change towards data-driven science and the paradigms of Open Science (including Open Source) and the FAIR principles (Findable, Accessible, Interoperable, Reusable), GRASS GIS software can now be referenced by Digital Object Identifiers (DOI).
• 14 March 2024
• 15:02

  GeoCat: GeoCat is the proud sponsor of the 128th OGC Member Meeting in Delft, the Netherlands

  sur Planet OSGeo

  GeoCat is happy to announce that we are the proud sponsor of the 128th OGC Member Meeting that takes place in Delft in the Netherlands from March 25th – March 28th, 2024.

  The meeting’s theme is “GEO-BIM for the Built Environment” and there will be a GeoBIM Summit, a special session on Land Admin, a Built Environment Joint Session, a meeting of the Europe Forum, and several SWG and DWG meetings.

  Join us and members of the OGC. We are looking forward to see you all in Delft.

  Read more about the meeting on the OGC website.

  The post GeoCat is the proud sponsor of the 128th OGC Member Meeting in Delft, the Netherlands appeared first on GeoCat bv.

• 13:00

  Fernando Quadro: Raster no PostGIS, vale a pena?

  sur Planet OSGeo

  Você sabe quais os benefícios e as armadilhas de colocar arquivos rasters em um banco de dados relacional?

  A maioria das pessoas pensa que “colocar em um banco de dados” é uma receita mágica para: desempenho mais rápido, escalabilidade infinita e gerenciamento fácil.

  Se você pensar que o banco de dados está substituindo uma pilha de arquivos CSV, isso provavelmente é verdade.

  Porém quando o banco de dados está substituindo uma coleção de arquivos de imagens GeoTIFF, isso provavelmente é falso. O raster no banco de dados será mais lento, ocupará mais espaço e será muito chato de gerenciar.

  Então, por que fazer isso? Comece com um padrão, “não!”, e então avalie a partir daí.

  Para alguns dados raster não visuais e casos de uso que envolvem o enriquecimento de vetores de fontes raster, ter o raster colocalizado com os vetores no banco de dados pode tornar o trabalho com ele mais conveniente. Porém, ainda será mais lento que o acesso direto e ainda será difícil de gerenciar, mas permite o uso de SQL como uma linguagem de consulta, o que pode oferecer muito mais flexibilidade para explorar o espaço da solução do que um script de acesso a dados criado especificamente para esse fim.

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

  Gostou desse post? Deixe seu comentário

• 11:00

  Mappery: One World

  sur Planet OSGeo
  

  Mark Iliffe spotted this neat t-shirt in a New York shop. You may need to enlarge the picture to appreciate it.

  I want (L please).

  MapsintheWild One World

• 7:02

  Piero, l’application Web 3D SIG/BIM open source !

  sur Oslandia
  Piero : une nouvelle application web 3D SIG/BIM OpenSource

  Oslandia annonce la sortie de Piero, une application opensource dédiée aux jumeaux numériques. Piero est une application web basée sur Giro3D et offrant des fonctionnalités de visualisation 3D de données géoréférencées, qu’elles viennent du monde BIM ou du monde SIG, de façon intégrée et ergonomique.

  

  Prête à l’emploi, Piero est disponible en démonstration à l’adresse suivante :

  [https:]]

  Des exemples de données sont pré-chargés, libres à vous de glisser-déposer vos données pour démarrer sans une seule ligne de code !

  Historique

  Giro3D est une bibliothèque logicielle permettant la visualisation et manipulation de données 2D, 2.5D et 3D cartographiques, directement dans le navigateur. Cette bibliothèque peut être intégrée dans n’importe quelle application web, ce qui la rend très versatile. On vous a notamment récemment parlé de LiDAR et de WebGL, deux technologies mises à profit dans Giro3D.

  Giro3D, en tant que bibliothèque, est dédiée aux développeurs et nécessite en contrepartie des efforts d’intégration. Afin de proposer d’adresser des cas d’utilisation plus larges, et également de montrer les fonctionnalités de Giro3D, Oslandia a développé une application complète mettant à profit les fonctionnalités de Giro3D, avec une interface utilisateur ergonomique, et proposant également des fonctionnalités avancées en terme de visualisation et d’analyse.

  Cette application, baptisée Piero, est aujourd’hui assez mature pour servir d’application Web clé en main. Tirant profit de Giro3D et du moteur 3D THREE.js pour fusionner les mondes SIG et BIM, Piero fournit une application complète reposant sur Vue.js. De la même façon que Giro3D, Piero est libre et open-source, et son code source est disponible sur la plateforme GitLab sous license MIT.

  Formats de données

  En plus des types nativement supportés par Giro3D, Piero couvre un large éventail de formats, allant du plus basique nuage de points CSV au très détaillé modèle IFC, en passant par CityJSON, GeoPackage, Shapefile, etc. Elle supporte également les webservices OGC.

  La liste complète est disponible sur la page du projet. Nous ajoutons le support de nouveaux formats en continu selon les besoins : si votre format préféré n’est pas encore supporté, n’hésitez pas à nous en faire part. Piero étant opensource et communautaire, il est également possible de contribuer pour ajouter des implémentations de formats de données.

  Fonctionnalités

  Piero va au-delà de la visualisation. De la simple identification, telle qu’on la retrouve dans QGIS, aux annotations et mesures, en passant par les plans de coupes ou la boîte de détourage, l’application fournit les outils pour exploiter facilement vos données 3D. La liste grandit au fil du temps, n’hésitez pas à faire un tour sur la page GitLab pour une information plus détaillée.

  

  Quelques fonctionnalités marquantes :

  • La mesure entre plans, avec une détection automatique des plans ( e.g. de mur à mur dans un bâtiment )
  • La « clipping box » permettant de découper l’intérieur d’une boîte, ou son extérieur pour mieux visualiser les éléments 3D. Très utiles pour les bâtiments.
  • L’interrogation des objets IFC avec tous leurs attributs
  • Les annotations et les geo-signets 3D

  Personnalisation

  Si la simple utilisation en glisser-déposer de données ne vous suffit pas, ou si vous avez des données situées en dehors de la France métropolitaine, vous pouvez héberger votre propre instance de Piero. Très simplement, en éditant la configuration via un simple fichier, vous pourrez modifier l’emprise et les sources de données. L’application étant statique (JavaScript et CSS), il suffira de regénérer l’application et déployer les fichiers sur un simple serveur web. En quelques lignes de commande, vous pouvez mettre à disposition votre propre Piero sans modifier une seule ligne de code source.

  Piero étant open-source et libre, vous pouvez également modifier le code source de l’application plus en profondeur si besoin ! Piero peut servir de base à des applications dédiées avec des fonctionnalités propres, ou des cas d’utilisation spécifiques.

  Plus d’information

  N’hésitez pas à nous contacter en créant un ticket sur le projet GitLab ! Par ailleurs, la gouvernance de Piero est communautaire et nous accueillons toutes les contributions ! Vous pouvez également contacter Oslandia si vous souhaitez de l’accompagnement en formation, développement, maintenance, intégration de données, ou si vous souhaitez établir un partenariat sur ces sujets : infos+3d@oslandia.com.

• 13 March 2024
• 13:00

  Fernando Quadro: Geoprocessamento na Gestão Rodoviária

  sur Planet OSGeo

  Quando falamos de Gestão Rodoviária, muito se discute em como aumentar a segurança e na diminuição de acidentes nas rodovias em geral.

  Você sabia que podemos aplicar Geoprocessamento na Gestão Rodoviária para apoio na previsão das condições das rodovias?

  O projeto Vision Zero, por exemplo, é uma iniciativa que tem o objetivo de reduzir a zero as mortes no trânsito, e o SIG e a análise espacial são ferramentas utilizadas para atingir esse objetivo.

  Mas onde o Geoprocessamento entra na prática, e onde ele pode realmente contribuir? Veja:

  Prevenção de riscos e acidentes;
  Melhorias de acesso;
  Mapeamento de estradas inundáveis;
  Geotecnologias de detecção remota;
  Dados GPS;
  Aprendizado de máquina para prever locais de acidentes.

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

  Você já tinha pensado nessas possibilidades do Geoprocessamento? Conte nos comentários

• 11:00

  Mappery: Geo-embellished Vending Machine

  sur Planet OSGeo
  

  Maarten Pullen sent us this pic of a vending machine that he spotted in Amsterdam.

  If you are puzzled by this one, Maarten explained “The shot was taken in Amsterdam, at the Amsterdam School of Real Estate. They probably want to show some of their local identity to all the business people visiting there.”

  MapsintheWild Geo-embellished Vending Machine

• 9:12

  Stefano Costa: Africa. Le collezioni dimenticate

  sur Planet OSGeo

  È finita a Torino la mostra “Africa. Le collezioni dimenticate” allestita nelle sale di Palazzo Chiablese. Sono riuscito a visitare la mostra pochi giorni fa. Mi è piaciuta molto.
  
  La mostra è stata organizzata dai Musei Reali di Torino, dalla Direzione Regionale Musei Piemonte e dal Museo di Antropologia ed Etnografia dell’Università di Torino, ed è una intensa passeggiata nel voyeurismo e collezionismo italiano durante il lungo periodo della scoperta, conquista e razzia dell’Africa, fino agli orrori della guerra in Etiopia. Il percorso si snoda sui passi di molti personaggi, tutti uomini italiani: esploratori, ingegneri al servizio dell’espansione belga nel Congo, affaristi, membri della casa reale. Tutti accomunati dall’attività coloniale nelle sue diverse fasi storiche, e tutti prontamente rimossi dalla memoria collettiva al termine della seconda guerra mondiale. Altrettanto dimenticate le collezioni di oggetti africani che questi personaggi hanno fatto confluire a vario titolo nei musei italiani e in questo caso piemontesi.
  
  Ad accompagnare la visita le installazioni di Bekele Mekonnen, in particolare il “site specific” dal titolo “The smoking table” ma anche le clip sonore lungo il percorso.
  
  La mostra ha agitato tantissimo i fascisti dichiarati e quelli non dichiarati perché non usa giri di parole, perché chiama il colonialismo e il razzismo con il loro nome, perché mette le voci africane sullo stesso piano di quelle italiane. Il ricco programma pubblico ha coinvolto molte persone, anche originarie dell’Africa.

  Parte dell’installazione “The smoking table” con scritte di colori diversi. In rosso sotto un braccio muscoloso: conspiracy, betrayal, greed, injustice, deception. In azzurro sotto due mani strette: honesty, fraternity, generosity, impartiality”

  Le polemiche, tutte politiche e ben poco culturali, suonano come un brusio fastidioso se consideriamo il lavoro lunghissimo di preparazione della mostra, la quantità di musei con collezioni africane in tutto il Piemonte, la ricchezza del catalogo che affronta in dettaglio molte delle questioni sollevate ad arte, ad esempio il salario pagato ai lavoratori della Società Agricola Italo-Somala, veri “forzati della terra” anche nelle parole degli italiani dell’epoca.

  Il paradosso sta nel fatto che questa mostra è molto blanda, se la inquadriamo nella cornice europea e occidentale bianca dei musei di antropologia e archeologia: dalla complessa operazione di continuo adattamento del Musée du Quai Branly di Parigi, al documentario Dahomey di Mati Diop che ha vinto l’Orso d’oro del Festival di Berlino pochi giorni fa, per finire al lavoro avviato nel 2016 da quello che oggi si chiama Museo delle Civiltà. È molto eloquente l’intervento del direttore Andrea Villani a un convegno di poche settimane fa, che potete rivedere su YouTube. Ho apprezzato questo passaggio:

  Quello che allora aveva un senso oggi può non solo non avere un senso, ma può anche essere tossico. [..] La storia non si cambia. I musei non cambiano la storia, ma possono raccontarla per intero, accettando di mettere in crisi quello che è venuto prima

  E poiché in Italia non siamo solo colonizzatori ma anche colonizzati e depredati, è bene sapere che alcuni musei degli USA sono seriamente alle prese con la provenienza delle proprie collezioni.

• 12 March 2024
• 17:03

  Un plugin QGIS pour QWC

  sur Oslandia
  Etat des lieux

  QGIS Web Client (QWC) est un client web responsive modulaire de nouvelle génération pour QGIS Server, construit avec ReactJS et OpenLayers et qui fonctionne avec un système de service. Il permet donc de visualiser dans une application cartographique web des projets QGIS.

  Actuellement pour publier un projet QGIS il faut passer par l’interface d’administration web pour uploader le projet, ou bien le sauvegarder au bon endroit dans l’arborescence de l’instance QWC.

  L’objectif du travail qui a été réalisé est donc d’améliorer l’intégration entre QGIS et son client web en permettant de publier un projet dans une instance QWC directement depuis l’interface de QGIS. Ce développement a été financé par la Direction des Systèmes d’Information et des Usages Numériques des Agences de l’eau

  Pour atteindre cet objectif il a fallu développer deux choses.

  Premièrement un nouveau service de publication pour assurer l’interaction entre le client QGIS et son client web QWC.

  Et ensuite, un plugin QGIS pour interagir avec ce service de manière simple et intuitive.

  Côté QWC : Le service de publication

  Ce service de publication est nommé qwc-publish-service et est disponible sur notre GitLab.

  Il s’agit d’une API REST permettant une gestion des projets avec des opérations de type CRUD (Create Read Update Delete). Le service est donc constitué de toutes les routes API nécessaires à la gestion de l’arborescence (créer/supprimer et déplacer des dossiers) et également à la gestion des projets (publier/mettre à jour/supprimer des projets). Ces routes sont détaillées dans le readme du projet.

  Une option du service qwc-publish-service permet de générer automatiquement la configuration de l’application lors de chaque action. En cas d’échec de la génération, le service restaure l’état précédent (application d’un Rollback sur l’action). Il n’est par exemple pas possible de supprimer un projet qui est utilisé dans un thème ou bien de publier un projet vide.

  Côté QGIS : Le plugin QWC2 Tools

  Pour accompagner le service et rendre ces routes API utilisables de manière plus transparente nous avons développé un plugin QGIS nommé QWC2 Tools.

   Pour fonctionner, ce plugin nécessite obligatoirement que l’instance QWC soit associée au service qwc-publish-service. Si le service peut fonctionner sans le plugin, l’inverse n’est pas possible.

  Ce plugin fournit donc une interface intuitive et intégrée à QGIS. On y retrouve un explorateur dédié à QWC, dans lequel on retrouve l’arborescence des projets de l’instance.

  Cet arbre est surplombé d’un bandeau contenant toutes Les actions possibles :

  • Publier un projet
  • Mettre à jour un projet
  • Supprimer un projet ou un dossier
  • Créer un dossier
  • Rafraîchir l’arbre
  • Ouvrir tous les dossiers
  • Fermer tous les dossiers
  • Accéder à la fenêtre des paramètres de l’instance

  Certaines de ces actions sont également possibles par clic droit et double clic, directement dans l’arborescence. Pour déplacer un projet ou un dossier le drag and drop peut être utilisé.

  Toutes les actions disponibles sont visibles dans la documentation.

  Enfin ce plugin gère également la gestion de l’authentification aux instances QWC via le gestionnaire d’authentification natif de QGIS. Deux types d’authentification sont gérés, l’authentification simple avec utilisateur et mot de passe et l’authentification OIDC (OpenID Connect).

  Démonstration

• 15:59

  Fernando Quadro: Última chance para se inscrever no Curso de GeoNode: garanta a sua vaga!

  sur Planet OSGeo

  NÃO FIQUE DE FORA!

  Curso de GeoNode: Última Semana de inscrições!

  Aprenda a montar a sua própria Infraestrutura de Dados Espaciais com o GeoNode, uma plataforma para gestão e publicação de dados geoespaciais que reúne projetos open-source maduros e estáveis sob uma interface consistente e fácil de usar, permitindo que os usuários, compartilhem seus dados de forma rápida e facil.

  Este novo curso visa capacitar os profissionais no uso eficiente da plataforma GeoNode, e tem como objetivos:

  Familiarizar os participantes com os conceitos fundamentais do Geonode e suas capacidades.
  Explorar o funcionamento de servidores de mapas e seus benefícios.
  Apresentar os padrões de dados do Open Geospatial Consortium (OGC), como Web Map Service (WMS) e Web Feature Service (WFS), para interoperabilidade geoespacial.
  Demonstrar a publicação eficiente de dados no Geonode usando views de bancos de dados geográficos.
  Ensinar a integração do Geonode com o QGIS através de plugins.

  Quer saber mais?

  O Curso é oferecido na modalidade EAD Ao Vivo, com uma carga horária de 18 horas divididos em 6 encontros. Porém, essas aulas são gravadas e ficam disponíveis ao aluno por 12 meses em nosso portal do aluno.

  Então, se por acaso você não puder comparecer em alguma das aulas ao vivo, não se preocupe, você poderá rever a aula gravada a qualquer momento.

  Ficou interessado?

  Acesse: [https:]]
  WhatsApp: [https:]]

• 11:32

  Markus Neteler: GRASS GIS 8.3.2 released

  sur Planet OSGeo

  The GRASS GIS 8.3.2 maintenance release contains more than 30 changes compared to 8.3.1. This new patch release includes important fixes and improvements to the GRASS GIS modules and the graphical user interface (GUI), making it even more stable for daily work.

  The post GRASS GIS 8.3.2 released appeared first on Markus Neteler Consulting.

• 11:00

  Mappery: Occular Cartographic Study

  sur Planet OSGeo
  

  Eric Lund said “Came across this eye-catching map at my eye doctor’s office this week and had to share it with you.” Well I am glad he did share it, what a cracking map in the wild! Here’s a bit more detail.

  

  This piece was designed by Tad Bradley, the accompanying description says
  
  ‘Snellen’ and “Tumbling E’ eye charts: Ocular Cartographic Study
  
  Although trained and currently practicing architecture at SMA Architecture + Design, Tad Bradley remains an artist and educator. He is continually fascinated with nature and the human body. The complexities within and between these are continually inspirational to investigate through art.
  The scale of the eye charts is inspired by the art movement of hyperrealism. In reproducing the eye charts at such a large scale, they begin to hold a greater weight within space, possibly reminding us the value of our eyesight and the incredible value this sense and these organs bring to our lives.
  The maps and text you see were originally printed in 1906. The series of oversized manuscripts, which focused on separate geographic regions, were titled ‘Geologic Atlas of the United States’, edited by S.J. Kubel. The maps here, in the waiting area, have been scanned and reprinted on metal panels in order to protect them from UV degradation from solar exposure.
  Eye charts have been the tool opticians have used for many years to assist in initially analyzing visual acuity. Exploring a tool within art invites a different awareness of not only the object but the process of how it is used. These eye charts were created for specific groups of people. The Tumbling E chart is used for those unable to read or never learned the Latin alphabet. The shapes and their direction are universal to all. The Snellen eye chart contains eleven rows of diminishing Latin letters to assess vision.
  Each 11? x 11? plywood panel has two layers of hand-cut paper [1906] to create visual contrast for viewers.
  “I chose the text pages from the Atlas to expose the Tumbling E chart. I was interested in exploring the contrast of the text-heavy pages and their visual relationship to the simplified ‘E’ shapes. The maps, on the other hand, are filled with high-contrast colors and patterns, more easily revealing the letters of the Snellen eye chart.
  One of my goals in creating this work was to analyze how we as humans experience the world, interact with one another, and stand alone as individuals. I hope that my work creates curiosity, questions and conversation”.

  MapsintheWild Occular Cartographic Study

• 11 March 2024
• 13:00

  Fernando Quadro: Por que usar o PostGIS?

  sur Planet OSGeo

  Talvez você já tenha escutado algumas vezes a frase: “PostGIS é uma extensão espacial do PostgreSQL”.

  Isso não significava que você tivesse ou tenha alguma ideia do que isso significa, e que você sabia o que é o PostgreSQL, quiçá o PostGIS.

  Mas não se preocupe, você não sairá desse post sem saber o que é cada um deles.

  PostGIS é um extensor de banco de dados espacial de código aberto e disponível gratuitamente para o PostgreSQL Database Management System (também conhecido como DBMS). Portanto, PostgreSQL (também conhecido como Postgres) é o banco de dados e PostGIS é como um complemento desse banco de dados.

  Resumidamente, o PostGIS adiciona funções espaciais, como distância, área, união, interseção e tipos de dados de geometria ao PostgreSQL. Os bancos de dados espaciais armazenam e manipulam objetos espaciais como qualquer outro objeto no banco de dados.

  E qual a vantagem de utilizá-lo?

  Na prática temos algumas vantagens em utilizá-los, mas a principal é a possibilidade de trabalhar com grandes conjuntos de dados. Não é apenas mais fácil, mas às vezes é quase impossível trabalhar em conjuntos de dados maiores sem um banco de dados.

  Você já tentou abrir um arquivo CSV de 2 GB?
  Ou tentou fazer algum geoprocessamento para um GeoJSON de 800 mb?
  Você sabia que os Shapefiles têm um limite de tamanho?

  É claro que você pode resolver alguns desses problemas usando o Geopackage ou alguns outros formatos de arquivo, mas em geral o PostGIS é a ferramenta ideal para lidar com grandes volumes de dados (geoespaciais).

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

  E você, já conhecia o PostGIS? Conta nos comentários

• 11:00

  Mappery: Indigenous Australia

  sur Planet OSGeo
  

  Tony Rabin spotted this map of the indigenous peoples of Australia near the Qantas bording gate at LAX

  MapsintheWild Indigenous Australia

• 10 March 2024
• 19:08

  Stefano Costa: In…segnami il silenzio

  sur Planet OSGeo

  Ieri sera siamo andati al Teatro Gustavo Modena, qui vicino a casa, per uno spettacolo della stagione dedicata all’infanzia. Eravamo con altre famiglie, ci siamo persino fatti un aperitivo casalingo prima di andare, visto che iniziava alle sette e mezza.

  Lo spettacolo si intitola “In…segnami il silenzio” e ha come protagonisti Marcello e Maria. Marcello ci racconta dell’arrivo di Maria nella sua classe, lei non parla e non sente, perché ha le “orecchie rotte”. Maria però sa ascoltare con gli occhi e sa parlare con la danza delle mani, con il viso, con tutto il corpo. Il rapporto tra Marcello e Maria è molto profondo, lui si lascia trasportare e insegnare. In cambio le fa vedere la musica che lei non può sentire, in particolare sulle note di una travolgente “Ça plane pour moi”.

  Lo spettacolo è rivolto ai bambini anche se non è facilissimo, ma tratta in modo fiabesco, senza filtri e un po’ scanzonato il tema della disabilità, che non è solo la sordità di Maria ma anche la “distrazione” di Marcello che la maestra gli rimprovera.

  Ci è piaciuto molto.

  Alla fine un appello della regista Elena Dragonetti per il cessate il fuoco a Gaza è stato accolto da un lungo applauso.

  Locandina dello spettacolo sul sito del Teatro nazionale di Genova

  Plastic Bertrand – Ça plane pour moi

• 12:48

  Mappery: Mappery Featured in The New York Times

  sur Planet OSGeo
  

  A few weeks ago I did an interview with Eve Kahn for a piece she was writing for The NewYork Times about what she calls “Cartifacts” which are a subset of Maps in the Wild. Mappery gets a very nice write up of course and I recommend the whole piece to my map loving friends.

  MapsintheWild Mappery Featured in The New York Times

• 11:00

  Mappery: Archer Field

  sur Planet OSGeo
  

  Marianne Pietersen sent us these pics from her visit to Archer Field.

  “Last year I went to a lecture at Archer Field, Brisbane, about the history of the Dutch military camp there,
  during WW2. In a side room of the airport building was a small amount of photos from those days, including the attached 3 maps of the Field. The exhibition is permanent (for now at least.)    ?”

  

  Today the spelling has been concatenated to Archerfield but the title pane of the map makes clear that in the past it was Archer Field.

  

  More info on the history of Archer Field airport

  MapsintheWild Archer Field

• 09 March 2024
• 11:00

  Mappery: Switzerland in 3D Magnificence

  sur Planet OSGeo
  

  This stunning relief map was sent to us by Scott Simmons who spotted it at the Swiss National Museum in Zurich.

  MapsintheWild Switzerland in 3D Magnificence

• 08 March 2024
• 13:00

  Fernando Quadro: Você conhece o MobilityDB?

  sur Planet OSGeo

  Dispositivos de rastreamento de localização, como GPS, são hoje amplamente utilizados em smartphones e veículos. Como resultado, os dados de trajetória geoespacial estão atualmente sendo coletados e usados ??em muitos domínios de aplicação. O MobilityDB fornece o suporte de banco de dados necessário para armazenar e consultar esses dados de trajetória geoespacial.

  MobilityDB é implementado como uma extensão do PostgreSQL e PostGIS. Ele implementa tipos de banco de dados persistentes e operações de consultas para gerenciar trajetórias geoespaciais e suas propriedades que variam no tempo.

  Uma trajetória geoespacial é geralmente coletada como uma sequência de pontos de localização e informações de data e hora. Na realidade, porém, o movimento é contínuo. Portanto, o MobilityDB interpola a trilha de movimento entre as informações de entrada. Como tal, a localização e as propriedades do objeto em movimento podem ser consultadas, efetivamente aproximadas, a qualquer momento.

  Embora esta interpolação restaure a continuidade do movimento, ela não corresponde a um aumento no tamanho do armazenamento. Pelo contrário, permite descobrir informações redundantes e removê-las. Assim, apenas as informações onde ocorre uma mudança significativa na velocidade/direção são retidas. Esse processo é chamado de normalização e geralmente resulta em uma redução significativa no tamanho do armazenamento em comparação com os pontos de entrada.

  Mas na prática, como funciona esse gerenciamento realizado pela extensão?

  Pense em obter a velocidade média de um trem em movimento, sem nenhum código SQL longo, usando uma função e pronto.
  Ou em armazenar dados GPS de forma muito compacta em uma única linha/coluna e ser capaz de fazer consultas complexas com muito pouco SQL.

  É essa praticidade que o MobilityDB vai te proporcionar.

  Você já tinha ouvido falar dessa extensão do PostgreSQL/PostGIS? Conte nos comentários

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

• 11:00

  Mappery: Mosaic map of Delft

  sur Planet OSGeo
  

  Impressive mosiac map of Delft, posted by Hans van der Kwast @hansakwast@fosstodon.org

  MapsintheWild Mosaic map of Delft

• 1:00

  GeoServer Team: How to Publish a GeoTIFF file in GeoServer

  sur Planet OSGeo

  GeoSpatial Techno is a startup focused on geospatial information that is providing e-learning courses to enhance the knowledge of geospatial information users, students, and other startups. The main approach of this startup is providing quality, valid specialized training in the field of geospatial information.

  ( YouTube | LinkedIn | Facebook | Reddit | X )

  Publishing a GeoTIFF file in GeoServer

  In this session, we want to talk about “How to Publish a GeoTIFF file in GeoServer” comprehensively. If you want to access the complete tutorial, simply click on the link.

  

  Introduction

  The GeoTIFF is a widely used geospatial raster data format, it is composed of a single file containing both the data and the georeferencing information. By default, GeoTIFF will be an option in the Raster Data Sources list when creating a new data store.

  Note. In this blog post, we used GeoServer version 2.20.0.

  Add a GeoTIFF data

  To add a GeoTIFF data in GeoServer, follow these steps:

  • Navigate to Data > Stores page, then click on the Add new Store link.
  • Select the desired workspace from the drop-down menu.
  • Enter the Data Source Name, make sure the Enabled option is checked. If checked, it enables the store. If unchecked (disabled), no data in the GeoTIFF will be served from GeoServer.
  • In the URL under the Connection Parameters, browse to the location of the GeoTIFF file then press the Save button.
  • Now you will be redirected to the New Layer page automatically and to add a layer for an available resource click on the Publish link.
  • Check the Name, Coordinate Reference Systems and the Bounding Boxes fields are properly set and press the Save button.

  Layer Groups

  In Geoserver, a layer group serves as a convenient container for organizing layers and other layer groups in a structured hierarchy. By assigning a single layer to a layer group in WMS requests, the process of making requests is simplified as instead of specifying multiple individual layers, only one layer needs to be indicated. Furthermore, a layer group establishes a set order for the layers within it and enables the specification of alternative styles for the layers, distinct from their default settings.

  Add a Layer Group

  • To create a Layer Groups, navigate to Data > Stores page. Click on Add a new layer group link. The initial fields allow you to configure the name, title, abstract and workspace of the layer group. Enter the Data Source Name and Title.

  • The Enabled checkbox, if disabled, will cause the layer group to just show up at configuration time, while the Advertised checkbox, if unchecked, will make it to not be available in GetCapabilities request and in the layer preview. The behaviour of layer group regarding both checkboxes will not affect the behaviour of any of the layers being grouped, which will follow respectively that specified in the corresponding edit page.

    Note. In the layer group section, Workspace selection is optional.

  • The Bound section contain the data BoundingBox of this layer group in the native coordinate reference system. The input can be done manually or automatically with the help of Generate Bounds.

    Note. By default, a layer group is queryable when at least a child layer is queryable. Uncheck Queryable box if you want to explicitly indicate that it is not queryable independently of how the child layers are configured.

  • To add more layers to the Layer Group list, you can press the Add Layer… button at the top of the table. From the popup window, select the layer to be added by clicking the layer name.

  • A layer group can be added by pressing the Add Layer Group… button at the top of the table. From the list of layer groups, select the appropriate layer group’s name.

  • A style group is a style that has one or more Named Layers which reference layers that exist in the catalog. Style groups can be added to Layer Groups as an alternative way of defining a collection of styled layers. To add it, press the Add Style Group… button at the top of the table and from the popup window, select the style group to be added by clicking its name.

  • Press the generate bounds button to have geoserver compute the group bounds from the layers inside of it.

    Note. A layer group can contain layers with dissimilar bounds and projections. GeoServer automatically reprojects all layers to the projection of the layer group.

  • When a layer group is processed, the layers are rendered in the order provided, so the publishable elements at the bottom of list will be rendered last and will show on top of the others. A publishable element can be positioned higher or lower on this list by pressing the green up or down arrows, respectively, or can be simply dragged in the target position.

  • Metadata links allows linking to external documents that describe the data of layer group. Keywords make possible to associate a layer group with some keywords that will be used to assist catalog searching.

  • Press Save button to create the new layer group.

  Preview a Layer Group

  So in order to preview the created layer, navigate to the Data > Layer Preview page and enter the name of your layer group in the search box, then press Enter button. Click on the OpenLayers link for a given layer and the view will display. An OpenLayers map loads in a new page and displays the group layer with the default styles. You can use the Preview Map to zoom and pan around the dataset, as well as display the attributes of features by click on each feature.

  Using WMS layers in QGIS

  To display a WMS layer in QGIS software, follow these steps:

  • Open GQIS and navigate to Layer > Add Layer > Add WMS/WMTS Layer.
  • To create a new service connection, from the Layers tab, press New button.
  • Name your connection from the Connection Details. Next, from the URL textbox, you need to access a WMS layer as HTTP address of Web Map Server. In this case, name the connection as My Project and the URL as http://localhost:8080/geoserver/project/wms and press OK. Note that the “project” refers to the workspace defined in Geoserver.
  • Press the Connect button to fetch the list of layers available, then press Add button and Close.
  • Now, you will see the layer loaded in the QGIS canvas. You can zoom/pan around just like any other layer. The way WMS service works is that every time you zoom/pan, it sends your viewport coordinates to the server and the server creates an image for that viewport and return it to the client. So there will be some delay before you see the image for the area after you have zoomed in. Also, since the data you see is an image, there is no way to query for attributes like in a regular vector/imagery layer.
• 1:00

  Camptocamp: OSGeo - OGC - ASF Code Sprint in Évora, Portugal

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  This unique gathering brought together key players in the field, including Camptocamp, a prominent contributor to the OsGeo community and a leading player in the steering committees of many of the association's projects.
• 07 March 2024
• 13:00

  Fernando Quadro: Comparando GeoNode e ArcGIS Online: Qual é o certo para você?

  sur Planet OSGeo

  GeoNode e ArcGIS Online são plataformas de software GIS (Geographic Information System) que permitem a criação e o compartilhamento de mapas e aplicativos web. No entanto, existem diferenças importantes entre as duas plataformas que podem influenciar na escolha da solução mais adequada para suas necessidades. Este artigo tem como objetivo fornecer uma comparação entre essas plataformas, com foco em recursos, funcionalidades e sua adequação para instituições governamentais, empresariais e acadêmicas.

  Funcionalidades

  O Geonode é uma plataforma open-source com foco na catalogação, visualização e compartilhamento de dados geoespaciais, que apresenta facilidade de uso, gerenciamento e integração com diversas ferramentas e serviços web OGC (Open Geospatial Consortium).

  O ArcGIS Online é uma plataforma robusta para criação de mapas e aplicativos WebGIS que possui uma ampla gama de funcionalidades para análise espacial, geoprocessamento e gerenciamento de dados, além da integração com outras plataformas ArcGIS e ferramentas da Esri.

  Curva de aprendizado

  O Geonode possui uma interface amigável e intuitiva, facilitando o aprendizado para iniciantes por meio de uma documentação completa e uma comunidade ativa que oferece suporte e ajuda aos usuários. Além disso, o Geonode possui uma curva de aprendizado mais suave para usuários com pouca ou nenhuma experiência em GIS.

  O ArcGIS Online é uma plataforma mais complexa, com uma curva de aprendizado mais acentuada, o que requer conhecimentos técnicos em GIS para configuração, administração e desenvolvimento de aplicações. Essa plataforma possui documentação extensa e abrangente, com diversos recursos de aprendizado.

  Documentação

  A documentação do Geonode é recomendada para usuários iniciantes em GIS que buscam uma documentação mais simples e direta e para usuários que desejam configurar e usar a plataforma rapidamente.

  O ArcGIS Online é recomendado para usuários experientes em GIS que buscam uma documentação completa e abrangente e para usuários que desejam explorar todos os recursos da plataforma.

  Taxas de licenciamento e custos de assinatura

  GeoNode: Sendo de código aberto, o GeoNode é totalmente gratuito para baixar, usar e modificar. Não há taxas de licenciamento ou custos de assinatura associados ao uso da plataforma.

  ArcGIS Online: O ArcGIS Online exige uma taxa de licenciamento, que pode ser substancial, especialmente para organizações maiores ou com necessidades complexas de GIS. Além disso, poderão ser incorridos custos contínuos de assinatura para acesso a atualizações e suporte.

  Personalização e Desenvolvimento

  O GeoNode: A natureza de código aberto do GeoNode permite ampla personalização e desenvolvimento. As organizações podem adaptar a plataforma às suas necessidades específicas sem incorrer em custos adicionais com ferramentas de desenvolvimento proprietárias.

  ArcGIS Online: A personalização no ArcGIS Online pode exigir o uso de ferramentas e APIs proprietárias, potencialmente levando a taxas de licenciamento ou custos de desenvolvimento
  adicionais.

  Escalabilidade e flexibilidade

  GeoNode: A escalabilidade do GeoNode não está vinculada a níveis de licenciamento ou níveis de assinatura. As organizações podem dimensionar a implantação do GeoNode conforme necessário, sem incorrer em custos adicionais de licenciamento.

  ArcGIS Online: O dimensionamento do ArcGIS Online pode exigir a compra de licenças adicionais ou níveis de assinatura, o que pode se tornar caro à medida que as necessidades de GIS de uma organização aumentam.

  Mas enfim, quando devo usar cada uma das ferramentas?

  Use o GeoNode se fizer parte de uma pequena, média ou grande organização com necessidades essenciais de mapeamento e compartilhamento de dados geoespaciais e que, além disso, busque uma solução open-source, fácil de usar e sem custos de licenças.

  Use o ArcGIS Online se fizer parte de uma grande organização com recursos que possua necessidades complexas de GIS e que busquem uma plataforma robusta e com ampla gama de funcionalidades para usuários que já estão familiarizados com outras plataformas ArcGIS e ferramentas da Esri.

  Ficou interessado?

  Acesse: [https:]]
  WhatsApp: [https:]]

• 7:00

  [1’Tech by Oslandia] WebGL

  sur Oslandia

  Dans cette minute Tech, nos collaborateurs vous proposent d’expliquer une technologie, une méthodologie, un concept. Après « open source » et « LiDAR« , on a brainstormé sur GitLab pour donner notre meilleure définition de WebGL.

  Déf : WebGL est une interface de programmation graphique permettant l’affichage de scènes 2D et 3D interactives dans le navigateur. C’est le pont qui permet aux pages web d’utiliser la carte graphique des ordinateurs, ce qui est synonyme de multiplication des usages 3D !

  Par exemple, OpenLayers, librairie JavaScript, utilise WebGL pour dessiner des cartes en 2D. Three.js est une libraire javascript implémentant un moteur 3D complet: [https:]] .

  WebGL x Oslandia

  Oslandia travaille régulièrement sur des projets alliant cartographie et 3D. Giro3D est une librairie WebGL SIG ( [https:]] ) qui a été développée par nos équipes et permettant de visualiser des geodata dans son navigateur.

• 06 March 2024
• 13:00

  Fernando Quadro: Os 5 benefícios da Infraestrutura de Dados Espaciais

  sur Planet OSGeo

  A Infraestrutura de Dados Espaciais (IDE) é uma ferramenta essencial no Geoprocessamento, oferecendo uma série de benefícios. Com a utilização da IDE, é possível organizar, armazenar e compartilhar dados espaciais de forma eficiente, facilitando o acesso e a análise dessas informações.

  Princípios como a padronização e a interoperabilidade são fundamentais para o bom funcionamento da IDE, garantindo a qualidade e a integridade dos dados. Além disso, fatores históricos, como o avanço da tecnologia e a democratização do acesso à informação, contribuíram para o desenvolvimento e a popularização da Infraestrutura de Dados Espaciais.

  Os benefícios:

  Melhor organização e gestão dos dados
  Maior eficiência na análise espacial
  Facilidade no compartilhamento de informações
  Melhor tomada de decisões
  Estímulo à inovação e desenvolvimento tecnológico

  As aplicações da IDE são diversas, abrangendo áreas como planejamento urbano, gestão ambiental, agricultura, transporte e muitas outras. Através da utilização de mapas e análises espaciais, é possível obter informações valiosas para a tomada de decisões, contribuindo para o desenvolvimento sustentável e a melhoria da qualidade de vida.

  E onde o GeoNode se encaixa nisso?

  O GeoNode é uma plataforma para gestão e publicação de dados geoespaciais que reúne projetos open source maduros e estáveis sob uma interface consistente e fácil de usar. Com ele você consegue implantar sua IDE de forma fácil e prática.

  Quer saber mais?

  O Curso é oferecido na modalidade EAD Ao Vivo, com uma carga horária de 18 horas divididas em 6 encontros. Porém, essas aulas são gravadas e ficam disponíveis ao aluno por 12 meses em nosso portal do aluno.

  Então, se por acaso você não puder comparecer em alguma das aulas ao vivo, não se preocupe, você poderá rever a aula gravada a qualquer momento.

  Em comemoração ao aniversário de 12 anos da Geocursos, estamos disponibilizando pra você R$ 100 de desconto, basta utilizar o cupom GEOCURSOS12ANOS

  Ficou interessado?

  Acesse: [https:]]
  WhatsApp: [https:]]

• 8:19

  OPENGIS.ch: INTERLIS Crashkurs Webinar

  sur Planet OSGeo

  Der Crashkurs dauert 2.5 Stunden via Google Meet (kein Google Konto erforderlich) und kostet 90 CHF pro Person.

  Beschreibung

  Ziel dieses Crashkurses ist es, “blutigen Anfänger:innen” INTERLIS näher zu bringen. Nach dem Crashkurs werden sie wissen, was INTERLIS ist, wie es angewendet wird und wie ein Modell gelesen wird und man sich darin zurechtfindet. Weiter werden sie fähig sein, ein einfaches Beispielmodell selbst zu modellieren.

  Vorkenntnisse

  Keine.

  Software

  Keine. Das Webinar ist primär frontal und es muss keine Software vorinstalliert werden.

  Um gleich ein bisschen mitzumachen, können aber optional folgende Tools installiert werden, im Idealfall auf einem separaten Bildschirm:

  • Aktuelle QGIS LTR Version für Windows, macOS oder Linux https://download.qgis.org.
  • VS Code Texteditor

  Kurskalender und Anmeldung
• 4:38

  Adam Steer: Image transects for ecological assessment

  sur Planet OSGeo
  Sometimes we don’t need to create full blown orthophotos and 3D models to understand things. Just seeing an image in a location context is enough. With this in mind, I was recenly tasked by Taungurung Land and Waters Council to collect a set of baseline images along preset transects for ecological assessment. The transects were… Read More »Image transects for ecological assessment
• 05 March 2024
• 17:29

  GeoSolutions: GeoSolutions at CalGIS in Visalia, California – March 18-20, 2024

  sur Planet OSGeo

  You must be logged into the site to view this content.

• 13:00

  Fernando Quadro: O que é um WebGIS

  sur Planet OSGeo

  WebGIS é uma tecnologia usada para exibir e analisar dados espaciais na Internet. Ele combina as vantagens da Internet e do GIS oferecendo um novo meio de acessar informações espaciais sem a necessidade de você possuir ou instalar um software GIS.

  A necessidade de divulgação de dados geoespaciais têm estimulado cada vez mais o uso de ferramentas WebGIS para apresentações interativas de mapas e de informações relacionadas por meio da internet.

  As soluções adotadas na apresentação destes mapas devem apresentar um equilíbrio entre facilidade de uso, riqueza de recursos para visualização e navegação entre os dados, e funcionalidades geoespaciais para pós-processamento, características que devem ser adequadas para cada perfil de usuário que acessará o WebGIS.

  Fonte: webgis.tech
  Instagram: [https:]]
  LinkedIn: [https:]]

• 9:47

  gvSIG Team: Coordinación CArtográfica en el Sistema de Administración del Territorio (CCASAT)

  sur Planet OSGeo
  

  Compartimos información sobre CCASAT un grupo de trabajo de expertos en administración del territorio del cual la Asociación gvSIG formamos parte.

  Coordinación CArtográfica en el Sistema de Administración del Territorio (CCASAT) es un grupo con sede en la Universitat Politécnica de València, España; en el Departamento de Ingeniería Cartográfica, Geodesia y Fotogrametría (DICGF) y en la Escuela Técnica Superior de Ingeniería Geodésica, Cartográfica y Topográfica (ETSIGCT), cuyos objetivos principales son:

  Apoyo, colaboración e investigación en todos aquellos ámbitos relacionados con la información cartográfica que permita una administración efectiva del territorio (como la información catastral, y/o la información registral, o similar), y fundamentalmente en aspectos que sirvan de apoyo para conseguir seguridad en la tenencia de la tierra, y valoración con efecto administrativo. Fomentando la difusión, transferencia de conocimientos, investigación, coordinación, consultoría y optimización de recursos.

  CCASAT está enfocado principalmente a España y Latinoamérica, siendo el idioma principal el español.

  http://www.ccasat.upv.es

• 7:00

  TerriSTORY®, un outil partenarial d’aide au pilotage de la transition des territoires

  sur Oslandia

  Co-construit avec les territoires et présent dans 6 régions (Auvergne-Rhône-Alpes, Bretagne, Corse, Nouvelle-Aquitaine, Occitanie et Pays de la Loire), TerriSTORY® est un outil d’aide à la décision et de visualisation de données énergie-climat territoriales. TerriSTORY® est une plateforme multi thématiques avec de nombreuses fonctionnalités, qui permet d’élaborer le diagnostic du territoire, de définir la stratégie, et de suivre la trajectoire de transition.

  Origine du projet

  Le projet TerriSTORY® est né en 2017, à l’initiative d’Auvergne-Rhône-Alpes Énergie Environnement dans le cadre de ses missions : collecter, produire, traiter et diffuser des données sur le climat, l’énergie, les déchets, les ressources, … afin de les mettre à disposition des territoires pour les accompagner sur les enjeux écologiques.

  Les acteurs du projet

  Le consortium TerriSTORY®, aujourd’hui en charge de la gestion et des choix d’évolution du projet, rassemble une vingtaine d’acteurs nationaux et régionaux ayant une mission de service public ou d’intérêt général.

  Le volet technique a été assuré entièrement par Oslandia en 2018 et 2019 puis partiellement de 2020 à de 2022, dans une logique de transfert de compétences. Les équipes d’Auvergne-Rhône-Alpes Energie Environnement assurent aujourd’hui elles-même l’ensemble des développements et opérations de maintenance.

  « Nous avons réalisé un POC au départ puis avons assuré les développements avec les équipes projets pendant quelques années. En parallèle et tout au long du projet, nous avons formé deux de leurs développeurs en interne. L’objectif était de leur permettre d’être complètement autonomes, et c’est le cas aujourd’hui ! » Vincent Picavet, co-fondateur et CEO d’Oslandia.

  Les technologies mobilisées

  Côté client, le choix s’est porté vers ReactJS, accompagné d’OpenLayers et ChartJS. L’API backend a été développée en Sanic (Python). Les données sont stockées et exploitées au sein d’une base de données PostgreSQL/PostGIS.

  Une application open source

  Le code TerriSTORY® est rendu disponible sous la licence publique générale GNU Affero (ou aGPL) version 3.

  Plus d’informations

  • Sur le projet : [https:]]
  • Sur le site : https://terristory.fr
  • Sur le dépôt Gitlab : [https:]]

• 04 March 2024
• 13:00

  GeoTools Team: GeoTools 31-RC Release Candidate

  sur Planet OSGeo
   The GeoTools team is pleased share a release candidate  GeoTools 31-RC: geotools-31-RC-bin.zip  geotools-31-RC-doc.zip  geotools-31-RC-userguide.zip  geotools-31-RC-project.zip  This release candidate is also available from the OSGeo Maven Repository and is made in conjunction with GeoServer 2.25-RC. The release was made by Jody Garnett (GeoCat).Testing
• 10:47

  Stefano Costa: ènostra e la transizione energetica dal basso a Savona

  sur Planet OSGeo

  Venerdì 1 marzo ero a Savona per parlare di transizione energetica dal basso alla Società di Mutuo Soccorso Fornaci, insieme al gruppo territoriale di ènostra. Ci avevano invitati il comitato No rigassificatore e il comitato Fermiamo il mostro per una serata insieme a due associazioni genovesi con cui collaboriamo spesso, Cittadini sostenibili e CER Sole.

  Savona e Vado Ligure non assistono passivamente alle scelte assurde dei politici regionali e locali di accogliere un rigassificatore che inquina il mare, deturpa il territorio con tutto il gasdotto necessario a terra, contribuisce a inquinare l’aria rimanendo ancorati alle fonti fossili e arricchendo le grandi multinazionali. C’è stato un risveglio che ha portato a una lunga catena umana lungo la costa, tante mobilitazioni e molti resistono all’idea di avere dei benefici “compensativi”.

  La serata è stata lunga e la partecipazione grande, nonostante la pioggia. Si è parlato dei danni che derivano dalle fonti fossili per il clima e per la salute, delle false notizie sulle rinnovabili, delle comunità energetiche. E io ho presentato le attività di ènostra. Ero piuttosto stanco ma con l’aiuto degli altri soci del gruppo territoriale ho spiegato cosa fa la cooperativa, che principi la guidano e l’importanza della partecipazione alle scelte energetiche al di là del cambio di fornitura. Non tutta l’energia rinnovabile è uguale e quella fatta dal basso, attenta agli impatti sociali e ambientali è quella che preferiamo.

  L’accoglienza del comitato è stata molto generosa e sono contento che sia nato questo legame.

  Cos’è una cooperativa energetica e cosa fa in concreto (video Youtube)

  
• 1:00

  GeoServer Team: GeoServer 2.25-RC Release

  sur Planet OSGeo

  GeoServer 2.25-RC release is now available with downloads (bin, war, windows), along with docs and extensions.

  This is a release candidate intended for public review and feedback. GeoServer 2.25-RC is made in conjunction with GeoTools 31-RC, and GeoWebCache 1.25-RC.

  Thanks to Jody Garnett (GeoCat) for making this release.

  Why share a release candidate?

  A sensible question to ask is why a “release candidate” is being produced at all - when we do not recommend running such a thing in production.

  GeoServer also follows a “release early, release often” approach which is where the project shares releases so you can test and provide feedback.

  This results in a lovely balance:

  • The GeoServer developer has already tested on the data and data sources they got handy.

  • The users of GeoServer have access to a much greater variety in data and and use cases to test with.

    Please try out this release candidate and let us know how it works for you.

  • Bonus: By testing with your data directory you are assured that the next GeoServer will work well for you and your team.

  This balance of a community sharing and each doing what they can they can do easily, is a nice thing about the open-source approach: the result is software we can trust and works well.

  Thank you for being part of the GeoServer community. Testing and feedback is welcome by email and bug reports.

  Upgrade Notes

  We have a number of configuration changes when updating an existing system:

  • The longstanding ENTITY_RESOLUTION_ALLOWLIST setting has been recommended as a way to control the locations available for external entity resolution when parsing XML documents and requests.

    The default has changed from * (allowing any location) to allowing the recommended www.w3.org, schemas.opengis.net, www.opengis.net locations used for OGC Web Services, along with the inspire.ec.europa.eu/schemas location used by our friends in Europe.

  • The FreeMarker Template HTML Auto-escaping is now enabled by default.

  • The spring security firewall is now enabled by default.

  • A new configuration setting is available to limit content served from the geoserver/www folder.

    If you have not met the www folder before it is used to share content, and there is a tutorial serving static files.

  • We do add recommendations to production considerations over time, if you have not checked that page in a while please review.

  Thanks to Steve Ikeoka and Jody Garnett for these improvements.

  Security Considerations

  This a reminder to update to GeoServer 2.24.2 Release (or GeoServer 2.35.5 Release).

  Alongside the upcoming GeoServer 2.25.0 release we will “publicly disclose” a list of Common Vulnerabilities and Exposures that have been addressed previously.

  • If you are working with a commercial support provider that volunteers with the geoserver-security email list they are already informed.
  • If you have updated to GeoServer 2.24.2 Release (or GeoServer 2.23.5 Release) you are already patched.

  I hope you enjoy our team’s effort to improve communication. The use of the CVE system allows us to reach a wider audience than reads these blog posts.

  See the project security policy for more information on how security vulnerabilities are managed.

  Experimental Java 21 support

  GeoServer, along with GeoTools and GeoWebCache, are now tested to build and pass tests with Java 21.

  This is not yet an endorsement to run GeoServer in production with Java 21. We are looking ahead at the 2024 roadmap, and are making sure the basics are covered for the newer Java releases.

  JTS fast polygon intersection enabled by default

  The JTS Next Generation polygon intersection algorithm has been enabled by default, which will improve performance of a number of operations, including WPS processes and the vector tiles generation. We deem the functionality well tested enough that it should be opened to the majority of users, even if it’s still possible to turn it off by adding the -Djts.overlay=old.

  

  MapML Extension

  The MapML extension is receiving a number of updates and improvements, with more to come in the following months. It’s now possible to declare “Tiled CRS” as the CRS for a layer, with the implication not just of the CRS, but also of the gridset that will be used by the MapML viewer:

  

  This portion builds on top of the work done months ago to support astronomical CRSs, which allows GeoServer to support multiple CRS authorities.

  The MapML preview links are now using the new MapML output format, while the old dedicated REST controller has been removed. This allows for better integration of the MapML format in the GeoServer ecosystem. The MapML viewer has also been updated to the latest version:

  

  Thanks to Joseph Miller and Andrea Aime (GeoSolutions) for this work, and Natural Resources Canada for sponsoring it.

  Community Module Updates

  Much of the new activity in GeoServer starts as a community module. We’d like to remind you that these modules are not yet supported, and invite you to join the effort by participating in their development, as well as testing them and providing feedback.

  Raster attribute Table community module

  Developed as part of GEOS-11175, the Raster Attribute Table community module uses the GDAL Raster Attribute Table (RAT) to provide a way to associate attribute information for individual pixel values within the raster, to create styles as well as to provide a richer GetFeatureInfo output.

  

  

  For more information see the user guide.

  We’d like to thank Andrea Aime (GeoSolutions) for the development and NOAA for sponsoring.

  Graticules for WMS maps

  The graticules community module, developed as part of GEOS-11216, provides a datastore generating graticules for WMS maps, along with a rendering transformation that can be used to label them. The module can be used to draw a graticule in WMS maps, as well as to download them as part of WFS (or in combination with the WPS download module).

  

  

  We’d like to thank Ian Turton for development and GeoSolutions for sponsoring the work.

  GeoServer monitor Kafka storage

  The monitoring Kafka storage module, developed as part of GEOS-11150, allows storing the requests captured by the monitoring extension into a Kafka topic.

  

  We’d like to thank Simon Hofer for sharing his work with the community. To learn more about the module, how to install and use it, see the user-guide.

  JWT Headers

  The JWT headers module has been developed as part of GEOS-11317.

  

  The module is a new authentication filter that can read JWT Headers, as well as general JSON payloads and simple strings, to identify a user, as well as to extract their roles. The combination of Apache mod_auth_openidc with geoserver-jwt-headers-plugin provides an alternative to using the geoserver-sec-oauth2-openid-connect-plugin plugin.

  We’d like to thank David Blasby (GeoCat) for this work on this module.

  Full Release notes

  New Feature:

  • GEOS-11225 [AuthKey] AuthKey synchronize the user/group automatically

  MapML:

  • GEOS-10438 ENTITY_RESOLUTION_ALLOWLIST property not parsing empty setting
  • GEOS-11207 Refactor MapML MVC controller as GetMap-based operation with standard parameter format
  • GEOS-11221 mkdocs preflight rst fixes
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11297 Escape WMS GetFeatureInfo HTML output by default
  • GEOS-11300 Centralize access to static web files

  Improvement:

  • GEOS-11130 Sort parent role dropdown in Add a new role
  • GEOS-11142 Add mime type mapping for yaml files
  • GEOS-11148 Update response headers for the Resources REST API
  • GEOS-11149 Update response headers for the Style Publisher
  • GEOS-11152 Improve handling special characters in the Simple SVG Renderer
  • GEOS-11153 Improve handling special characters in the WMS OpenLayers Format
  • GEOS-11155 Add the X-Content-Type-Options header
  • GEOS-11173 Default to using [HttpOnly] session cookies
  • GEOS-11176 Add validation to file wrapper resource paths
  • GEOS-11213 Improve REST external upload method unzipping
  • GEOS-11222 Include Conformance Class for “Search” from OGC API - Features Part 5 proposal
  • GEOS-11226 Enable JTS OverlayNG by default
  • GEOS-11246 Schemaless plugin performance for WFS
  • GEOS-11247 Avoid HTML annotations special status in APIBodyProcessor
  • GEOS-11248 Move version header handling from APIBodyMethodProcessor to APIDispatcher
  • GEOS-11260 JNDI tutorial uses outdated syntax
  • GEOS-11288 Improve input validation in ClasspathPublisher
  • GEOS-11289 Enable Spring Security Stric [HttpFirewall] by default
  • GEOS-11298 When a Raster Attribute Table is available, expose its attributes in GetFeatureInfo

  Bug:

  • GEOS-11050 jdbc-store broken by changes to Paths.names
  • GEOS-11051 Env parametrization does not save correctly in AuthKey extension
  • GEOS-11145 The GUI “wait spinner” is not visible any longer
  • GEOS-11182 Avoid legends with duplicated entries
  • GEOS-11187 Configuring a raster with NaN as NODATA results in two NaN in the nodata band description
  • GEOS-11190 GeoFence: align log4j2 deps
  • GEOS-11203 WMS GetFeatureInfo bad WKT exception for label-geometry
  • GEOS-11224 Platform independent binary doesn’t start properly with default data directory
  • GEOS-11250 WFS GeoJSON encoder fails with an exception if an infinity number is used in the geometry
  • GEOS-11278 metadata: only selected tab is submitted
  • GEOS-11312 Used memory calculation fix on legend WMS request

  Task:

  • GEOS-11242 Remove the Xalan library
  • GEOS-11315 Revert to CORS commented out
  • GEOS-11318 Update postgresql to 42.7.2
  • GEOS-11134 Feedback on download bundles: README, RUNNING, GPL html files
  • GEOS-11141 production consideration for logging configuration hardening
  • GEOS-11159 Update mapfish-print-lib 2.3.0
  • GEOS-11180 Update ImageIO-EXT to 1.4.9
  • GEOS-11181 Update jai-ext to 1.1.25
  • GEOS-11186 Fix maven enforcer failFast
  • GEOS-11220 Upgrade Hazelcast from 5.3.1 to 5.3.6
  • GEOS-11245 Update OSHI from 6.2.2 to 6.4.10
  • GEOS-11316 Update Spring version to 5.3.32

  Community module development:

  • GEOS-11305 Add layer information in the models backing STAC
  • GEOS-11146 Fix MBTiles output format test
  • GEOS-11184 ncwms module has a compile dependency on gs-web-core test jar
  • GEOS-11209 Open ID Connect Proof Key of Code Exchange (PKCE)
  • GEOS-11212 OIDC accessToken verification using only JWKs URI
  • GEOS-11219 Upgraded mail and activation libraries for SMTP compatibility
  • GEOS-11293 Improve performance of wps-lontigudinal-profile

  About GeoServer 2.25 Series

  Additional information on GeoServer 2.25 series:

  • GeoServer 2.25 User Manual
  • GeoServer 2024 Roadmap Plannings
  • MkDocs Proposal

  Release notes: ( 2.25-RC )

• 02 March 2024
• 17:35

  Stefano Costa: Install iosacal with conda

  sur Planet OSGeo

  Starting today, you can install iosacal with conda. This adds to the existing installation procedure with pip. Conda is a good fit for complex projects and has better tooling for reproducibility.

  Installing iosacal can be achieved by adding conda-forge to your channels with:

  conda config --add channels conda-forge conda config --set channel_priority strict

  Once the conda-forge channel has been enabled, iosacal can be installed with conda:

  conda install iosacal

  or with mamba:

  mamba install iosacal

• 01 March 2024
• 20:39

  Fernando Quadro: Curso de GeoNode com inscrições abertas!

  sur Planet OSGeo

  Aprenda a montar a sua própria Infraestrutura de Dados Espaciais com o GeoNode, uma plataforma para gestão e publicação de dados geoespaciais que reúne projetos open-source maduros e estáveis sob uma interface consistente e fácil de usar, permitindo que os usuários, compartilhem seus dados de forma rápida e facil.

  Este novo curso visa capacitar os profissionais no uso eficiente da plataforma GeoNode, e tem como objetivos:

  Familiarizar os participantes com os conceitos fundamentais do Geonode e suas capacidades.
  Explorar o funcionamento de servidores de mapas e seus benefícios.
  Apresentar os padrões de dados do Open Geospatial Consortium (OGC), como Web Map Service (WMS) e Web Feature Service (WFS), para interoperabilidade geoespacial.
  Demonstrar a publicação eficiente de dados no Geonode usando views de bancos de dados geográficos.
  Ensinar a integração do Geonode com o QGIS através de plugins.

  Quer saber mais?

  O Curso é oferecido na modalidade EAD Ao Vivo, com uma carga horária de 18 horas divididos em 6 encontros. Porém, essas aulas são gravadas e ficam disponíveis ao aluno por 12 meses em nosso portal do aluno.

  Então, se por acaso você não puder comparecer em alguma das aulas ao vivo, não se preocupe, você poderá rever a aula gravada a qualquer momento.

  Em comemoração ao aniversário de 12 anos da Geocursos, estamos disponibilizando pra você R$ 100 de desconto, basta utilizar o cupom GEOCURSOS12ANOS

  Ficou interessado?

  Acesse: [https:]]
  WhatsApp: [https:]]

• 17:27

  Stefano Costa: IOSACal in Google Colab

  sur Planet OSGeo

  Google Colab is a popular notebook service that you can run directly from your browser. Python is natively supported and it’s fairly easy to run a Jupyter notebook, even with custom dependencies like Numpy and Matplotlib.
  
  You can run IOSACal in Google Colab! I have added a new short how-to guide in the official documentation. Find the how-to at [https:]] .
  
  This takes advantage of a demo notebook that was contributed by Jelmer Wind.

  A screenshot of the demo notebook running IOSACal in Google Colab. Even with a plot!

• 28 February 2024
• 18:00

  OTB Team: OTB Release 9.0.0

  sur Planet OSGeo
  Dear OTB community, We are happy to announce that OTB version 9.0.0 has been released! Ready to use binary packages are available on the package page of the website: The Docker image is available :docker pull orfeotoolbox/otb:9.0.0 It is also possible to checkout the branch with git: git clone [https:] OTB -b release-9.0 The documentation […]

• 26 February 2024
• 7:00

  Je soutiens le logiciel libre, je suis membre de l’APRIL !

  sur Oslandia

  Créée en 1996, l’April est la principale association de promotion et de défense du logiciel libre dans l’espace francophone. Depuis plusieurs années maintenant et du fait de son engagement dans la communauté open source, Oslandia soutient l’April en faisant partie des entreprises adhérentes.

  Par cette adhésion, nous apportons tout notre soutien aux actions de l’association et invitons les acteurs du Libre, entreprises, associations, collectivités, … à rejoindre le mouvement et soutenir la promotion du Libre en France !

  [https:]]

• 24 February 2024
• 20:26

  Free and Open Source GIS Ramblings: Trajectools 2.0 released ?

  sur Planet OSGeo

  It’s my pleasure to share with you that Trajectools 2.0 just landed in the official QGIS Plugin Repository.

  This is the first version without the “experimental” flag. If you look at the plugin release history, you will see that the previous release was from 2020. That’s quite a while ago and a lot has happened since, including the development of MovingPandas.

  Let’s have a look what’s new!

  The old “Trajectories from point layer”, “Add heading to points”, and “Add speed (m/s) to points” algorithms have been superseded by the new “Create trajectories” algorithm which automatically computes speeds and headings when creating the trajectory outputs.

  “Day trajectories from point layer” is covered by the new “Split trajectories at time intervals” which supports splitting by hour, day, month, and year.

  “Clip trajectories by extent” still exists but, additionally, we can now also “Clip trajectories by polygon layer”

  There are two new event extraction algorithms to “Extract OD points” and “Extract OD points”, as well as the related “Split trajectories at stops”. Additionally, we can also “Split trajectories at observation gaps”.

  Trajectory outputs, by default, come as a pair of a point layer and a line layer. Depending on your use case, you can use both or pick just one of them. By default, the line layer is styled with a gradient line that makes it easy to see the movement direction:

  

  while the default point layer style shows the movement speed:

  How to use Trajectools

  Trajectools 2.0 is powered by MovingPandas. You will need to install MovingPandas in your QGIS Python environment. I recommend installing both QGIS and MovingPandas from conda-forge:

  (base) conda create -n qgis -c conda-forge python=3.9 
  (base) conda activate qgis
  (qgis) mamba install -c conda-forge qgis movingpandas
  

  The plugin download includes small trajectory sample datasets so you can get started immediately.

  Outlook

  There is still some work to do to reach feature parity with MovingPandas. Stay tuned for more trajectory algorithms, including but not limited to down-sampling, smoothing, and outlier cleaning.

  I’m also reviewing other existing QGIS plugins to see how they can complement each other. If you know a plugin I should look into, please leave a note in the comments.

• 23 February 2024
• 14:17

  geomatico: Desarrollo de un gemelo digital para la gestión del agua

  sur Planet OSGeo

  La escasez de agua en la agricultura, agravada por el cambio climático, amenaza la seguridad alimentaria. Los sistemas de riego eficientes son clave para mitigar estos desafíos, optimizando el uso del agua y fortaleciendo la resiliencia agrícola.

  Entre 2022 y 2023 hemos desarrollado un gemelo digital de gestión del agua en agricultura junto al IRTA (Instituto de Investigación y Tecnología Agroalimentaria). En la aplicación web se pueden monitorizar y analizar casi 300 mil parcelas simbolizadas semanalmente por 17 indicadores (unos 250 millones de registros por año) que permiten optimizar la irrigación.

• 22 February 2024
• 21:00

  QGIS España: Publicación del libro Introducción a los Sistemas de Información Geográfica con QGIS

  sur Planet OSGeo
  Publicada la Segunda Edición del Libro “Introducción a los Sistemas de Información Geográfica con QGIS” de Federico Gazaba

  Una pregunta recurrente en redes sociales es ¿Dónde puedo encontrar un manual para aprender a usar QGIS? o ¿Cómo puedo iniciarme en el uso de los Sistemas de Información Geográfica (SIG)? Hace aproximadamente 3 años Federico Gazaba publicaba la pimera versión de su libro “Introducción a los Sistemas de Información Geográfica con QGIS” un manual que en su momento fue de referencia obligada para las personas usuarias de QGIS en habla hispana pero que con el paso del tiempo había quedado desactualizado debido a la aparición de nuevas versiones de QGIS.

  Recientemente el autor nos comentaba que se estaba preparando una actualización de libro y no nos ha hecho esperar mucho, el 22 de Febrero nos anunciaba en el canal de Telegram de QGIS en español que la versión 2.0 había sido publicada: _“Hola amigos #geoinquietos !. Lo prometido es deuda, les traigo la versión 2.0 de mi libro libre “Introducción a los Sistemas de Información Geográfica con QGIS”. Esta versión actualiza los contenidos de la versión anterior a QGIS 3.34 Prizren.".

  El libro ha sido publicado bajo la licencia CC BY-SA 4.0 lo que permite que sea compartido o modificado, para cualquier proposito, con libertad mientras se respete la atribución al autor y se comparta con la misma licencia. Se puede descargar aquí o aquí el repositorio del libro se puede encontrar en GitHub

  Este libro es otro ejemplo que demuestra que los proyectos de software libre y open source permiten compartir y colaborar en este tipo de iniciativas donde podemos participar de forma activa y generar grandes sinergias en sus aplicaciones y desarrollos en beneficio, tanto de las comunidades que las desarrollan como las que las usan.

  Federico Gazaba es profesor de Matemáticas y Técnico Maestro Mayor de Obras y actualmente es docente en el Instituto de Formación Docente y Técnica 122 “Presidente Illia” de Pergamino (Provincia de Buenos Aires, Argentina) y Director de Sistemas de Información Georreferenciada de la Municipalidad de Pergamino. Desde el año de 2013 es usuario de QGIS y es un entusiasta del las tecnologías libres y de los datos espaciales abiertos. La creación del manual nace de la necesidad de impartir cursos de QGIS a sus colegas de municipalidad y es el resultado de la sistematización de esas enseñanzas. Desde 2016, de forma ininterrumpida, imparte cursos introductorios a los SIG para diferentes instituciones.

  Puedes seguir a Federico en la siguientes redes sociales:

  • X: [https:]]
  • Mastodon: [https:]]
  • Telegram: @federicogazaba
  • Github [https:]]

• 7:00

  [Equipe Oslandia] Augustin, développeur sénior

  sur Oslandia

  Chaque mois, nous avons le plaisir de vous présenter un membre de l’équipe, aujourd’hui c’est Augustin qui a répondu à nos questions

  Diplômé d’un double cursus ingénieur Supelec à Gif-sur-Yvette et d’un Master of Science « Advanced Computing » à Londres, Augustin commence en régie en tant que développeur Java avant de partir dans une agence web parisienne dans laquelle il découvre le front, à une époque où « JavaScript montait très fort ». C’est aussi l’occasion d’acquérir des compétences DevOps via des missions de gestion de la production, mise en production.

  En 2015, il quitte son emploi en même temps que la sortie de Firefox OS pour travailler avec une start-up spécialisée dans la personnalisation de l’OS et du roam cooking pour les opérateurs … dont l’aventure se termine prématurément avec l’abandon par Mozilla de Firefox OS … En 2016, il rejoint Oslandia, sans connaitre les SIG mais « convaincu par les choix open source » de l’entreprise.

  Augustin travaille beaucoup sur les projets Javascript pour la 3D avec WebGL et maintient deux librairies pour lequelles Oslandia est très impliqué : Py3dtiles (librairie Python) et Giro3D (librairie webGL).
  Adepte également du PostgreSQL et PostGIS, il est un soutien pour ses collègues sur les problématiques DevOps ou l’optimisation de requêtes PostGIS, un volet DevOps qu’il a également mis à contribution avec Ansible, pour l’infra Oslandia.

  Ses projets emblématiques

  • Projet avec le Shom (Service hydrographique et océanographique de la Marine) : conception de la base de données et des routines d’exploitation d’un référentiel des profondeurs sous marines (mesures batimétriques).
  • Développement d’un visualisateur 3D web pour un leader du transport en France avec des données de bâtiment, d’imagerie, des nuages de point, …

  Ses technologies de prédilection

  Ansible / Javascript / Typescript / webGL / PostGIS / univers Rust / Python

  Sa philosophie

  « Se questionner sans cesse pour produire du code pérenne, du code propre pour rendre service aux autres… et à moi-même. J’aime aussi beaucoup aider mes collègues et venir en soutien. »

  Oslandia en 1 mot

  Liberté dans le sens d‘autonomie et d’esprit d’initiative et d’action mais aussi liberté en lien avec le logiciel libre : la liberté de construire sur ce qu’on produit !

• 21 February 2024
• 12:30

  GeoTools Team: GeoTools 29.5 released

  sur Planet OSGeo
    GeoTools 29.5 releasedThe GeoTools team is pleased to announce the release of the latest maintenance version of GeoTools 29.5:geotools-29.5-bin.zipgeotools-29.5-doc.zipgeotools-29.5-userguide.zipgeotools-29.5-project.zipThis release is also available from the OSGeo Maven Repository and is made in conjunction with GeoServer 2.23.5 and GeoWebCache 1.23.4. We are
• 20 February 2024
• 20:17

  QGIS Blog: Save the date & call for contributions: QGIS user conference and contributor meeting in Bratislava

  sur Planet OSGeo

  We are happy to announce that QGIS User Conference will take place on 9-10 September 2024 in Bratislava, Slovakia.

  

  
  The traditional Contributor Meeting will be held right after the conference on 11-13 September 2024 at the same venue.
  
  Learn more about the user conference and the contributor meeting at the event’s web site: [https:]]
  
  The call for papers for the user conference is now open – you can submit proposals for talks and workshops by 31 March 2024:
  [https:]]
  
  We have also started call for sponsors, with sponsorship opportunities at various levels. More details here:
  [https:]]
  
  User Conference
  
  The QGIS User Conference is an annual event that brings together users and developers of QGIS. The conference provides an opportunity for attendees to learn about the latest developments in QGIS, share their experiences with others, and network with other QGIS users and
  developers.
  
  Contributor Meeting
  
  QGIS Contributor Meetings are volunteer-driven events where contributors to the QGIS project from around the world get together in a common space – usually a university campus. During these events, contributors to the QGIS project take the opportunity to plan their work, hold face-to-face discussions and present new improvements to the QGIS project that they have been working on. Everybody attending the event donates their time to the project for the days of the event.
  As a project that is built primarily through online collaboration, these meetings provide a crucial ingredient to the future development of the QGIS project. The event is planned largely as an ‘unconference’ with minimal structured programme planning.

  For more details and to sign up, please visit the corresponding wiki page [https:]]

• 19 February 2024
• 1:00

  Camptocamp: Coopterr, territorial cooperation platform based on Rennes Métropole's digital twin

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  Coopterr, Rennes Métropole's territorial cooperation platform, is now online. It offers a first service to citizens, enabling them to consult electromagnetic wave exposure measurements and identify radioelectric sites in the city of Rennes.
• 18 February 2024
• 1:00

  GeoServer Team: GeoServer 2.23.5 Release

  sur Planet OSGeo

  GeoServer 2.23.5 release is now available with downloads (bin, war, windows), along with docs and extensions.

  This is the last planned maintenance release of GeoServer 2.23.x, providing existing installations with minor updates and bug fixes. Sites using the 2.23.x series are encouraged to upgrade to GeoServer 2.24.x, or eventually wait next month, for the 2.25.0 release, and upgrade their installation, with the help of the upgrade guide.

  GeoServer 2.23.5 is made in conjunction with GeoTools 29.5, and GeoWebCache 1.23.4.

  Thanks to Andrea Aime (GeoSolutions) for making this release.

  Release notes

  New Feature:

  • GEOS-11225 AuthKey synchronize the user/group automatically
  • GEOS-11279 metadata: allow same field on multiple tabs

  Improvement:

  • GEOS-11213 Improve REST external upload method unzipping
  • GEOS-11246 Schemaless plugin performance for WFS
  • GEOS-11260 JNDI tutorial uses outdated syntax
  • GEOS-11276 Use style_body to define CSS style for a layer
  • GEOS-11288 Improve input validation in ClasspathPublisher

  Bug:

  • GEOS-11174 GWC rest api returns erroneous truncated response when gzip http encoding is enabled
  • GEOS-11205 Layer page: style image fails if it is in isolated workspace
  • GEOS-11250 WFS GeoJSON encoder fails with an exception if an infinity number is used in the geometry
  • GEOS-11255 Multiple inserts in WPS with different idGen strategies does not work
  • GEOS-11256 Cannot retrieve LegendGraphic from a PostGIS datastore with ‘hideEmptyRules’ and ‘Support on the fly geometry simplification’ enabled
  • GEOS-11278 metadata: only selected tab is submitted
  • GEOS-11285 GWC REST Content-Encoding gzip returns broken response
  • GEOS-11291 GeoFence: Cleanup stale log4j references

  For the complete list see 2.23.5 release notes.

  Community Updates

  Community module development:

  • GEOS-10933 keycloak logout NPE
  • GEOS-11290 With Oauth enabled, anon users get random auth requests

  Community modules are shared as source code to encourage collaboration. If a topic being explored is of interest to you, please contact the module developer to offer assistance.

  About GeoServer 2.23 Series

  Additional information on GeoServer 2.23 series:

  • GeoServer 2.23 User Manual
  • Drop Java 8
  • GUI CSS Cleanup
  • Add the possibility to use fixed values in Capabilities for Dimension metadata
  • State of GeoServer 2.23
  • GeoServer Feature Frenzy 2023
  • GeoServer used in fun and interesting ways
  • GeoServer Orientation

  Release notes: ( 2.23.5 | 2.23.4 | 2.23.3 | 2.23.2 | 2.23.1 | 2.23.0 | 2.23-RC1 )

• 15 February 2024
• 20:09

  QGIS Blog: QGIS Grants #9: Call for Grant Proposals 2024

  sur Planet OSGeo

  Dear QGIS Community,

  We are very pleased to announce that this year’s round of grants is now available. The call is open to anybody who wants to make a contribution to QGIS funded by our grant fund, subject to the call conditions outlined in the application form.

  The deadline for this round is in four weeks, on 14 March 2024.

  There are no new procedures in 2024. Please note the following guidelines established in previous years: 

  • The proposal must be submitted as a ‘QEP’ (QGIS Enhancement Proposal) issue in the repo: [https:]] (tagged as Grant-2024). Following this approach will allow people to ask questions and provide public feedback on individual proposals.
  • Proposals must clearly define the expected final result so that we can properly assess if the goal of the proposal has been reached.
  • The project budgets should account for PR reviewing expenses to ensure timely handling of the project-related PRs and avoid delays caused by relying on reviewer volunteer time. 
  • In the week after the QEP discussion period, the proposal authors are expected to write a short summary of the discussion that is suitable for use as a basis on which voting members make their decisions. 

  The PSC of QGIS.ORG will examine the proposals and has veto power in case a proposal does not follow guidelines or is not in line with project priorities.

  For more details, please read the introduction provided in the application form.

  We look forward to seeing all your great ideas for improving QGIS!

• 1:00

  EOX' blog: Open Science Catalog

  sur Planet OSGeo
  Just like the European Space Agency (ESA), we advocate for and actively support Open Science, as we believe in the significance of collaborative efforts in advancing scientific knowledge and addressing global challenges. We acknowledge the transformative power of Open Science in driving interdiscipl ...

• 13 February 2024
• 11:31

  Oslandia recrute : H/F Assistant(e) administratif et comptable

  sur Oslandia
  OSL2402A – H/F Assistant(e) administratif et comptable Oslandia

  Oslandia est une société de service en informatique spécialisée dans les logiciels de système d’information géographique opensource. SAS générant un chiffre d’affaires d’environ 2M€, Oslandia organise son activité autour de 4 types de prestations : conseil, développement, support et formation. Forte de 15 années d’existence, la société compte aujourd’hui 26 collaborateurs, dont 23 de profil ingénieurs-développeurs, répartis en télétravail sur toute la France. L’organisation interne et le modèle managérial de l’entreprise reposent à la fois sur une forte autonomie des collaborateurs et un modèle collaboratif à distance approfondi induisant une implication individuelle forte dans le projet d’entreprise. Valeurs de l’open source, excellence technique, transparence, entraide et cohésion d’équipe font partie des ingrédients forts de la culture d’entreprise.

  Oslandia dispose de plusieurs fonctions supports dont un directeur, une directrice administrative, financière et RH. Ces fonctions support sont complétées par plusieurs rôles contribuant au pilotage et à l’organisation de l’activité : responsable de production ou membres du comité RH.

  Nous recherchons

  Oslandia recherche un(e) assistant(e) administratif et comptable à temps plein basé(e) sur la région IDF, en télétravail.

  Missions confiées

  Vous serez amené.e à travailler en étroite collaboration avec la directrice administrative et financière basée sur la région Parisienne, sur les missions décrites ci-dessous. Le poste est en 100 % télétravail avec possibilité de coworking ponctuellement.

  Comptabilité

  • Banque (état de rapprochement, cession créance BPI, réglements, …) ;
  • Facturation client (établir les factures, déposer les factures sur les plateformes appropriées, relance, encaissements) ;
  • Factures/NDF (saisie des factures, vérification des ndf, préparation des OD paie et tva) ;
  • Vérifications comptables (lettrage, aide à l’élaboration de la situation semestrielles et clôture comptable annuelle) ;
  • Déclarations (DES, CMIE, préparation TVA) ;
  • Matériel (suivi du matériel Oslandia et collaborateur sur l’ERP, commandes du matériel).

  Gestion administrative du personnel

  • Paie (transmission au cabinet comptable, vérification, classement…) ;
  • Gestion admin des entrées et sorties des colloborateurs (DPAE, affiliation mutuelle et prévoyance, maj dossiers individuels, visites médicales, conformité électriques, …) ;
  • Saisie des éléments de tableau indicateurs RH (absences, salaires, données du contrat de travail …).

  Gestion des services généraux

  • Qualification et affectation des appels et mails entrants ;
  • Gestion du courrier (scan, transfert, …) ;
  • Classement des documents comptables ;
  • Gestion administrative : location de salle, achats et gestion des stocks ;
  • Organisation logistique de séminaires et événements ;
  • Relations clients et fournisseurs ;
  • Gestion administrative de l’activité formation d’Oslandia (définition du besoin, courriers, …).

  Compétences recherchées

  Au-delà de votre formation (Niveau BAC ou BAC+2 Comptabilité/Gestion/Administratif), nous serons davantage attentifs aux compétences acquises par l’expérience dans des fonctions proches ou similaires.

  • Travail à distance
  • Comptabilité
  • Administration du personnel
  • Maîtrise des logiciels bureautiques
  • Adaptabilité aux outils numériques

  Qualités humaines recherchées

  • Organisation
  • Rigueur
  • Autonomie
  • Sens du service
  • Capacité à gérer plusieurs projets en même temps
  • Réactivité et gestion des priorités

  Conditions

  • CDI en 100 % télétravail avec possibilité de coworking
  • Localisation en Île de France
  • 37h hebdomadaire, non-cadre avec accord collectif ( 1RTT / mois )
  • Temps plein, possibilité de temps partiel 80 %
  • Rémunération entre 27 et 30 K€ annuels en fonction du profil et de l’expérience
  • Poste à pourvoir rapidement

  Nous offrons

  Oslandia est une société au modèle organisationnel atypique, avec des valeurs affirmées et une cohérence forte entre son objectif de développement des outils OpenSource et son mode de fonctionnement interne.

  Nous offrons un pack de rémunération composé notamment des aspects suivants :

  • Salaire en fonction de l’expérience
  • Transparence salariale interne
  • Accord d’intéressement collectif avec répartition égalitaire
  • Mutuelle d’entreprise fortement couvrante intégrant les ayant-droits
    prise en charge à 75% par l’entreprise

  Candidater

  Effectuez votre candidature par l’intermédiaire de notre formulaire dédié. La référence de l’annonce est OSL2402A

  Nous vous demandons notamment :

  • Un CV détaillé et à jour
  • Un texte présentant votre motivation à nous rejoindre

  Nous reviendrons vers vous sous peu si votre candidature retient notre attention.

  Notre processus de recrutement est présenté sur notre page web et vous sera explicité lors des premiers entretiens. Il comporte plusieurs entretiens individuels avec différents collaborateurs de notre équipe, sur des aspects techniques ainsi que de savoir-être. À l’issue de processus, nous mettons en place un plan d’intégration personnalisé qui vous permet une arrivée la meilleure possible parmi nous.

  Nous avons hâte de vous rencontrer, alors n’hésitez pas !

• 7:00

  ZFE.green, faciliter la logistique urbaine durable

  sur Oslandia

  Une loi d’août 2021 rend la mise en place obligatoire des ZFE (Zone à Faibles Émissions) dans toutes les agglomérations de plus de 150 000 habitants avant le 31 décembre 2024. A l’initiative du groupement d’acteurs privés et publics InTerLUD (Innovations Territoriales et Logistique Urbaine Durable),  l’application ZFE.green permet aux professionnels de disposer d’informations précises et de visualiser rapidement les contraintes de circulation des ZFE-m (-mobilité) spécifiques à chaque territoire.

  

  En entrant les caractéristiques de son véhicule, le type de vignette Crit’Air mais aussi la nature de son activité, le professionnel accèdera aux ZFE-m actives et en projet et identifiera très rapidement les zones à circulation autorisées ou interdites.

  L’application permet par ailleurs de visualiser son itinéraire de circulation avec les ZFE-m traversées et un itinéraire bis sans ZFE-m.

  Itinéraire de circulation :

  

  Itinéraire bis sans ZFE-m :

  

  Origine du projet

  Le projet ZFE.green s’inscrit dans le cadre d’un programme CEE – Certificat d’Economie d’Energie incitant les entreprises de certains secteurs tels que celui de l’énergie, à compenser leur impact en finançant des projets générant des économies d’énergie. InTerLUD a souhaité mettre en œuvre un outil pour faciliter la logistique urbaine durable et s’est pour cela entretenu avec les collectivités et les fédérations de professionnels (logisticiens mais aussi artisans) afin de signer une charte pour une logistique plus douce. InTerLUD souhaitant privilégier les technologies open source et open data, s’est entouré d’ALLOHOUSTON et d’Oslandia pour la mise en œuvre technique du projet.

  Les acteurs du projet

  • ALLOHOUSTON est venu en conseil pour proposer un outil sur mesure à InTerLUD : interview des utilisateurs, ateliers, conception fonctionnelle, …
  • Oslandia a apporté son expertise sur les volets cartographiques et calcul d’itinéraires.

  Les technologies mobilisées

  • ALLOHOUSTON : framework MeteorJS, front en ReactJS, OpenLayers, Mongo DB
    Oslandia : fonds de carte IGN, PG routing pour le calcul d’itinéraires, PostgreSQL

  Aurélien Debacq, Co-fondateur ALLOHOUSTON « Oslandia a apporté son expertise technique à la fois dans la conception technique de l’ensemble, dans le choix des data, des référentiels, le choix des librairies à utiliser. Oslandia travaille sur la nouvelle géoplateforme de l’IGN et c’est une voie envisagée pour une évolution future »

  Le développement technique a débuté le 1er semestre 2022 pour une utilisation effective en septembre 2022.

  La deuxième phase du programme CEE InTerLUD, co-porté par le Cerema, Logistic Low Carbon et Rozo a été lancée fin 2022 sous l’appellation CEE LUD+. ALLOHOUSTON et Oslandia poursuivent leur collaboration sur ce programme

  A terme, l’application ZFE.green devrait être versée en open source à la communauté.

  Plus d’infos

  • [https:]]
  • [https:]]

• 4:19

  XYCarto: Projection Grid

  sur Planet OSGeo

  There are times when I need a regular grid for an entire projection extent.  Meaning, for the extent of an entire projection, I need to create a regular grid of uniform tiles across the projection.  In past projects, these grids have been very helpful for data alignment and clipping data into uniform shapes and sizes. This has proved especially helpful in Machine Learning pipelines where I need to ensure pixel to pixel alignments between rasters in a specified location.

  Gridding, tiling, and indexing type work has been around forever in geospatial, so there is not much to say about the method.  Basically, you take an extent and cut it up into a grid. In this case, the extent is for an entire projection.

  I built a repository on Github and a quick method to do this via one command.

  make build-grid epsg="EPSG:2193" width=1000 height=1000

  For this method, the width and height are the desired grid cell size.  The units are the units for the projection.  EPSG:2193 (NZTM) is in metre units, so running the command above will make a grid of the NZTM projection populated with 1000m by 1000m cells.

  The GitHub repository can be run using the Make/Docker method or users can access the python script directly using:

  python3 create-grid.py EPSG:2193 1000 1000

  In order to do so, you will need to have installed:

  • GDAL
  • GeoPandas
  • PyProj
  • Shapely

  Happy mapping!

• 3:29

  GeoSolutions: GeoNode 4.2 is out + Free GeoNode Webinar

  sur Planet OSGeo

  Pièce jointe: [télécharger]

  You must be logged into the site to view this content.

• 09 February 2024
• 7:00

  La qualité logicielle dans QGIS

  sur Oslandia

  Selon la définition de la qualité logicielle qu’en donne Wikipédia

  Une appréciation globale de la qualité tient autant compte des facteurs extérieurs, directement observables par l’utilisateur, que des facteurs intérieurs, observables par les ingénieurs lors des revues de code ou des travaux de maintenance.

  J’ai fait le choix dans cet article de ne parler brièvement que des seconds. La qualité d’un logiciel et plus précisément QGIS ne se limite donc pas à ce qui est décrit ici. Il y aurait encore beaucoup à dire sur:

  • La prise en compte des retours utilisateurs,
  • le processus de rédaction de la documentation,
  • la gestion de la traduction,
  • l’interopérabilité via l’implémentation des standards,
  • l’extensibilité permise par une API toujours plus riche,
  • la réversibilité et la résilience du modèle open source…

  Ce sont des sujets qui nous tiennent à coeur, mais qui mériteraient chacun leur propre article.

  Je me concentrerai ici sur la problématique suivante : QGIS est un logiciel libre et permet à quiconque doté des compétences nécessaires de modifier le logiciel. Mais comment s’assurer alors que les multiples propositions de modifications du logiciel contribuent bien à son amélioration et ne portent pas préjudice à sa maintenance future?

  L’auto-discipline

  Les développeurs contribuant au code de QGIS n’appartiennent pas tous à la même organisation. Ils ne vivent pas tous dans le même pays, n’ont pas forcément la même culture et ne partagent pas forcément les mêmes intérêts ou ambitions pour le logiciel. Ils partagent cependant la conscience de modifier un bien commun et l’envie d’en prendre soin.

  Cette conscience transcende la conscience professionnelle, le développeur n’a pas seulement une responsabilité vis à vis de son employeur, mais aussi envers l’ensemble de la communauté d’utilisateurs et de contributeurs du logiciel.

  Cette auto-discipline est le fondement de la qualité des contributions d’un logiciel comme QGIS.

  Cependant, l’erreur est humaine et il est indispensable de procéder à des vérifications lors de chaque proposition de modification.

  Les vérifications automatiques

  À chaque proposition de modification (appelées Pull Request ou Merge Request ), la plateforme GitHub de QGIS lance automatiquement un ensemble de vérifications automatiques.

  
  Exemple de proposition de modification

  
  Résultat des vérifications automatiques sur une proposition de modification

  La première de ces vérifications est de construire QGIS sur les différents systèmes sur lesquels il est distribué (Linux, Windows, MacOS) en intégrant la modification proposée. Il est inconcevable d’intégrer une modification qui empêcherait de construire l’application sur l’un de ces systèmes.

  Les tests

  La première problématique posée par une proposition de modification est la suivante « Comment être sur que ce qui va être introduit ne casse pas ce qui existe déjà ? ».

  Pour valider cette assertion, on s’appuie sur des tests automatiques. Il s’agit d’un ensemble de micro-programmes que l’on nomme tests, dont le seul but est de valider qu’une partie de l’application se comporte comme attendue. Par exemple, il existe un test qui valide que lorsque l’utilisateur ajoute une entrée dans une couche de donnée, alors cette entrée est ensuite bien présente dans la couche de donnée. Si une modification venait à casser ce comportement, alors le test échouerait et la proposition serait refusée (ou plus vraisemblablement corrigée).

  Cela permet notamment d’éviter les régressions (on les appelle très souvent tests de non régression) et aussi de qualifier le comportement attendu.

  Il y a approximativement 1,3 Millions de lignes de code pour l’application QGIS et 420K de lignes de codes de tests, soit un rapport de 1 à 3. La présence de tests est obligatoire pour l’ajout de fonctionnalité, par conséquent la quantité de code tests augmente avec la quantité de code applicatif.

   

  

  En bleu le nombre de lignes de code dans QGIS, en rouge le nombre de lignes de tests

  On compte à l’heure actuelle dans QGIS plus de 900 groupes de tests automatiques qui s’exécutent pour la plupart en moins de 2 secondes, pour un temps d’exécution total d’environ 30 minutes.

  On constate par ailleurs que certaines parties du code de QGIS – les plus récentes – sont mieux couvertes par les tests que d’autres plus anciennes. Les développeurs s’efforcent au fur et à mesure d’améliorer cette situation pour résorber la dette technique.

  Les vérifications de forme

  De manière analogue à l’utilisation d’un correcteur orthographique lors de la rédaction d’un document, on procède à un ensemble de vérifications de forme sur le code source. On vérifie par exemple que la proposition de modification ne contient pas de mots mal orthographiés ni de mots « bannis », que la documentation de l’API a bien été rédigée ou encore que le code modifié respecte certaines règles de forme du langage de programmation.

  Nous avons eu l’occasion récémment d’ajouter une vérification basé sur l’outil clang-tidy. Ce dernier s’appui sur le compilateur Clang. Il est capable de détecter des erreurs de programmation en procédent à une analyse statique du code.

  Clang-tidy est par exemple capable de détecter les « narrowing conversions ».

  Exemple de détection de « narrowing conversions »

  Dans l’exemple ci-dessus, Clang-tidy détecte qu’il y a eu « narrowing conversion » et que la valeur du port utilisé dans la configuration du proxy réseau « peut » être altérée. En l’occurence, ce problème a bien été reporté sur la plateforme d’anomalies de QGIS et a dû être corrigé.

  A l’époque, clang-tidy n’était pas en place. Son utilisation aurait permis d’éviter cette anomalie et toutes les étapes qui ont menées à sa correction (description exhaustive de l’anomalie, multiples échanges pour permettre sa reproduction, investigation, correction, revue de la modification), soit une quantité conséquente de temps humain qui aurait ainsi pu être évité.

  La revue par les pairs

  Une proposition de modification qui validerait l’ensemble des vérifications automatiques décrites ci-dessus ne serait pas forcément intégrée dans le code de QGIS de façon automatique. De fait, son code est peut-etre mal conçu ou la modification mal pensée. La pertinence de la fonctionnalité est peut être douteuse, ou fait doublon avec une autre. L’intégration de la modification entrainerait donc potentiellement un fardeau pour les personnes responsables de la maintenance corrective ou évolutive du logicielle.

  Il est donc indispensable d’inclure une revue humaine dans le processus d’acceptation d’une modification.

  Il s’agit plus d’une relecture de fond de la proposition que de forme. Pour ces dernières, on priviligie les vérifications automatiques décrites précédemment en vue d’alléger le processus de revue.

  Par conséquent, la relecture humaine prends du temps, et cet effort est grandissant avec la quantité de modifications proposées dans le code de QGIS. La question de son financement se pose, et des discussions sont en cours. L’association QGIS.org dédie notamment une partie conséquente de son budget pour financer les revues de code.

  

  Plus de 100 propositions de modification ont été revues et intégrées sur le mois de décembre 2023. Plus de 30 personnes différentes ont contribué. Plus de 2000 fichiers ont été modifiés.

  Par conséquent l’attente d’une relecture peut parfois être longue. C’est aussi souvent le moment où s’exprime les désaccords. C’est donc une phase qui peut s’avérer frustrante pour les contributeurs, mais c’est un moment important et riche de la vie communautaire d’un projet libre.

  A suivre !

  En tant que développeur cœur QGIS, et en tant que société pure player OpenSource, nous pensons qu’il est fondamental de nous impliquer dans chacune des étapes du processus de contribution.

  Nous nous investissons dans le processus de relecture, l’amélioration des vérifications automatiques, et dans le processus qualité de QGIS de façon générale. Et nous continuerons à nous investir dans ces problématiques afin de contribuer à faire de QGIS un logiciel pérenne et stable.

  Si vous souhaitez contribuer ou simplement en savoir plus sur QGIS, n’hésitez pas à nous contacter à infos+qgis@oslandia.com et consulter notre proposition de support à QGIS.

• 08 February 2024
• 1:00

  PostGIS Development: PostGIS Patch Releases

  sur Planet OSGeo
  The PostGIS development team is pleased to provide bug fix releases for 3.4.2, 3.3.6, 3.2.7, 3.1.11, 3.0.11, and 2.5.11. Please refer to the links above for more information about the issues resolved by these releases.
• 07 February 2024
• 13:55

  Oslandia: Software quality in QGIS

  sur Planet OSGeo

  According to the definition of software quality given by french Wikipedia

  An overall assessment of quality takes into account external factors, directly observable by the user, as well as internal factors, observable by engineers during code reviews or maintenance work.

  I have chosen in this article to only talk about the latter. The quality of software and more precisely QGIS is therefore not limited to what is described here. There is still much to say about:

  • Taking user feedback into account,
  • the documentation writing process,
  • translation management,
  • interoperability through the implementation of standards,
  • the extensibility using API,
  • the reversibility and resilience of the open source model…

  These are subjects that we care a lot and deserve their own article.

  I will focus here on the following issue: QGIS is free software and allows anyone with the necessary skills to modify the software. But how can we ensure that the multiple proposals for modifications to the software contribute to its improvement and do not harm its future maintenance?

  Self-discipline

  All developers contributing to QGIS code doesn’t belong to the same organization. They don’t all live in the same country, don’t necessarily have the same culture and don’t necessarily share the same interests or ambitions for the software. However, they share the awareness of modifying a common good and the desire to take care of it.

  This awareness transcends professional awareness, the developer not only has a responsibility towards his employer, but also towards the entire community of users and contributors to the software.

  This self-discipline is the foundation of the quality of the contributions of software like QGIS.

  However, to err is human and it is essential to carry out checks for each modification proposal.

  Automatic checks

  With each modification proposal (called Pull Request or Merge Request), the QGIS GitHub platform automatically launches a set of automatic checks.

  

  Example of proposed modification

  

  Result of automatic checks on a modification proposal

  The first of these checks is to build QGIS on the different systems on which it is distributed (Linux, Windows, MacOS) by integrating the proposed modification. It is inconceivable to integrate a modification that would prevent the application from being built on one of these systems.

  The tests

  The first problem posed by a proposed modification is the following “How can we be sure that what is going to be introduced does not break what already exists?”

  To validate this assertion, we rely on automatic tests. This is a set of micro-programs called tests, which only purpose is to validate that part of the application behaves as expected. For example, there is a test which validates that when the user adds an entry in a data layer, then this entry is then present in the data layer. If a modification were to break this behavior, then the test would fail and the proposal would be rejected (or more likely corrected).

  This makes it possible in particular to avoid regressions (they are very often called non-regression tests) and also to qualify the expected behavior.

  There are approximately 1.3 Million lines of code for the QGIS application and 420K lines of test code, a ratio of 1 to 3. The presence of tests is mandatory for adding functionality, therefore the quantity of test code increases with the quantity of application code.

  

  In blue the number of lines of code in QGIS, in red the number of lines of tests

  There are currently over 900 groups of automatic tests in QGIS, most of which run in less than 2 seconds, for a total execution time of around 30 minutes.

  We also see that certain parts of the QGIS code – the most recent – are better covered by the tests than other older ones. Developers are gradually working to improve this situation to reduce technical debt.

  Code checks

  Analogous to using a spell checker when writing a document, we carry out a set of quality checks on the source code. We check, for example, that the proposed modification does not contain misspelled words or “banned” words, that the API documentation has been correctly written or that the modified code respects certain formal rules of the programming language.

  We recently had the opportunity to add a check based on the clang-tidy tool. The latter relies on the Clang compiler. It is capable of detecting programming errors by carrying out a static analysis of the code.

  Clang-tidy is, for example, capable of detecting “narrowing conversions”.

  

  Example of detecting “narrowing conversions”

  In the example above, Clang-tidy detects that there has been a “narrowing conversion” and that the value of the port used in the network proxy configuration “may” be corrupted. In this case, this problem was reported on the QGIS issues platform and had to be corrected.

  At that time, clang-tidy was not in place. Its use would have made it possible to avoid this anomaly and all the steps which led to its correction (exhaustive description of the issue, multiple exchanges to be able to reproduce it, investigation, correction, review of the modification), meaning a significant amount of human time which could thus have been avoided.

  Peer review

  A proposed modification that would validate all of the automatic checks described above would not necessarily be integrated into the QGIS code automatically. In fact, its code may be poorly designed or the modification poorly thought out. The relevance of the functionality may be doubtful, or duplicated with another. The integration of the modification would therefore potentially cause a burden for the people in charge of the corrective or evolutionary maintenance of the software.

  It is therefore essential to include a human review in the process of accepting a modification.

  This is more of a rereading of the substance of the proposal than of the form. For the latter, we favor the automatic checks described above in order to simplify the review process.

  Therefore, human proofreading takes time, and this effort is growing with the quantity of modifications proposed in the QGIS code. The question of its funding arises, and discussions are in progress. The QGIS.org association notably dedicates a significant part of its budget to fund code reviews.

  

  More than 100 modification proposals were reviewed and integrated during the month of December 2023. More than 30 different people contributed. More than 2000 files have been modified.

  Therefore the wait for a proofreading can sometimes be long. It is also often the moment when disagreements are expressed. It is therefore a phase which can prove frustrating for contributors, but it is an important and rich moment in the community life of a free project.

  To be continued !

  As a core QGIS developer, and as a pure player OpenSource company, we believe it is fundamental to be involved in each step of the contribution process.

  We are investing in the review process, improving automatic checks, and in the QGIS quality process in general. And we will continue to invest in these topics in order to help make QGIS a long-lasting and stable software.

  If you would like to contribute or simply learn more about QGIS, do not hesitate to contact us at infos+qgis@oslandia.com and consult our QGIS support proposal.

• 7:00

  [1’Tech by Oslandia] LiDAR

  sur Oslandia

  Dans cette minute Tech, nos collaborateurs vous proposent d’expliquer une technologie, une méthodologie, un concept. Après « open source« , on a brainstormé sur GitLab pour donner notre meilleure définition du LiDAR (Light Detection And Ranging).

  Déf : Un LiDAR est un capteur permettant grâce à un laser d’extraire des informations géophysiques de l’environnement, notamment des coordonnées X, Y, Z, et une intensité lumineuse. On dispose en sortie d’un nuage de points 3D que l’on peut exploiter pour la visualisation ou de nombreux autres usages.
  L’IGN, via le programme LiDAR HD, met à disposition une cartographie 3D de l’intégralité du sol et du sursol de la France en données LIDAR.

  LiDAR x Oslandia

  Nous avons utilisé la technologie LiDAR sur plusieurs projets et notamment dans Giro3D qui dispose d’une visualisation de LiDAR avec un pre-processing via py3dtiles, un module Python développé pour les formats 3DTiles.

  Nos équipes ont également travaillé sur des projets liés à la reconstruction de bâtiments à partir de LiDAR : par exemple dans Giro3D via notre plugin QGIS CityBuilder visualisable dans QGIS 3D.

• 06 February 2024
• 17:00

  Paul Ramsey: Building the PgConf.Dev Programme

  sur Planet OSGeo

  Update: The programme is now public.

  The programme for pgconf.dev in Vancouver (May 28-31) has been selected, the speakers have been notified, and the whole thing should be posted on the web site relatively soon.

  

  I have been on programme committees a number of times, but for regional and international FOSS4G events, never for a PostgreSQL event, and the parameters were notably different.

  The parameter that was most important for selecting a programme this year was the over 180 submissions, versus the 33 available speaking slots. For FOSS4G conferences, it has been normal to have between two- and three-times as many submissions as slots. To have almost six-times as many made the process very difficult indeed.

  Why only 33 speaking slots? Well, that’s a result of two things:

  • Assuming no more than modest growth over the last iteration of PgCon, puts attendence at around 200, which is the size of our plenary room. 200 attendees implies no more than 3 tracks of content.
  • Historically, PostgreSQL events use talks of about 50 minutes in length, within a one hour slot. Over three tracks and two days, that gives us around 33 talks (with slight variations depending on how much time is in plenary, keynotes or lightning talks).

  The content of those 33 talks falls out from being the successor to PgCon. PgCon has historically been the event attended by all major contributors. There is an invitation-only contributors round-table on the pre-event day, specifically for the valuable face-to-face synch-up.

  

  Given only 33 slots, and a unique audience that contains so many contributors, the question of what pgconf.dev should “be” ends up focussed around making the best use of that audience. pgconf.dev should be a place where users, developers, and community organizers come together to focus on Postgres development and community growth.

  That’s why in addition to talks about future development directions there are talks about PostgreSQL coding concepts, and patch review, and extensions. High throughput memory algorithms are good, but so is the best way to write a technical blog entry.

  Getting from 180+ submissions to 33 selections (plus some stand-by talks in case of cancellations) was a process that consumed three calls of over 2 hours each and several hours of reading every submitted abstract.

  The process was shepherded by the inimitable Jonathan Katz.

  • A first phase of just coding talks as either “acceptable” or “not relevant”. Any talks that all the committee members agreed was “not relevant” were dropped from contention.
  • A second phase where each member picked 40 talks from the remaining set into a kind of “personal program”. The talks with just one program member selecting them were then reviewed one at a time, and that member would make the case for them being retained, or let them drop.
  • A winnow looking for duplicate topic talks and selecting the strongest, or encouraging speakers to collaborate.
  • A third “personal program” phase, but this time narrowing the list to 33 talks each.
  • A winnow of the most highly ranked talks, to make sure they really fit the goal of the programme and weren’t just a topic we all happened to find “cool”.
  • A talk by talk review of all the remaining talks, ensuring we were comfortable with all choices, and with the aggregate make up of the programme.

  The programme committee was great to work with, willing to speak up about their opinions, disagree amicably, and come to a consensus.

  

  Since we had to leave 150 talks behind, there’s no doubt lots of speakers who are sad they weren’t selected, and there’s lots of talks that we would have taken if we had more slots.

  If you read all the way to here, you must be serious about coming, so you need to register and book your hotel right away. Spaces are, really, no kidding, very limited.

• 12:03

  Oslandia: (Fr) Rencontres QGIS-fr – Grenoble 27 & 28 mars 2024

  sur Planet OSGeo

  Sorry, this entry is only available in French.

• 12:02

  Rencontres QGIS-fr – Grenoble 27 & 28 mars 2024

  sur Oslandia

  Oslandia sera présent aux prochaines rencontres des utilisateurs francophones de QGIS qui auront lieu les 27 et 28 mars 2024 à Grenoble. A cette occasion et dans le cadre de l’appel à conférences et ateliers, vous pourrez nous retrouvez sur plusieurs sujets

  Nouveautés QGIS 3D par Jean Felder et Benoit De Mezzo

  QGIS intègre un visualiseur 3D prenant en charge une variété de formats de données 2D et 3D. Cet atelier vous présentera les fonctionnalités bases (vues, caméra, chargement de données) ainsi que des avancées. Vous y découvrirez la manipulation des données 3D : chargement, configuration des vues et caméra ainsi que le chargement de données tels que les modèle numérique de terrain, les tuiles 3D (3dtiles), les nuages de points et PostGIS 3D. Vous pourrez exploiter des outils comme la boundingbox ou l’élévation de profils et des méthodes d’analyse adaptées à cet environnement tridimensionnel.

  Créer et publier un joli projet sur QWC par Gwendoline Andres et Florent Fougeres

  Durant cet atelier vous découvrirez comment publier une jolie carte web sur QWC à partir de votre projet QGIS. Vous verrez ce qu’il est possible de réaliser au niveau visuel (sur la carte), comment mettre en valeur ses attributs et le paramétrage de l’impression de cartes.
  Ensuite nous aborderons la publication de vos projets QGIS depuis l’interface d’administration de QWC. Pour finir, nous découvrirons le nouveau plugin QGIS pour publier confortablement depuis QGIS.

  Cartographie avancée avec QGIS par Julien Cabièces et Jacky Volpes

  Après un bref rappel sur les concepts de base de la réalisation de symbologie dans QGIS, cet atelier vous propose d’explorer les fonctionnalités de symbologies avancées sur des données vectorielles ou images. Nous aborderons entre autres : le rendu par catégorie ou via un ensemble de règles, les masques sélectifs, l’utilisation du générateur de géométrie, comment intégrer la dimension temporelle dans vos cartes. Enfin, nous présenterons quelques notions à connaître pour réussir l’intégration de ces cartes dans vos mises en pages et rapport.

  Initiation au déploiement rationalisé de QGIS avec PowerShell et QDT par Julien Moura et Florent Fougeres

  Automatisez vos installations de QGIS avec PowerShell et rationalisez le déploiement des profils QGIS plus efficacement avec QGIS Deployment Toolbelt (QDT). Apprenez à : 1) installer, désinstaller et mettre à jour QGIS en mode silencieux, 2) rationaliser, stocker et versionner vos profils QGIS avec un fichier profile.json et Git, 3) concevoir un scénario de déploiement pour automatiser le déploiement des profils avec QDT.  Bref une bonne occasion de mettre le pied à l’étrier pour optimiser votre flux de travail d’administrateur/ice QGIS !

  Collecter vos données sur le terrain avec QField par Loïc Bartoletti

  QField permet une intégration transparente avec QGIS, propose des fonctionnalités essentielles pour capturer, éditer et synchroniser aisément des données géographiques en temps réel sur vos appareils mobiles. L’atelier explorera comment importer des couches cartographiques de QGIS vers QField, ainsi que les méthodes de travail hors ligne et synchronisé sur les données collectées. Vous découvrirez comment QField optimise la saisie précise des données terrain, améliorant ainsi la productivité et la qualité des données recueillies. Cette présentation conjointe entre Oslandia, promoteur QField France et OpenGIS, développeur suisse de QField, sera l’occasion de partager astuces et bonnes pratiques ainsi que des retours d’expérience pour optimiser l’utilisation de QField dans votre SIG.

  Les conférences de nos clients

  • Notre client, Les Agences de l’eau, animera un atelier sur le sujet : Un plugin QGIS et un service de publication pour QGIS Web Client (QWC)
  • Orange animera une conférence sur QGIS Server : composant principal du SIG d’Orange

  Oslandia x QGIS

  Oslandia est Mécène Or des Rencontres utilisateurs QGIS-fr 2024.
  Au fil des projets réalisés et des expériences, Oslandia a acquis un statut d’acteur majeur français sur QGIS. Depuis 2011, Oslandia est éditeur open source QGIS et contribue activement à la communauté.

  Plus d’infos

  • Le programme complet est disponible : [https:]]
  • Inscription : [https:]]

  RDV les 27 et 28 mars à Grenoble !

   

• 1:00

  SourcePole: Designing QGIS Cloud QWC2 with CSS

  sur Planet OSGeo
  In an earlier post, I showed how it is possible to permanently position a legend in the QGIS Cloud map as part of a QGIS Cloud Pro subscription. To achieve this, the appearance of the map view was changed using CSS. In this post, I will describe exactly what this is and how it works. The appearance of the QGIS Cloud Web Client is controlled via CSS. CSS stands for Cascading Style Sheets.
• 05 February 2024
• 9:00

  Lutra consulting: New point clouds and mesh features in QGIS 3.36

  sur Planet OSGeo

  QGIS 3.36 is round the corner and as usual, there will be several new exciting features with the new release. Below is the list of features our team has added to the new release. This was made possible by generous funding from clients.

  Render point clouds as a surface in 2D map views

  Point clouds are rendered as individual points by default. Depending on the zoom level and density of the points, you might not be able to get a full picture of the map.

  Rendering points as surface enables you to have a better understanding of the data before trying to do any analysis or processing. This has been possible in 3D map views for a couple of QGIS releases, now we have added the functionality also in 2D map views.

  The feature generates a surface using triangulation on-the-fly from the points using the same symbology. Below you can see the difference between a point cloud rendered as individual points and rendered as a surface:

  

  Point clouds as individual points vs. as a TIN surface

  The good news is that rendering as a surface also works well with global map shading, allowing users to get a nice hillshade:

  

  Point clouds as surface with hillshade

  To enable this feature, you need to check the option for Render as a Surface (Triangulate) under the Layer Styling panel.

  

  Settings to display point clouds as surface

  Pro-tip: if the on-the-fly rendering as a surface takes too long to render, try increasing the Maximum error: for example 0.6 mm instead of the default 0.3 mm.

  Flexible styling of classes

  Previously, point cloud data visualisation in QGIS was limited to rendering all points with a uniform size and opacity. This made it difficult to differentiate between different point classes and highlight specific features of interest. To address this issue, we have introduced a new feature that allows users to customise the point size and opacity for each point cloud data class. This provides a flexible way for visualising point cloud data, allowing users to highlight specific point classes, e.g. by increasing the point size.

  

  Assigning size and opacity to each point cloud class

  

  Point clouds with different sizes and opacity levels Set 3D map view extent in 2D map

  Effectively navigating and visualising large-scale 3D datasets can be challenging on PCs with limited resources. To address this issue, we introduced a new feature that allows users to interactively limit the 3D scene, enabling them to focus on specific areas of interest. This new feature, conveniently accessible from the toolbar, eliminates the need for tedious manual entry of coordinates for bounding boxes. Instead, users can simply drag and draw a box around the desired area, instantly restricting the 3D scene to that specific extent. This interactive approach significantly enhances the user experience and streamlines the process of exploring and analysing 3D data:

  

  Interactive selection of 3D map scene from 2D map Python API for 3D views

  Creating and viewing 3D maps in QGIS with the correct camera location and angle, scene tilt, light, and other parameters can be a time-consuming and error-prone process. This is because it requires users to manually adjust these settings, often through trial and error. However, with the introduction of the new 3D map view API in QGIS, Python plugins can now automate this process, making it much easier, consistent and more efficient to create high-quality 3D maps that are visually appealing and informative.

  # List all open 3D map canvases
  iface.mapCanvases3D()
  # [<qgis._3d.Qgs3DMapCanvas object at 0x7f23491b5e10>]
  canvas = iface.mapCanvases3D()[0]
  

  Now let’s try something more complicated:

  # Let's change some settings!
  ms = canvas.mapSettings()
  ms.setEyeDomeLightingEnabled(True)
  ms.setBackgroundColor(QColor('beige'))
  ms.setTerrainMapTheme('dtm')
  ms.setFieldOfView(110)
  
  # Move the camera to look at specific map coordinates in layer's CRS
  cam = canvas.cameraController()
  mapPoint = QgsVector3D(-498175.92, -1205400.58, 210)
  worldPoint = ms.mapToWorldCoordinates(mapPoint)
  cam.setLookingAtPoint(worldPoint, 60, 45, 100)
  
  # Create four new 3D map views
  c1 = iface.createNewMapCanvas3D('South View')
  c2 = iface.createNewMapCanvas3D('West View')
  c3 = iface.createNewMapCanvas3D('North View')
  c4 = iface.createNewMapCanvas3D('East View')
  
  # Apply settings to all open 3D map views
  for canvas in iface.mapCanvases3D():
  	canvas.mapSettings().setEyeDomeLightingEnabled(True)
  
  # Define a camera pose to update the views' cameras
  pose = QgsCameraPose()
  pose.setCenterPoint(QgsVector3D(0, 210, 0))  # This is in 3D world coordinates
  pose.setDistanceFromCenterPoint(100)
  pose.setPitchAngle(75)  # Tilt the camera by 75 degrees
  pose.setHeadingAngle(0)  # Looking towards North
  c1.cameraController().setCameraPose(pose)
  pose.setHeadingAngle(90)  # Towards East
  c2.cameraController().setCameraPose(pose)
  pose.setHeadingAngle(180)  # Towards South
  c3.cameraController().setCameraPose(pose)
  pose.setHeadingAngle(270)  # Towards West
  c4.cameraController().setCameraPose(pose)
  
  # We can set the 3D map views 2D extent to always match the main 2D canvas one
  # Our 3D views get updated while zooming/panning the main 2D canvas
  canvas = iface.mapCanvas()
  canvas.extentsChanged.connect(lambda :c1.mapSettings().setExtent(canvas.extent()))
  canvas.extentsChanged.connect(lambda :c2.mapSettings().setExtent(canvas.extent()))
  canvas.extentsChanged.connect(lambda :c3.mapSettings().setExtent(canvas.extent()))
  canvas.extentsChanged.connect(lambda :c4.mapSettings().setExtent(canvas.extent()))
  

  

  Changing 3D view settings through Python More point clouds attributes

  LAS/LAZ/COPC point clouds have a classificationFlags attribute that stores four types of information (Synthetic, Keypoint, Withheld, and Overlap) in a single value. This saves space, but it makes it difficult to use the information for styling or filtering, as you need to write complex expressions.

  To make it easier to use, we are following the approach introduced in PDAL 2.6: the classificationFlags attribute gets replaced with four separate attributes: Synthetic, Keypoint, Withheld, and Overlap. This will make it easier to include these attributes in styling and filtering expressions.

  Performance enhancement for rendering

  To improve the performance of point cloud rendering in QGIS, we introduced a new caching system to minimise the need for repeated decompression of LAS node data while panning or zooming. This caching mechanism efficiently stores decompressed points for each unique combination of layer URI, node, requested attributes, filter extent, and filter expression. This enables rapid rendering of previously cached nodes, significantly enhancing the overall rendering performance in 2D and 3D maps.

  Performance can vary depending on actual data, but on a local sample COPC file, it renders 7 times faster with this change.

  Labels for mesh layer

  Viewing mesh data has been possible through styling, plotting or using the Identify tool. But now you can also create labels on mesh surfaces or vertices similar to vector layers.

  To display labels for your mesh data, simply open the styling panel and enable labels for:

  • Labels on Vertices
  • Labels on Surfaces

  

  Label settings for mesh layers

  Below is an example of mesh Z values at vertices (yellow) and mesh areas at cell centre (purple):

  

  Example of labels on a mesh layer Want more changes in QGIS?

  Do you want to see more improvements and new features in QGIS? Do not hesitate to contact us to discuss your requiremnets.

• 0:09

  Sean Gillies: Preseason running

  sur Planet OSGeo

  My 32 week running season starts on February 19 and ends on September 29, at Bear Lake if everything goes right. My preseason running has been light on running because of various maladies. I strained my back at the end of December and just as I recovered from that I experienced some knee inflammation that was badly aggravated by running. For the past three weeks I've switched to weight training and chugging on the elliptical machines at a nearby gym. I'm doing 5x5s of squats, deadlifts, etc three times a week and 4-5 x 3 minute hard elliptical intervals once or twice a week. In between I've been walking briskly on the bike path or hiking on trails. I'd hoped to be actually running 6 hours a week by now, but am adjusting and getting some good workouts in. By February 19, I think I'll be able to take my interval workouts outside and switch from hiking to running without beating up on my knee.

• 04 February 2024
• 15:42

  Markus Neteler: Celebrating 18 Years of the Open Source Geospatial Foundation (OSGeo)

  sur Planet OSGeo

  The Open Source Geospatial Foundation (OSGeo) today celebrates its 18th anniversary, underscoring its pivotal role in the development of open source geospatial software and its impact on the world. Founded in 2006, OSGeo’s mission is to support and promote the collaborative development of open geospatial technologies and data. Over the years, it has become a cornerstone of the open geospatial community, fostering innovation, education and adoption of open source geospatial software worldwide.

  The post Celebrating 18 Years of the Open Source Geospatial Foundation (OSGeo) appeared first on Markus Neteler Consulting.