diff --git a/.github/workflows/manual_new_rdp.yml b/.github/workflows/manual_new_rdp.yml index 341e94c8f1..38f4445f15 100644 --- a/.github/workflows/manual_new_rdp.yml +++ b/.github/workflows/manual_new_rdp.yml @@ -68,7 +68,7 @@ jobs: - name: Notification Slack id: slack - uses: slackapi/slack-github-action@v1.26 + uses: slackapi/slack-github-action@v1.27 if: "${{ github.event.inputs.notify-slack == 'true' }}" with: payload: '{"blocks":[{"type":"section","text":{"type":"mrkdwn","text":":newspaper: La GeoRDP du ${{ env.DATE_FR_LONG }} a été créée et attend vos contributions :writing_hand: !"}},{"type":"section","fields":[{"type":"mrkdwn","text":"Créée par *${{ github.actor }}* via GitHub Action."}]},{"type":"actions","elements":[{"type":"button","text":{"type":"plain_text","emoji":true,"text":":squid: Voir la PR (GitHub)"},"url":"${{ steps.cpr.outputs.pr_url }}"},{"type":"button","text":{"type":"plain_text","emoji":true,"text":":eye: Voir la preview (Netlify)"},"style":"primary","url":"https://preview-pullrequest-${{steps.cpr.outputs.pr_number}}--geotribu-preprod.netlify.app/"}]}]}' diff --git a/.mailmap b/.mailmap index ed6e7dcef9..4dcb3ce330 100644 --- a/.mailmap +++ b/.mailmap @@ -78,6 +78,7 @@ Lilan Morinon <16464382+utagawal@users.noreply.github.c Loïc Bartoletti Loïc Bartoletti Loïc Bartoletti +Loïc Bartoletti Maël Reboux Maël Reboux @@ -135,7 +136,8 @@ Thomas Gratier Thomas Michel <65945567+ThomasIdgeo@users.noreply.github.com> -Thomas Szczurek-Gayant <121474664+thomas-szczurek@users.noreply.github.com> +Thomas Szczurek-Gayant +Thomas Szczurek-Gayant <121474664+thomas-szczurek@users.noreply.github.com> Tristram Gräbener Tristram Gräbener diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d95252955b..56cc50e885 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -28,7 +28,7 @@ repos: - "--py39-plus" - repo: https://github.com/astral-sh/ruff-pre-commit - rev: "v0.5.6" + rev: "v0.6.3" hooks: - id: ruff args: diff --git a/config/plugins_redirections.yml b/config/plugins_redirections.yml index 9058cdc0af..b6c1dde32e 100644 --- a/config/plugins_redirections.yml +++ b/config/plugins_redirections.yml @@ -865,6 +865,7 @@ redirects: team/acha.md: team/aurelien-chaumet.md team/avha.md: team/adrien-van-hamme.md team/avan.md: team/arnaud-vandecasteele.md + team/avdc.md: team/arnaud-vandecasteele.md team/bmer.md: team/boris-mericskay.md team/credits.md: about/credits.md team/cros.md: team/cedric-rossi.md @@ -914,8 +915,13 @@ redirects: # divers (typos, changement de date...) articles/2010/2010-12-13_imagemap_baselayers_v2.md: articles/2010/2010-12-13_imagimap_baselayers_v2.md + rdp/2013/rdp_2013-01-26.md: rdp/2013/rdp_2013-01-25.md + rdp/2013/rdp_2013-02-02.md: rdp/2013/rdp_2013-02-01.md + rdp/2013/rdp_2013-07-13.md: rdp/2013/rdp_2013-07-12.md + rdp/2015/rdp_2015-03-16.md: rdp/2015/rdp_2015-03-13.md rdp/2015/rdp_2015-05-16.md: rdp/2015/rdp_2015-05-15.md rdp/2015/rdp_2015-09-21.md: rdp/2015/rdp_2015-09-25.md - rdp/2013/rdp_2013-07-13.md: rdp/2013/rdp_2013-07-12.md + rdp/2015/rdp_2015-11-30.md: rdp/2015/rdp_2015-12-11.md articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-01-annonce.md: articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md articles/2024/2024-07-18_de-la-tolerance-en-sig-geometrie-02-calculs-intersects-qgis-pas-bons.md: articles/2024/2024-07-18_de-la-tolerance-en-sig-geometrie-01-calculs-intersects-qgis-pas-bons.md + articles/2010/2010-08-25_interroger_geoserver_en_python_grace_a_gconfig.md: articles/2010/2010-08-25_interroger_geoserver_en_python_grace_a_gsconfig.md diff --git a/content/articles/2010/2010-02-02_ski_iphone_cartographie.md b/content/articles/2010/2010-02-02_ski_iphone_cartographie.md index c9cbe42b73..7e025c466f 100644 --- a/content/articles/2010/2010-02-02_ski_iphone_cartographie.md +++ b/content/articles/2010/2010-02-02_ski_iphone_cartographie.md @@ -7,6 +7,7 @@ categories: comments: true date: 2010-02-02 description: "Ski, iPhone et cartographie" +icon: material/ski tags: - cartographie - iPhone @@ -21,7 +22,7 @@ tags: ![icône ski](https://cdn.geotribu.fr/img/logos-icones/divers/ski.png "icône ski"){: .img-thumbnail-left } -Bon je ne vais pas vous raconter mes vacances, ce n'est pas le but de ce site - bonne neige ceci dit :-) , mais en tant qu'utilisateur d'iPhone je me suis décidé à tester des applications carto gratuites pour le ski. En effet, l'iPhone possède un récepteur GPS et on peut se servir dans l'AppleStore pour essayer différents produits. +Bon je ne vais pas vous raconter mes vacances, ce n'est pas le but de ce site - bonne neige ceci dit :slight_smile:, mais en tant qu'utilisateur d'iPhone je me suis décidé à tester des applications carto gratuites pour le ski. En effet, l'iPhone possède un récepteur GPS et on peut se servir dans l'AppleStore pour essayer différents produits. ---- diff --git a/content/articles/2021/2021-02-09_statistiques_twitter.md b/content/articles/2021/2021-02-09_statistiques_twitter.md index 8c569af075..19652a4546 100644 --- a/content/articles/2021/2021-02-09_statistiques_twitter.md +++ b/content/articles/2021/2021-02-09_statistiques_twitter.md @@ -6,7 +6,8 @@ categories: - article comments: true date: 2021-02-09 -description: 'Récupérer des données sociales de Twitter, les préparer et les représenter est assez simple, grâce à trois bibliothèques Python : Twint, Pandas et Plolty. L''exemple développé ici s''appuie sur les statistiques autour des GeoRDP et articles parus dans GeoTribu en 2020' +description: "Récupérer des données sociales de Twitter, les préparer et les représenter est assez simple, grâce à trois bibliothèques Python : Twint, Pandas et Plolty. L'exemple développé ici s'appuie sur les statistiques autour des GeoRDP et articles parus dans GeoTribu en 2020" +icon: material/twitter image: https://cdn.geotribu.fr/img/articles-blog-rdp/articles/stats_twitter/geotribu_stats_twitter.png tags: - Geotribu diff --git a/content/articles/2021/2021-04-01_qtribu_plugin_qgis_geotribu.md b/content/articles/2021/2021-04-01_qtribu_plugin_qgis_geotribu.md index 2c4ad037ad..940c23cdec 100644 --- a/content/articles/2021/2021-04-01_qtribu_plugin_qgis_geotribu.md +++ b/content/articles/2021/2021-04-01_qtribu_plugin_qgis_geotribu.md @@ -6,7 +6,8 @@ categories: - article comments: true date: 2021-04-01 -description: 'Présentation du plugin de Geotribu pour QGIS : QTribu. Inutile donc forcément indispensable.' +description: "Présentation du plugin de Geotribu pour QGIS : QTribu. Inutile donc forcément indispensable." +icon: material/puzzle-heart-outline image: https://cdn.geotribu.fr/img/projets-geotribu/plugin_qtribu/qtribu_article_displayed.png license: default tags: diff --git a/content/articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md b/content/articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md index 70ef3cfb35..bde3598c8d 100644 --- a/content/articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md +++ b/content/articles/2024/2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md @@ -48,9 +48,9 @@ Dans les chapitres suivants, nous explorerons ensemble : - [Et dans les bases de données ? Comparaisons de SQL Server, Oracle et PostGIS](./2024-08-08_de-la-tolerance-en-sig-geometrie-04-postgis-oracle-ms-sql-server.md). - [Utilisation de la topologie : est-ce que la topologie peut nous sauver ?](./2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md) - [Approche alternative : utilisation de SFCGAL pour des calculs plus robustes.](./2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md) -- Et chez la concurrence, ça se passe comment ? -- Algorithmes et code : comment cela fonctionne-t-il ? Cette partie sera optionnelle, pour ceux ne voulant pas voir de code. -- La conclusion : comment arrêter de trop penser et vivre une vie meilleure ! +- [Et chez les proprios, ça se passe comment ?](./2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md) +- [Algorithmes et code : comment cela fonctionne-t-il ? Cette partie sera optionnelle, pour ceux ne voulant pas voir de code.](./2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md) +- [La conclusion : comment arrêter de trop penser et vivre une vie meilleure !](./2024-09-26_de-la-tolerance-en-sig-geometrie-09-conclusions.md "Conclusions") Êtes-vous prêts pour l'aventure ? Sortons nos SIG ! diff --git a/content/articles/2024/2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md b/content/articles/2024/2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md index ca975612fe..6fbd94f12d 100644 --- a/content/articles/2024/2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md +++ b/content/articles/2024/2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md @@ -88,7 +88,7 @@ Ainsi, nous allons passer de : ![GRASS line overlay clean](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/grass_select_line_clean_points.svg){: .img-center loading=lazy } -Maintenant, on regarde si notre fonction v.select avec `intersects` fonctionne. +Maintenant, on regarde si notre fonction `v.select` avec `intersects` fonctionne. Hourra ! @@ -210,6 +210,9 @@ En réalité, pas totalement, mais j'ai volontairement arrondi à trois chiffres Pourquoi ai-je fait ça ? Marre de me trimbaler autant de chiffres. Et, puis, est-ce vraiment utile d'avoir autant de chiffres après la virgule ? :wink: +[6 : _beyond the comma_ avec SFCGAL :fontawesome-solid-forward-step:](./2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md "SFCGAL pour des calculs géométriques robustes"){: .md-button } +{: align=middle } + {% include "licenses/beerware.md" %} diff --git a/content/articles/2024/2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md b/content/articles/2024/2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md index 02085de761..da06651c04 100644 --- a/content/articles/2024/2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md +++ b/content/articles/2024/2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md @@ -8,7 +8,7 @@ categories: comments: true date: 2024-08-22 description: "Sixième partie du tour d'horizon des SIG sur les dessous des calculs géométriques : utilisation de SFCGAL pour des calculs plus robustes" -icon: material/vector-polygon-variant +icon: material/decimal-comma-decrease image: https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_06_sfcgal.png license: beerware robots: index, follow @@ -29,8 +29,21 @@ Pour cela, laissez-moi introduire [SFCGAL](https://sfcgal.gitlab.io/SFCGAL/). ![Série d'été 2024 de Loïc Bartoletti - Les Géométries et les SIG : SFCGAL - Crédits : Sylvain Beorchia](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_06_sfcgal.png){: .img-center loading=lazy } +[Le dossier :octicons-move-to-start-16:](./2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md "De la tolérance en SIG : le dossier"){: .md-button } +[5 : topologie vs spaghetti :fontawesome-solid-backward-step:](./2024-08-15_de-la-tolerance-en-sig-geometrie-05-topologie-forces-et-limites.md "Topologie ; forces et limites"){: .md-button } +{: align=middle } + +[Commenter cet article :fontawesome-solid-comments:](#__comments "Aller aux commentaires"){: .md-button } +{: align=middle } + +---- + +## SFCGAL ? + Il s'agit d'une bibliothèque logicielle C++ sous licence [LGPL2+](https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html) construite comme une surcouche de [CGAL](https://www.cgal.org/) avec pour objectif de supporter l'[ISO 19107:2013](https://www.iso.org/fr/standard/26012.html) et la norme OGC [Simple Features Access](https://www.opengeospatial.org/standards/sfa/) 1.2 de l'OGC pour les opérations en 3D. +![logo SFCGAL](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/sfcgal.webp){: .img-center loading=lazy } + Concrètement, SFCGAL fournit des types de géométries et des opérations conformes aux normes, auxquels on accède via ses API [C](https://sfcgal.gitlab.io/SFCGAL/doxygen/group__capi.html) ou [C++](https://sfcgal.gitlab.io/SFCGAL/doxygen/group__public__api.html). Par exemple, PostGIS utilise l'API C pour exposer certaines fonctions de SFCGAL dans les bases de données spatiales (cf. [manuel de PostGIS](https://postgis.net/docs/reference.html#reference_sfcgal)). @@ -45,6 +58,8 @@ On utilisera SFCGAL de deux façons, pour comparer leurs résultats : - avec Python - et avec PostGIS. +---- + ## Python avec PySFCGAL [PySFCGAL](https://gitlab.com/sfcgal/pysfcgal) est une interface Python pour la bibliothèque SFCGAL, en cours de développement et de packaging. À défaut d'avoir une application `sfcgalop` à la `geosop` (au moment de la publication de l'article, celle-ci est en cours de développement) l'interface Python permet de faire des calculs plus facilement qu'en C ou C++. Promis, c'est « lisible » comme code. @@ -147,6 +162,9 @@ Il existerait une façon de rendre le calcul correct dans PostGIS avec SFCGAL, m Malgré les problèmes potentiels de précision dans son utilisation dans PostGIS, SFCGAL reste un outil précieux. Son principal atout réside dans ses fonctionnalités avancées en 2D et 3D, absentes de GEOS/PostGIS natif. Par ailleurs, ces erreurs ne sont pas systématiques et dépendent des données et opérations effectuées. +[7 : La gestion propriétaire de la géométrie : ESRI et FME :fontawesome-solid-forward-step:](./2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md "Gestion de la précision géométrique dans Esri et FME"){: .md-button } +{: align=middle } + {% include "licenses/beerware.md" %} diff --git a/content/articles/2024/2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md b/content/articles/2024/2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md new file mode 100644 index 0000000000..78b0141d34 --- /dev/null +++ b/content/articles/2024/2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md @@ -0,0 +1,221 @@ +--- +title: "La gestion propriétaire de la géométrie : ESRI et FME" +subtitle: "Série : De la tolérance en SIG - chapitre 7" +authors: + - Loïc Bartoletti +categories: + - article +comments: true +date: 2024-08-29 +description: "Septième et avant-dernière partie du tour d'horizon des SIG sur les dessous des calculs géométriques : un petit tour chez ESRI et FME." +icon: simple/esri +image: https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_07_esri_fme.png +license: beerware +robots: index, follow +tags: + - analyse + - ArcGIS + - ESRI + - FME + - géométrie +--- + +# Et chez les proprios, ça se passe comment ? + +On ne va pas tous les faire, mais seulement deux un peu connus et installés parfois à côté de QGIS comme logiciels SIG secondaires :wink:. + +Le premier sera FME, une sorte de boîte à outils de QGIS et l'autre ArcGIS Pro, le concurrent payant de GRASS/QGIS. + +![Série d'été 2024 de Loïc Bartoletti - Les Géométries et les SIG : ESRI & FME - Crédits : Sylvain Beorchia](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_07_esri_fme.png){: .img-center loading=lazy } + +Cet article est la septième partie de la série d'été sur la gestion de la géométrie dans les SIG. + +[Le dossier :octicons-move-to-start-16:](./2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md "De la tolérance en SIG : le dossier"){: .md-button } +[6 : SFCGAL pour les calculs robustes :fontawesome-solid-backward-step:](./2024-08-22_de-la-tolerance-en-sig-geometrie-06-sfcgal.md "SFCGAL"){: .md-button } +{: align=middle } + +[Commenter cet article :fontawesome-solid-comments:](#__comments "Aller aux commentaires"){: .md-button } +{: align=middle } + +---- + +## FME + +![logo FME](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/FME.png){: .img-thumbnail-left } + +Pour FME, pas de blabla. J'insère les WKB[^wkt_wkb], je fais un test d'intersection et je regarde si les points intersectent `line` et `base`. + +Vous pouvez trouver le fichier [fmw sur mon github](https://github.com/lbartoletti/lbartoletti.github.io/blob/master/assets/2024_intersection_intersects/data/fme_test_intersects.fmw) + +Et le résultat : + +![FME test intersects](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/fme_test_intersects.png){: .img-center loading=lazy } + +KO ! + +FME utilise, et contribue, aux outils open source. Néanmoins, même si le résultat est le même qu'avec GEOS, ce n'est pas cette bibliothèque qui est utilisée, mais une de leur conception. Encore une fois, le problème n'est donc pas GEOS. + +---- + +## ESRI ArcGIS Pro + +![logo ArcGIS Pro](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/arcgis_pro.png){: .img-thumbnail-left } + +Comme pour QGIS, nous allons tester notre problème de deux façons : par les traitements via une couche SIG et directement avec le WKB[^wkt_wkb]. + +### Utilisation du ShapeFile + +Sauf erreur de ma part, ArcGIS ne sait pas ouvrir les fichiers GeoPackage. Qu'importe, nous utiliserons le bon vieux ShapeFile qui sera importé dans une GeoDatabase. + +Afin de réaliser le calcul de l'intersection, nous utilisons l'outil [Pairwise Intersect](https://pro.arcgis.com/en/pro-app/latest/tool-reference/analysis/pairwise-intersect.htm). + +Contrairement à ce que j'ai pu faire pour QGIS, je ne montre pas les formulaires graphiques, mais le code qu'exécute ArcGIS. + +En entrée `in_features`, on donne nos deux couches `line` et `base`. On sait que l'on va avoir des points, donc on déclare le type de sortie comme `POINT`. + +```python +arcpy.analysis.PairwiseIntersect( + in_features="line;base", + out_feature_class=r"C:\Users\xxx\AppData\Local\Temp\ArcGISProTemp37912\Sans titre\Default.gdb\line_PairwiseIntersect", + join_attributes="ALL", + cluster_tolerance=None, + output_type="POINT" +) +``` + +Je passe les étapes pour l'extraction du WKB et WKT[^wkt_wkb], dont voici les résultats : + +- `0104000000020000000101000000e034efc8c83c3e4120166a8166d55341010100000040a4df9e8f3c3e416054525379d55341` +- `MultiPoint ((1981640.78490000218153 5199258.02210000157356262),(1981583.62060000002384186 5199333.30189999938011169))` + +ArcGIS nous sort un résultat légèrement différent. Testons avec l'autre outil pour les intersections : [Intersect](https://pro.arcgis.com/en/pro-app/latest/tool-reference/analysis/intersect.htm) + +```python +arcpy.analysis.Intersect( + in_features="line #;base #", + out_feature_class=r"C:\Users\xxx\AppData\Local\Temp\ArcGISProTemp37912\Sans titre\Default.gdb\line_Intersect1", + join_attributes="ALL", + cluster_tolerance=None, + output_type="POINT" +) +``` + +- `01040000000200000001010000008016d99e8f3c3e416054525379d553410101000000e034efc8c83c3e4120166a8166d55341` +- `MultiPoint ((1981583.62049999833106995 5199333.30189999938011169),(1981640.78490000218153 5199258.02210000157356262))` + +Un résultat également légèrement différent, mais proche de celui que nous obtenons avec les autres SIG. +Que se passe-t-il ici ? + +ArcGIS utilise, pour tous les calculs, une notion que l'on retrouve parfois dans les SIG OpenSource, celui de résolution et tolérance. +On peut la modifier en passant en paramètres des valeurs XY. Voici les requêtes et les résultats avec une valeur de 0.00001 mm. + +```python +with arcpy.EnvManager(XYResolution="0.00001 Millimeters", XYTolerance="0.00001 Millimeters"): + arcpy.analysis.PairwiseIntersect( + in_features="line;base", + out_feature_class=r"C:\Users\xxx\AppData\Local\Temp\ArcGISProTemp37912\Sans titre\Default.gdb\line_PairwiseIntersect1", + join_attributes="ALL", + cluster_tolerance=None, + output_type="POINT" + ) +``` + +- `MultiPoint ((1981640.78490600734949112 5199258.02208840474486351),(1981583.6205737441778183 5199333.30187807604670525))` +- `0104000000020000000101000000a099efc8c83c3e417ce5698166d553410101000000c0ebdd9e8f3c3e416cf8515379d55341` + +Ah, on retrouve nos petits ! Du moins, l'écart a été réduit. + +L'équivalent de notre sélection par localisation se fait comme suit : + +```python +arcpy.management.SelectLayerByLocation( + in_layer="line_PairwiseIntersect1;pariwiseIntersect_tolerance;lineIntersect", + overlap_type="INTERSECT", + select_features="line", + search_distance=None, + selection_type="NEW_SELECTION", + invert_spatial_relationship="NOT_INVERT" +) +``` + +Avec une distance de recherche (tolérance) + +```python +arcpy.management.SelectLayerByLocation( + in_layer="line_PairwiseIntersect1;pariwiseIntersect_tolerance;lineIntersect", + overlap_type="INTERSECT", + select_features="line", + search_distance="0.000000001 Millimeters", + selection_type="NEW_SELECTION", + invert_spatial_relationship="NOT_INVERT" +) +``` + +Dans les deux cas, ArcGIS sélectionne les points d'intersection. C'est donc un bon point pour eux. + +### Via le WKB et ArcPy + +Dans la partie suivante, nous allons regarder comment cela se passe, en utilisant directement les fonctions de base. + +```python +import binascii +# on importe le WKB de base +base = arcpy.FromWKB(binascii.unhexlify('0102000000050000007997c6b68d3c3e4139eb62c260d55341ac9ea7316a3c3e41cbeb40e073d55341403e0bfbc33c3e41b3fc06f380d55341387a2a800c3d3e41f256b8176dd553417997c6b68d3c3e4139eb62c260d55341')) +# on importe le WKB de line +line = arcpy.FromWKB(binascii.unhexlify('010200000002000000ea9c6d2b873c3e41a03d941b7cd5534133db7796ce3c3e413fba569864d55341')) +# calcul du point d'intersection en WKT +base.intersect(line, 1).WKT +# 'MULTIPOINT ((1981583.6207275391 5199333.3018798828), (1981640.7850952148 5199258.0220947266))' +# en WKB +base.intersect(line, 1).WKB +# bytearray(b'\x01\x04\x00\x00\x00\x02\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\xe8\x9e\x8f<>A\x00\x00RSy\xd5SA\x01\x01\x00\x00\x00\x00\x00\xfc\xc8\xc8<>A\x00\x00j\x81f\xd5SA') +# avec la conversion pour l'afficher en hexa +binascii.hexlify(base.intersect(line, 1).WKB) +# b'01040000000200000001010000000000e89e8f3c3e410000525379d5534101010000000000fcc8c83c3e4100006a8166d55341' +``` + +Maintenant, regardons les relations spatiales entre notre résultat `result` et les [géométries](https://pro.arcgis.com/en/pro-app/latest/arcpy/classes/geometry.htm) `base` et `line`. +On utilisera : disjoint, contains, crosses, equals, overlaps, touches et whitin ; ce dernier étant notre intersects. + +Base : + +```python +result.disjoint(base) +# False +``` + +```python +result.contains(base), result.crosses(base), result.equals(base), result.overlaps(base), result.touches(base), result.within(base) +# (False, False, False, False, False, True) +``` + +Line : + +```python +result.disjoint(line) +# False +``` + +```python +result.contains(line), result.crosses(line), result.equals(line), result.overlaps(line), result.touches(line), result.within(line) +# (False, False, False, False, False, True) +``` + +On obtient bien le résultat souhaité. En fait, vous l'aurez peut-être compris en filigrane, ArcGIS ne propose pas un calcul "strict" comme les autres, mais bien quelque chose de particulier. Il est "tolérant". + +[8 : Algorithmes géométriques et code :fontawesome-solid-forward-step:](./2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md "Algorithmes géométriques et code : comment cela fonctionne-t-il ?"){: .md-button } +{: align=middle } + + + +{% include "licenses/beerware.md" %} + + + +[^wkt_wkb]: formats standards de représentation des géométries : + + - **WKB (Well-Known Binary)** : Le WKB est un format binaire utilisé pour représenter des objets géométriques de manière compacte et efficace, couramment utilisé dans les bases de données géospatiales pour le stockage et l'échange de données géographiques. + - **WKT (Well-Known Text)** : Le WKT est un format texte utilisé pour représenter des objets géométriques de manière lisible par l'humain. Il est souvent utilisé pour le partage et l'affichage de données géographiques. + + Pour plus d'informations, consultez la page [Wikipedia](https://fr.wikipedia.org/wiki/Well-known_text). + diff --git a/content/articles/2024/2024-09-03_nouvelle-fenetre-qtribu.md b/content/articles/2024/2024-09-03_nouvelle-fenetre-qtribu.md new file mode 100644 index 0000000000..304b56a4f6 --- /dev/null +++ b/content/articles/2024/2024-09-03_nouvelle-fenetre-qtribu.md @@ -0,0 +1,117 @@ +--- +title: Cherchez et contribuez à Geotribu depuis QGIS +subtitle: La porte ouverte à toutes les qontributions +authors: + - Geotribu + - Guilhem Allaman +categories: + - article +comments: true +date: 2024-09-03 +description: "Une nouvelle fenêtre des contenus Geotribu dans le plugin QGIS QTribu, qui permet d'accéder et de contribuer aux contenus du site" +icon: material/window-closed-variant +image: +license: beerware +robots: index, follow +tags: + - Geotribu + - QGIS + - news + - plugin +--- + +# Cherchez et contribuez à Geotribu depuis QGIS + +:calendar: Date de publication initiale : {{ page.meta.date | date_localized }} + +T'as découvert un super géo-outil et t'aimerais faire profiter ta découverte au plus grand nombre ? +T'es tombé sur un super article dans une autre langue et t'aimerais rendre cet article disponible pour les francophones ? +Tu travailles sur un projet sympa et t'aimerais le présenter et le diffuser ? +T'as participé à une conférence ou un géo-évènement et t'aimerais partager aux autres ce que t'as appris ? +T'as envie d'évoluer dans ton job en montrant ce que tu sais faire ? +T'as envie de fanfaronner à la machine à café (ou sur le slack/IRC, faut vivre avec son temps !) parce que ton nom est incrusté dans QGIS ? +T'as envie de partager tous les bons plans géo de ta région ? +Tu t'ennuies un peu à la plage et l'horizon bleu de la mer t'inspire ? +Tu trouves que les flux RSS et plus généralement les mails et les newsletters c'est trop de la BAL ? +T'as loupé ta dernière séance chez ton/ta *PSIG*[^1] et tu ressens le besoin de te confier ? +T'en as un peu marre du tutoiement récurrent ? + +Vous êtes au bon endroit. Eh mais ce serait pas un topito des raisons de contribuer à Geotribu ? Oui ! Mais pas seulement : surtout pas besoin de cliquer sur [ce lien](https://theuselessweb.com/), c'est ici que ça se passe ! + +Les contenus et contributions de Geotribu sont maintenant disponibles dans [QGIS](https://www.qgis.org), au travers d'une nouvelle fenêtre du [plugin QTribu](https://plugins.qgis.org/plugins/qtribu/), le plugin pour garder le Qontact. + +## Plugin QTribu + +![logo QGIS](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/qgis.png "logo QGIS"){: .img-thumbnail-left } + +Présentée un 1er avril par [Julien](../../team/julien-moura.md) au travers de [cet article](../2021/2021-04-01_qtribu_plugin_qgis_geotribu.md), l'extension `QTribu` est disponible dans QGIS via [le dépôt officiel](https://plugins.qgis.org/plugins/qtribu/) : + +![fenêtre du gestionnaire des extensions QGIS avec QTribu sélectionnée](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/qtribu-qgis-plugin.webp){: .img-center loading=lazy } + +## Fenêtre des contenus + +La fenêtre pour lister et rechercher parmi les contenus de Geotribu est disponible dans le menu `Internet`, puis `Qtribu` > `Rechercher dans les contenus` : + +![fenêtre des contenus Geotribu](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/qtribu-nouvelle-fenetre.webp){: .img-center loading=lazy } + +Les articles et GeoRDP peuvent être filtrés par auteur/ice, par mot-clé ou via une recherche texte. + +Sous le capot, c'est le [JSON feed de Geotribu](https://geotribu.fr/feed_json_created.json) qui est utilisé afin de récupérer les 50 derniers contenus, articles et GeoRDP, puis les afficher. + +## Les contenus de Geotribu + +À ce moment-là, il peut être judicieux de faire un petit rappel sur les contenus de Geotribu auxquels tout un chacun peut participer, via un [ticket Github](https://github.com/geotribu/website/issues/new/choose) ou donc via le plugin QGIS `QTribu`, et qui peuvent être de deux natures : + +- une news/brève pour une GeoRDP. Généralement plutôt courte, il s'agit de décrire une actualité géomatique pouvant être de différent type : sortie d'un logiciel, nouvelle version d'un outil, sortie d'un article, annonce ou rétrospective sur un évènement géo, actualité OpenStreetMap ...etc etc Il y a même une rubrique "Divers" pour les news qui ne rentrent dans aucune case, c'est libre et seulement limité par votre imagination ! [Le site de contribution](https://contribuer.geotribu.fr/rdp/add_news/) explique la démarche + +- un article. Pour celles et ceux qui pensent que c'est la taille qui compte, c'est l'occasion de s'étendre davantage (certaines mauvaises langues diraient "tartiner"), illustré avec des images, des bouts de code et autres, offrant ainsi la possibilité de montrer l'utilisation ou la découverte d'un outil, un partage d'expérience, un récapitulatif illustré d'un évènement, une présentation d'un projet auquel vous participez, ou non... etc [Le site de contribution](https://contribuer.geotribu.fr/articles/workflow/) explique la démarche + +Et tout ceci sans pression et dans la bonne humeur ! Il est même possible d'insérer des blagues un peu douteuses, comme par exemple : + +- mon premier est un langage de programmation assez utilisé dans les SIG. Il s'agit également d'un serpent :snake: +- mon second peut être vectoriel, et peut également être utilisé en toiture +- mon tout contient du liquide pour graisser les chaînes de vélo, en Alsace +- :question: Je suis je suis je suis ? + +![Julien Lepers - Je suis je suis ?](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/julien_lepers_je_suis.webp){: .img-center loading=lazy } + +??? question "Réponse" + Un python tuile !! + +## Send news + +Revenons à nos moutons, et à nos actions de contribution dans le plugin QGIS QTribu : l'action `Proposer une news` vous ouvrira un formulaire pour saisir une news à destination d'une future GeoRDP (menu `Internet` > `QTribu`) : + +![formulaire de saisie d'une news](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/qtribu-news.webp){: .img-center loading=lazy } + +Le bouton `Envoyer` vous conduira directement sur les rails d'une issue GitHub paramétrée et remplie comme il faut ! + +![gif conducteur à toute berzingue](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/gif-drive.gif){: .img-center loading=lazy } + +## Propositions d'articles + +L'action `Proposer un article` vous ouvrira un formulaire pour rédiger une ébauche d'article : + +![formulaire de saisie d'un article](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/qtribu-article.webp){: .img-center loading=lazy } + +Le bouton `Envoyer` vous conduira directement sur les rails d'une issue GitHub paramétrée et remplie comme il faut ! + +![gif cycliste à toute berzingue](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/gif-bicycle.gif){: .img-center loading=lazy } + +## Autres nouveautés de Geotribu + +Parmi les autres évolutions récentes de Geotribu, nous pouvons citer : + +- une [nouvelle page](https://geotribu.fr/team/) qui liste les membres ainsi que les contributeur·rices +- plus de qualitay dans l'automatisation de la chaîne de publication des contenus +- bientôt un [plugin QField](https://www.opengis.ch/2024/06/18/supercharge-your-fieldwork-with-qfields-project-and-app-wide-plugins/) ? +- et bientôt d'autres trucs marrants :wink: :smile_cat: + +![un petit chat trop 'gnon qui dit "Miaou" dans QGIS avec le plugin Geotribu](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/qtribu_nouvelle_fenetre/geotricat_qgis_meow.webp) + + +[^1]: PSIG : psy des SIG, profession réglementée + + + +{% include "licenses/beerware.md" %} diff --git a/content/articles/2024/2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md b/content/articles/2024/2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md new file mode 100644 index 0000000000..fab6f41fe5 --- /dev/null +++ b/content/articles/2024/2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md @@ -0,0 +1,365 @@ +--- +title: "Algorithmes géométriques et code : comment cela fonctionne-t-il ?" +subtitle: "Série : De la tolérance en SIG - chapitre 8" +authors: + - Loïc Bartoletti +categories: + - article +comments: true +date: 2024-09-05 +description: "Huitième partie du tour d'horizon des SIG sur les dessous des calculs géométriques : algorithmes et code" +icon: material/code-block-tags +image: https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_08_algos.png +license: beerware +robots: index, follow +tags: + - algorithmes + - analyse + - géométrie + - python + - SFCGAL +--- + +# Algorithmes géométriques et code : comment cela fonctionne-t-il ? + +:calendar: Date de publication initiale : {{ page.meta.date | date_localized }} + +![logo console terminal](https://cdn.geotribu.fr/img/logos-icones/divers/ligne_commande.png){: .img-thumbnail-left } + +Maintenant que l'on a regardé comment sont gérées les opérations géométriques sous le capot de différents logiciels SIG, essayons de comprendre comment se code concrètement une formule mathématique. En somme, codons notre propre algorithme de calcul géométrique ! + +!!! info "Disclaimer" + Cet article s'adresse à tous les géomaticiens, quel que soit leur niveau de compétence informatique. Cependant, ceux qui sont déjà familiers avec les erreurs comme `#!python 0.1 + 0.2 != 0.3` ne trouveront peut-être pas de nouvelles informations ici. Encore une fois, j'essaie de vulgariser. Si une version plus détaillée vous intéresse, je peux essayer d'en faire une. + +![Série d'été 2024 de Loïc Bartoletti - Les Géométries et les SIG : Algorithmes - Crédits : Sylvain Beorchia](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_08_algos.png){: .img-center loading=lazy } + +Cet article est la huitième partie de la série d'été sur la gestion de la géométrie dans les SIG. + +[Le dossier :octicons-move-to-start-16:](./2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md "De la tolérance en SIG : le dossier"){: .md-button } +[7 : gestion propriétaire de la géométrie : ESRI et FME :fontawesome-solid-backward-step:](./2024-08-29_de-la-tolerance-en-sig-geometrie-07-esri-fme.md "Gestion de la géométrie dans ESRI et FME"){: .md-button } +{: align=middle } + +[Commenter cet article :fontawesome-solid-comments:](#__comments "Aller aux commentaires"){: .md-button } +{: align=middle } + +---- + +## Un triangle ne manque pas d'aire + +Ceci dit, comment qu'on calcule si un point C est sur un segment AB ? On calcule l'aire du triangle ABC ! + +Dit autrement, avec un peu plus de formalisme mathématique, pour déterminer si un point \( C \) est sur une droite définie par deux points \( A \) et \( B \), on peut utiliser la géométrie vectorielle. Voici une méthode simple pour le faire : + +1. **Coordonnées des points** : supposons que les coordonnées des points \( A \), \( B \) et \( C \) soient respectivement \( (x_A, y_A) \), \( (x_B, y_B) \) et \( (x_C, y_C) \). + +1. **Vecteur AB et AC** : calculons les vecteurs \( \overrightarrow{AB} \) et \( \overrightarrow{AC} \) : + + - \( \overrightarrow{AB} = (x_B - x_A, y_B - y_A) \) + - \( \overrightarrow{AC} = (x_C - x_A, y_C - y_A) \) + +1. **Déterminant** : calculons le déterminant des vecteurs \( \overrightarrow{AB} \) et \( \overrightarrow{AC} \). Ce déterminant est donné par : + + \[ + \text{D} = (x_B - x_A) \cdot (y_C - y_A) - (y_B - y_A) \cdot (x_C - x_A) + \] + +1. **Vérification** : + + - Si \( \text{D} = 0 \), alors les points \( A \), \( B \) et \( C \) sont colinéaires, ce qui signifie que \( C \) est sur la droite \( AB \). + - Si \( \text{D} \neq 0 \), alors \( C \) n'est pas sur la droite \( AB \). + +## Exemple + +Supposons que les coordonnées soient : + +- \( A = (1, 2) \) +- \( B = (4, 6) \) +- \( C = (2, 3) \) + +Calculons les vecteurs : + +- \( \overrightarrow{AB} = (4 - 1, 6 - 2) = (3, 4) \) +- \( \overrightarrow{AC} = (2 - 1, 3 - 2) = (1, 1) \) + +Calculons le déterminant : + +\[ +\text{D} = 3 \cdot 1 - 4 \cdot 1 = 3 - 4 = -1 +\] + +Puisque \( \text{D} \neq 0 \), le point \( C \) n'est pas sur la droite \( AB \). + +Voici une implémentation simple en Python : + +```python title="Calcul aire et orientation d'un triangle" +def orient2d(x_a: float, y_a: float, x_b: float, y_b: float, x_c: float, y_c: float): + """Calcule le double de l'aire du triangle formé par les points a, b et c. + Si le résultat est positif, les points sont orientés dans le sens antihoraire. + Si le résultat est négatif, les points sont orientés dans le sens horaire. + Si le résultat est nul, les points sont alignés. + """ + return (x_b - x_a) * (y_c - y_a) - (y_b - y_a) * (x_c - x_a) + +def shoelace_area(x_a: float, y_a: float, x_b: float, y_b: float, x_c: float, y_c: float): + """Calcul de l'aire en utilisant la formule de la shoelace.""" + area = 0.5 * (x_a * (y_b - y_c) + x_b * (y_c - y_a) + x_c * (y_a - y_b)) + return area + +# Exemple d'utilisation +x_a, y_a = 1, 2 +x_b, y_b = 4, 6 +x_c, y_c = 2, 3 + +area = shoelace_area(x_a, y_a, x_b, y_b, x_c, y_c) +orient = orient2d(x_a, y_a, x_b, y_b, x_c, y_c) +print(f"L'aire du triangle est : {area}") +# L'aire du triangle est : -0.5 +print(f"L'orientation du triangle ABC est : {orient}") +# L'orientation du triangle ABC est : -1 +``` + +Le code retourne un nombre négatif ; l'aire étant la moitié de l'orientation. + +Si l'on inverse A et B, comme suit : + +```python +area = shoelace_area(x_b, y_b, x_a, y_a, x_c, y_c) +orient = orient2d(x_b, y_b, x_a, y_a, x_c, y_c) +print(f"L'aire du triangle est : {area}") +# L'aire du triangle est : 0.5 +print(f"L'orientation du triangle BAC est : {orient}") +# L'orientation du triangle BAC est : 1 +``` + +On retrouve un nombre positif. Le point C est de l'autre côté de l'axe AB, dit autrement, AB et C ne sont pas colinéaires. + +```python title="Exemple d'utilisation avec des points colinéaires" +x_a, y_a = 1, 1 +x_b, y_b = 2, 2 +x_c, y_c = 3, 3 + +area = shoelace_area(x_b, y_b, x_a, y_a, x_c, y_c) +orient = orient2d(x_b, y_b, x_a, y_a, x_c, y_c) +print(f"L'aire du triangle est : {area}") +# L'aire du triangle est : 0.0 +print(f"L'orientation du triangle BAC est : {orient}") +# L'orientation du triangle BAC est : 0 +``` + +```python title="Exemple d'utilisation avec des points colinéaires" +x_a, y_a = 0.1, 0.1 +x_b, y_b = 0.2, 0.2 +x_c, y_c = 0.3, 0.3 + +area = shoelace_area(x_b, y_b, x_a, y_a, x_c, y_c) +orient = orient2d(x_b, y_b, x_a, y_a, x_c, y_c) +print(f"L'aire du triangle est : {area}") +# L'aire du triangle est : -1.734723475976807e-18 +print(f"L'orientation du triangle BAC est : {orient}") +# L'orientation du triangle BAC est : 0.0 +``` + +Comme sur ma machine, vous devriez avoir une « blague ». L'aire n'est pas exactement égale à 0, mais proche de 0. + +Quelles sont donc les problèmes de cette « blague » ? + +## L'utilisation des nombres flottants + +Si l'on admet que C est le point d'intersection d'un segment avec AB, alors, en théorie, les lignes se croisent en un point bien défini : C. Cependant, en pratique, les ordinateurs effectuent des calculs en utilisant une représentation numérique finie qui peut introduire de petites erreurs. Voici pourquoi cela se produit : + +Les ordinateurs utilisent majoritairement une représentation en [virgule flottante](https://fr.wikipedia.org/wiki/Virgule_flottante) pour stocker des nombres réels. C'est même la norme pour les coordonnées de nos géométries. Ce fameux double que l'on retrouve de partout. Toutefois son utilisation peut introduire des erreurs d'arrondi. J'ai indiqué une opération en introduction, 0.1 + 0.2 != 0.3. Comme 0.3 ne peut pas être représenté exactement cela conduit à des approximations. C'est un problème connu des informaticiens, au point d'avoir [son propre site](https://0.30000000000000004.com/). +De même, je ne peux qu'encourager la lecture de l'article [What Every Computer Scientist Should Know About Floating-Point Arithmetic](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html). + +Il existe d'autres nombres sur des ordinateurs. Vous avez pu voir que 1 + 2 est bien égal à 3. Tandis que 0.1 + 0.2 n'est pas égal à 0.3. + +Les opérations sur les entiers sont toujours justes, dans leurs limites. Alors pourquoi ne pas utiliser que des entiers ? + +C'est plus ou moins ce qui est fait par d'autres bibliothèques de calculs. On pensera notamment à SFCGAL, mais comme on l'a vu, cela ne fait pas tout. L'enregistrement se faisant en double, la conversion va introduire des erreurs ; on détaillera cela plus bas. + +## L'accumulation d'erreurs + +Lors de calculs complexes, ces petites erreurs d'arrondi peuvent s'accumuler et devenir significatives. + +Lors du calcul de l'intersection de deux lignes, plusieurs opérations arithmétiques sont nécessaires. Chaque opération peut introduire une petite erreur. + +Des solutions comme GEOS ou Clipper (pour SAGA), repose sur des calculs bien plus robustes que notre exemple ; d'ailleurs, elles passent également par des entiers. Le calcul de l'intersection va être juste - à la précision du float. + +## Comparaisons de précision + +En réalité, ce qu'il manque dans nos SIG, c'est de la tolérance. + +Lorsqu'on vérifie si un point est sur une ligne, la précision des calculs peut affecter le résultat. + +Une des règles lorsque l'on utilise des nombres à virgule est de calculer suivant une valeur. On ne doit jamais comparer directement un nombre flottant. C'est à dire, éviter : + +```python +0.1 + 0.2 == 0.3 +``` + +mais plutôt utiliser des fonctions réalisant une comparaison approchée comme : + +```python +def compare_doubles(a, b, tolerance=1e-9): + """ + Compare deux nombres à virgule flottante avec une tolérance donnée. + :param a: Premier nombre à comparer + :param b: Deuxième nombre à comparer + :param tolerance: Tolérance pour la comparaison (par défaut 1e-9) + :return: True si les nombres sont égaux dans la tolérance, False sinon + """ + return abs(a - b) <= tolerance + +# Exemple d'utilisation +a = 0.1 + 0.2 +b = 0.3 +tolerance = 1e-9 + +if compare_doubles(a, b, tolerance): + print(f"Les nombres {a} et {b} sont égaux avec une tolérance de {tolerance}.") +else: + print(f"Les nombres {a} et {b} ne sont pas égaux avec une tolérance de {tolerance}.") +``` + +Vous devriez avoir cette sortie : + +`Les nombres 0.30000000000000004 et 0.3 sont égaux avec une tolérance de 1e-09.` + +Pour une étude plus approfondie, je vous encourage à lire l'article [Comparing Two Floating-Point Numbers +](https://embeddeduse.com/2019/08/26/qt-compare-two-floats/). + +Comme vous avez pu le deviner, c'est ce que fait ArcGIS. +Dans plusieurs endroits de nos SIG, il existe des comparaisons floues, peut-être que les prochaines versions de GEOS intègreront cette tolérance pour les relations. :wink: + +## Retour sur SFCGAL + +On a vu que SFCGAL est la seule bibliothèque à donner le bon résultat pour intersects, mais seulement en python. Avec PostGIS, il retourne faux comme GEOS, pourquoi ? + +SFCGAL, n'utilise pas les flottants, mais une autre arithmétique. Pour rappel, notre code exemple est : + +```python title="Intersection avec PySFCGAL" +from pysfcgal import sfcgal + +base = sfcgal.read_wkb('0102000000050000007997c6b68d3c3e4139eb62c260d55341ac9ea7316a3c3e41cbeb40e073d55341403e0bfbc33c3e41b3fc06f380d55341387a2a800c3d3e41f256b8176dd553417997c6b68d3c3e4139eb62c260d55341') +line = sfcgal.read_wkb('010200000002000000ea9c6d2b873c3e41a03d941b7cd5534133db7796ce3c3e413fba569864d55341') + +result = base.intersection(line) +# Affiche du WKT avec 10 décimales +print(result.wktDecim(10)) +# MULTIPOINT((1981583.6205737418 5199333.3018780742),(1981640.7849060092 5199258.0220883982)) +print(base.intersects(result)) +# True +print(line.intersects(result)) +# True +``` + +On a le résutat souhaité. Maintenant, essayons de reproduire ce qu'il se passe dans PostGIS. +Dans notre requête, on calcule le point d'intersection avec CG_Intersection. A la fin de son traitement, elle va convertir sa géométrie, et ses nombres, en [double PostGIS](https://github.com/postgis/postgis/blob/d29ba84cb05988ab0aa1b2da3eef90108dfae1db/sfcgal/lwgeom_sfcgal.c#L559). Cette étape est la cause du problème. Cette conversion revient à cela en Python : + +```python +# Création d'un point np en passant par des floats +p = sfcgal.lib.sfcgal_geometry_collection_geometry_n(result._geom, 0) +# conversion du nombre gmp en double +x = sfcgal.lib.sfcgal_point_x(p) +y = sfcgal.lib.sfcgal_point_y(p) +# création du point avec ces doubles +np = sfcgal.Point(x, y) +print(base.intersects(np)) +# False +print(line.intersects(np)) +# False +``` + +Et, voilà, « l'imprécision » des doubles nous donne ce mauvais résultat. + +Une solution, qui n'est pas élégante et donc pas encore implémentée, serait d'avoir des fonctions qui s'enchaînent et ne fassent pas continuellement des va-et-vient entre les nombres. Avec une fonction CG_IntersectsIntersection comme suit, le résultat dans PostGIS sera juste. + +```c +PG_FUNCTION_INFO_V1(sfcgal_intersects_intersection); +Datum +sfcgal_intersects_intersection(PG_FUNCTION_ARGS) +{ + GSERIALIZED *input0, *input1; + GSERIALIZED *output; + LWGEOM *lwgeom; + bool intersect1, intersect2; + char *values[3]; + + sfcgal_geometry_t *geom0, *geom1; + sfcgal_geometry_t *sfcgal_result; + srid_t srid; + + sfcgal_postgis_init(); + + input0 = PG_GETARG_GSERIALIZED_P(0); + srid = gserialized_get_srid(input0); + input1 = PG_GETARG_GSERIALIZED_P(1); + geom0 = POSTGIS2SFCGALGeometry(input0); + PG_FREE_IF_COPY(input0, 0); + geom1 = POSTGIS2SFCGALGeometry(input1); + PG_FREE_IF_COPY(input1, 1); + + sfcgal_result = sfcgal_geometry_intersection(geom0, geom1); + output = SFCGALGeometry2POSTGIS(sfcgal_result, 0, srid); + lwgeom = lwgeom_from_gserialized(output); + intersect1 = sfcgal_geometry_intersects(geom0, sfcgal_result); + intersect2 = sfcgal_geometry_intersects(geom1, sfcgal_result); + values[0] = intersect1 ? "t" : "f"; + values[1] = intersect2 ? "t" : "f"; + values[2] = lwgeom_to_hexwkb_buffer(lwgeom, WKB_EXTENDED); + lwpgnotice( + "%s %s %s", + values[0], values[1], values[2]); + + sfcgal_geometry_delete(geom0); + sfcgal_geometry_delete(geom1); + + sfcgal_geometry_delete(sfcgal_result); + + PG_RETURN_POINTER(intersect1 && intersect2); +} +``` + +Plus généralement, vous pouvez exécuter ce [mini script python](https://github.com/lbartoletti/lbartoletti.github.io/blob/master/assets/2024_intersection_intersects/data/intersects_intersection_numbers.py) qui résume ce que l'on a vu. +Il réalise notre calcul d'intersects/intersection sur 2 segments en utilisant des nombres floats, Decimal et Fraction de Python. + +## Webographie + +En plus des liens vers les documentations que j'ai indiquées par moments, voici quelques liens permettant de compléter ou d'approfondir le sujet. + +Tout d'abord, rendons à César ce qui est à César, cette suite d'articles, n'est qu'une explication illustrée de la [FAQ](https://locationtech.github.io/jts/jts-faq.html) de JTS ; qui est à l'origine de GEOS. Mais, comme personne ne lit la documentation :wink: autant remettre le lien [ici](https://locationtech.github.io/jts/jts-faq.html#D8). + +Sur la robustesse de l'intersection des segments, vous pouvez commencer par cet échange [stack](https://cs.stackexchange.com/questions/119760/robust-two-lines-segments-intersection-point-in-2d) et ensuite lire et utiliser le code de Shewchuk sur la robustesse des calculs avec des nombres flottants : + +- +- +- + +Des versions modernes ont été reprises comme qui a également fait un article complet sur ce concept. + +JTS/GEOS utilise une version modifiée de ces calculs. Afin de ne pas allonger un article déjà bien long. Je n'ai pas montré d'exemple avec ces fonctions, mais le résultat est le même. + +Dans nos SIG, voici quelques liens vers les codes sources utilisés : + +QGIS + +- Les fonctions sur les calculs géométriques de [QGIS](https://github.com/qgis/QGIS/blob/0c41c22343ded7c6b6a7be0d382477128e837bd9/src/core/geometry/qgsgeometryutils_base.cpp) + +Grass + +Le manuel de [v.clean](https://grass.osgeo.org/grass83/manuals/v.clean.html) qui utilise une fonction `split` qui va découper le segment avec une [distance](https://github.com/OSGeo/grass/blob/9cb4745b6c4abfeaf542ef05468060d68af72703/vector/v.clean/split.c). Pour être exhaustif, j'aurais pu indiquer que ce traitement peut légèrement modifier les géométries. + +SAGA + +- Le calcul de [l'intersection](https://github.com/saga-gis/saga-gis/blob/0e66e5a768d771052553f270c0ffe24efda1d0a8/saga-gis/src/saga_core/saga_api/geo_functions.cpp#L280) +- La fonction [line crossings](https://github.com/saga-gis/saga-gis/blob/0e66e5a768d771052553f270c0ffe24efda1d0a8/saga-gis/src/tools/shapes/shapes_lines/line_crossings.cpp#L226) +- et la bibliothèque [Clipper2](https://github.com/AngusJohnson/Clipper2) qui est utilisée par SAGA. +Enfin, GEOS : +- Le test d'[intersects](https://github.com/libgeos/geos/blob/a8d2ed0aba46f88f9b8987526e68eea6565d16ae/src/algorithm/LineIntersector.cpp#L222) +- Le calcul [orient2d](https://github.com/libgeos/geos/blob/a8d2ed0aba46f88f9b8987526e68eea6565d16ae/src/algorithm/CGAlgorithmsDD.cpp#L54) où l'on aperçoit un premier test rapide et si la robustesse n'est pas assez bonne, on passe sur une autre [arithmétique](https://github.com/libgeos/geos/blob/a8d2ed0aba46f88f9b8987526e68eea6565d16ae/include/geos/math/DD.h). + +[9 : 5 conseils pour bien vivre géométriquement (le 4è va vous étonner) :fontawesome-solid-forward-step:](./2024-09-26_de-la-tolerance-en-sig-geometrie-09-conclusions.md "Conclusions et conseils de vie"){: .md-button } +{: align=middle } + + + +{% include "licenses/beerware.md" %} diff --git a/content/articles/2024/2024-09-26_de-la-tolerance-en-sig-geometrie-09-conclusions.md b/content/articles/2024/2024-09-26_de-la-tolerance-en-sig-geometrie-09-conclusions.md new file mode 100644 index 0000000000..1e527dac00 --- /dev/null +++ b/content/articles/2024/2024-09-26_de-la-tolerance-en-sig-geometrie-09-conclusions.md @@ -0,0 +1,111 @@ +--- +title: "5 conseils pour bien vivre géométriquement" +subtitle: "Série : De la tolérance en SIG - chapitre 9" +authors: + - Loïc Bartoletti +categories: + - article +comments: true +date: 2024-09-26 +description: "Neuvième et dernière partie du tour d'horizon des SIG sur les dessous des calculs géométriques : 5 conseils pour vivre votre meilleure vie géométrique." +icon: material/meditation +image: https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_09_conclusion.png +license: beerware +robots: index, follow +tags: + - géométrie + - lifestyle + - open source + - topologie +--- + +# 5 conseils pour arrêter de trop penser et vivre une vie meilleure ! + +:calendar: Date de publication initiale : {{ page.meta.date | date_localized }} + +![Globe cerveau](https://cdn.geotribu.fr/img/internal/icons-rdp-news/mentale.png){: .img-thumbnail-left } + +On a souvent ces interrogations sur les « irrégularités » rencontrées lors des opérations courantes dans les SIG : pourquoi les accrochages dans QGIS ne se positionnent-ils pas toujours exactement sur la géométrie ? Pourquoi les calculs de superposition manquent-ils de précision ? Et pourquoi les résultats peuvent-ils être incohérents ? + +Plutôt que de se perdre dans une quête de surprécision, voici les 5 conseils pour améliorer votre expérience SIG et vivre une vie meilleure. + +Derrière cette expression « incitaclic », voici en réalité quelques conseils ou expériences que j'ai pu rencontrer sur différents projets. + +![Série d'été 2024 de Loïc Bartoletti - Les Géométries et les SIG : conclusions - Crédits : Sylvain Beorchia](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/splash_serie_geometrie_09_conclusion.png){: .img-center loading=lazy } + +Cet article est la neuvième et dernière partie de la série d'été sur la gestion de la géométrie dans les SIG. + +[Le dossier :octicons-move-to-start-16:](./2024-07-16_de-la-tolerance-en-sig-geometrie-00-annonce.md "De la tolérance en SIG : le dossier"){: .md-button } +[8 : Algorithmes géométriques et code :fontawesome-solid-backward-step:](./2024-09-05_de-la-tolerance-en-sig-geometrie-08-algorithmes-code.md "Algorithmes géométriques et code : comment cela fonctionne-t-il ?"){: .md-button } +{: align=middle } + +[Commenter cet article :fontawesome-solid-comments:](#__comments "Aller aux commentaires"){: .md-button } +{: align=middle } + +---- + +## Arrêtez de chercher la surprécision + +!!! quote "Conseil n°1 : Le prix de la rigueur" + La rigueur à tout prix peut devenir une source de frustration. Acceptez qu’une légère imprécision est inévitable et concentrez-vous sur l’essentiel. + +On est dans un monde infini, mais avec des ressources finies. Quelques arrondis ne font pas de mal. De combien de chiffres après la virgule avez-vous réellement besoin ? Votre précision c'est le décimètre, le centimètre, le millimètre, au-delà ? Vous avez besoin de combien de chiffres pour [Pi](https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/). Combien d'approximations réalisez-vous au quotidien, tout en étant précis ? Il est actuellement 21 h 02 ou simplement 21 h ? Quand vous réalisez un trajet de chez vous aux rencontres QGIS, vous êtes précis à la seconde, à la minute, au quart d'heure ? Bref, la précision dépend de votre contexte et il y a fort à parier que vous allez rarement être en dessous de 10^-3 sur du cartésien et 10^-8 en géodésique. + +![xkcd 2170 - Credits : Randall Monroe](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/xkcd_coordinate_precision.webp){: .img-center loading=lazy } + +---- + +## Gérez la tolérance + +!!! quote "Conseil n°2 : À chaque calcul, sa tolérance" + Utilisez des tolérances appropriées dans vos calculs pour minimiser les effets des erreurs d'arrondi. Définissez des tolérances adaptées à l’échelle et aux objectifs de votre projet. + +En lien avec le nombre de chiffres après la virgule, vous pouvez également ajouter une tolérance. En France, les gestionnaires de réseaux savent qu'on les caractérise suivant 3 classes : A, B ou C. 10 cm, 40 cm, etc. Une bonne pratique est de se demander si le point n'est pas à une distance d'environ X cm. Sur PostGIS, cela va se caractériser par l'utilisation de `ST_DWithin` plutôt qu'un `ST_Intersects`. + +---- + +## Utilisez la topologie + +!!! quote "Conseil n°3 : faut-il vraiment vous faire un topo ?" + La topologie permet de gérer les relations spatiales et de corriger les erreurs géométriques. Les outils topologiques garantissent que les entités spatiales respectent certaines règles, améliorant ainsi la cohérence des données. + +Si vraiment, vous souhaitez que les nœuds soient identiques, la topologie est là pour vous. Mais, attention, vous avez vu, cela transforme légèrement la donnée en entrée. Par ailleurs, suivant les outils que vous utilisez, elle peut ne pas être respectée lors d'éditions dans d'autres outils que ceux sur lesquels vous allez travailler. D'où l'idée de déporter l'intelligence en base : [Thick database (base épaisse)](https://img1.lemondeinformatique.fr/fichiers/telechargement/plaidoyer-de-frederic-brouard-sur-le-concept-de-bases-de-donnees-epaisses.pdf). + +---- + +## Connaissez les autres nombres + +!!! quote "Conseil n°4 : comptez-vous !" + Comprenez comment les nombres sont représentés dans les ordinateurs. Cela aide à anticiper et à gérer les erreurs de calcul, notamment les différences entre les nombres en virgule flottante et les autres. + +Tout est de la faute des nombres en virgule flottante ! Vous pouvez utiliser d'autres outils, mais attention, la conversion peut engendrer des erreurs. Sans aller jusqu'au détail de ces nombres, il faudrait retenir que 0.1 + 0.2 != 0.3. + +---- + +## Investissez dans l'évolution des outils + +!!! quote "Conseil n°5 : calculez sur le temps long." + Soutenez le développement et l'amélioration des outils SIG, surtout les projets open source comme ceux de l'OSGeo ! + +On ne le dira jamais assez, mais si un fonctionnement ou un bug vous dérange donnez-vous les moyens de le corriger. **Investissez dans vos outils SIG !** Du temps et/ou de l'argent pour consolider les bases techniques sur lesquelles votre travail ou vos missions reposent. Rappelez-vous que même les logiciels propriétaires s'inspirent voire s'appuient sur les briques libres, ouvertes et gratuites (à l'usage) que sont GEOS, GDAL, SFCGAL, QGIS, SAGA, GRASS et d'autres encore. Ça vaut également pour les demandes de fonctionnalités. + +---- + +## Conclusion finale + +!!! quote "Comprendre > penser" + La quête de la perfection numérique dans les SIG peut être frustrante. En adoptant une approche pragmatique et en comprenant les limites des calculs numériques, vous pouvez réduire le stress et améliorer votre efficacité. En acceptant ces réalités, vous pourrez arrêter de trop penser et commencer à vivre une vie meilleure, plus sereine et productive dans vos projets géospatiaux. + +C'est beau, hein ? + +En réalité, vivez vos SIG comme vous le voulez, mais ayez connaissance de leurs fonctionnements. Oui, leurs, car chacun peut vous donner des résultats plus ou moins différents. + +![Bannière 5 conseils pour bien vivre géométriquement](https://cdn.geotribu.fr/img/articles-blog-rdp/articles/2024/geometrie_tolerance_sig/bien_vivre_geometriquement.webp){: .img-center loading=lazy } + +J'espère que cette série d'articles vous a intéressé. D'autres sur la comparaison entre les outils devraient venir. + +Et pour finir, merci à mes relecteurs de Geotribu ([Michaël](../../team/michael-galien.md "Michaël Galien"), [Florian](../../team/florian-boret.md "Florian Boret"), [Guilhem](../../team/guilhem-allaman.md "Guilhem"), [Arnaud](../../team/arnaud-vandecasteele.md) et Julien), à [Sandro Santilli](https://www.osgeo.org/member/sandro-santilli/) (correction d'une erreur dans un code), [Martin Davis](https://wiki.osgeo.org/wiki/User:Mdavis) aka Dr. [JTS](https://www.osgeo.org/projects/jts/) (pour ses apports sur les « concurrents ») et tout ce qu'il a pu faire pour nos outils ! Et, enfin, merci à [Julien Moura](../../team/julien-moura.md "Julien Moura") qui a su être patient avant de voir la première phrase :grin:. + + + +{% include "licenses/beerware.md" %} diff --git a/content/rdp/2014/rdp_2014-08-22.md b/content/rdp/2014/rdp_2014-08-22.md index 25f98807d6..5b7c0ecea6 100644 --- a/content/rdp/2014/rdp_2014-08-22.md +++ b/content/rdp/2014/rdp_2014-08-22.md @@ -139,7 +139,7 @@ Pour finir, vous trouverez ce mois-ci dans le [dernier numéro de Beaux Arts Mag Perso, je ne me lasse pas des petites bandes dessinées de [XKCD](https://xkcd.com). Elles sont à la fois comiques, pertinentes et surtout bien réalisées. L'une des plus récentes est intéressante pour notre revue de presse car elle s'attache à la question de la représentation cartographique de la sécheresse en Californie selon différentes années. Pour les explications, je vous laisse le soin de lire le [billet associé](https://www.explainxkcd.com/wiki/index.php/1410) :wink: -Merci à Martin Hoffmann de nous avoir remonté cette info via le [formulaire de contribution]({{ config.extra.url_contribuer }}introduction/). +Merci à Martin Hoffmann de nous avoir remonté cette info via le [formulaire de contribution]({{ config.extra.url_contribuer }}). ![XKCD - California](https://cdn.geotribu.fr/img/articles-blog-rdp/capture-ecran/xkcd_california.png "XKCD - California"){: .img-center loading=lazy } diff --git a/content/rdp/2015/rdp_2015-12-11.md b/content/rdp/2015/rdp_2015-12-11.md index 15ce914965..8d8166b527 100644 --- a/content/rdp/2015/rdp_2015-12-11.md +++ b/content/rdp/2015/rdp_2015-12-11.md @@ -55,8 +55,7 @@ On n'en parle pas souvent dans nos colonnes et pourtant OsmAnd vaut le détour. Les dernières versions ont grandement améliorés l'interface utilisateur en proposant des menus plus clairs et plus intuitifs. D'ailleurs l'équipe sort [la version 2.2](http://osmand.net/blog?id=osmand-2-2-released) en proposant notamment un nouveau menu personnalisé. La recherche de POI et l'organisation des points favoris ont également été améliorées. Sur les plateformes de téléchargement, on trouve une version gratuite (limité à 10 cartes en téléchargement) et une payante pour les cartes en illimité, une façon de faire un don pour le développement. Moi, c'est fait, j'ai donné pour cet application ! -![OsmAnd](https://cdn.geotribu.fr/img/articles-blog-rdp/capture-ecran/ver_2_2_9.jpg "OsmAnd"){: loading=lazy width=300px } -{: align=middle } +![OsmAnd 2.2](https://cdn.geotribu.fr/img/articles-blog-rdp/capture-ecran/OsmAnd_version_2_2_9.jpg "OsmAnd"){: .img-center loading=lazy } ### Images satellite Sentinel-2 disponibles diff --git a/content/rdp/2020/rdp_2020-09-18.md b/content/rdp/2020/rdp_2020-09-18.md index 0c63fd1845..e84f52f686 100644 --- a/content/rdp/2020/rdp_2020-09-18.md +++ b/content/rdp/2020/rdp_2020-09-18.md @@ -45,7 +45,7 @@ Depuis la dernière  GeoRDP : - [article sur le web-scraping avec Scrapy](../../articles/2020/2020-09-08_web-scraping_scrapy_geotribu.md), avec l'exemple de la récupération des contenus de l'ancien site - [article sur la conversion HTML <--> Markdown](../../articles/2020/2020-09-11_html2markdown.md) avec l'exemple de la conversion à la volée d'un article du CNIG dans la continuité de l'article sur le web-scraping -- amélioration de notre [guide de contribution]({{ config.extra.url_contribuer }}introduction/) qui se consulte désormais en plusieurs étapes +- amélioration de notre [guide de contribution]({{ config.extra.url_contribuer }}) qui se consulte désormais en plusieurs étapes - [explications sur les règles et le système de validation de la syntaxe Markdown]({{ config.extra.url_contribuer }}guides/markdown_quality/) utilisée sur notre site - explications sur notre [moteur de rendu Markdown --> HTML]({{ config.extra.url_contribuer }}internal/markdown_engine/) diff --git a/content/rdp/2022/rdp_2022-12-16.md b/content/rdp/2022/rdp_2022-12-16.md index 2e240f4a51..28f5b8b4ee 100644 --- a/content/rdp/2022/rdp_2022-12-16.md +++ b/content/rdp/2022/rdp_2022-12-16.md @@ -38,7 +38,7 @@ On vous souhaite à toutes et tous de bonnes fêtes de fin d’année, il n’y N'hésitez pas à partager vos géo-cadeaux de Noël avec le hastag : #geocadeau [Commenter :fontawesome-solid-comments:](#__comments){: .md-button } -[Proposer :material-newspaper-plus:]({{ config.extra.url_contribuer }}rdp/add_news.md){: .md-button } +[Proposer :material-newspaper-plus:]({{ config.extra.url_contribuer }}rdp/add_news/){: .md-button } {: align=middle } ---- diff --git a/content/rdp/2024/rdp_2024-08-23.md b/content/rdp/2024/rdp_2024-08-23.md index c362dbdc4e..7cf8401c2c 100644 --- a/content/rdp/2024/rdp_2024-08-23.md +++ b/content/rdp/2024/rdp_2024-08-23.md @@ -14,6 +14,7 @@ tags: - AroundUs - BanqueDeFrance - BD + - GéoDataDays - GRASS - IGN - NullIsland @@ -63,7 +64,7 @@ La série d'été de [Loïc Bartoletti](../../team/loic-bartoletti.md) sur les g ![logo GRASS](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/grass.png "logo Grass"){: .img-thumbnail-left } -Avec plus de 520 changements, la nouvelle version, majeure, 8.4.0 de GRASS GIS apporte sont lot de modifications, dont : +Avec plus de 520 changements, la nouvelle version, majeure, 8.4.0 de GRASS GIS apporte son lot de modifications, dont : - Le terme "location" est remplacé par "project" dans l'interface et l'API - Simplification de la création de nouveaux projets en Python @@ -218,9 +219,7 @@ Le tout est propulsé par [OpenDataSoft](https://www.opendatasoft.com/fr/). Les données nuages de points du [programme LiDAR HD de l'IGN](https://geoservices.ign.fr/lidarhd) sont disponibles sur la région parisienne. L'occasion de découvrir [les lieux des épreuves de Jeux Olympiques](https://www.ign.fr/reperes/paris-2024-les-sites-des-epreuves-olympiques-reveles-par-lidar), de même que le beau bleu de la Seine qui donne envie de s'y baigner :yum: ! -![Écran du démonstrateur LiDAR HD sur Paris](https://cdn.geotribu.fr/img/articles-blog-rdp/capture-ecran/LiDAR_hd_paris.webp){: .img-center loading=lazy } - -[Le visualisateur](https://demo-lidar.ign.fr/) permet comme son nom l'indique de visualiser les données, à l'heure où les nuages de points sont disponibles pour environ une moitié de la France. Rappelons que l'avancement du programme peut être suivi via [la carte des acquisitions](https://macarte.ign.fr/carte/322ea69dab4c7e5afabc6ec7043b5994/acquisitionslidarhd) et [la carte des traitements](https://macarte.ign.fr/carte/28c909bde7d5a504c9e45178c8d363f4/traitementslidarhd). +[La visionneuse](https://diffusion-lidarhd.ign.fr/) permet de visualiser les emprises disponibles et télécharger les données, à l'heure où les nuages de points sont disponibles pour environ une moitié de la France. Rappelons que l'avancement du programme peut être suivi via [la carte des acquisitions](https://macarte.ign.fr/carte/322ea69dab4c7e5afabc6ec7043b5994/acquisitionslidarhd) et [la carte des traitements](https://macarte.ign.fr/carte/28c909bde7d5a504c9e45178c8d363f4/traitementslidarhd). ---- @@ -231,16 +230,18 @@ Les données nuages de points du [programme LiDAR HD de l'IGN](https://geoservic ![GeoDataDays](https://cdn.geotribu.fr/img/logos-icones/geodatadays.png "GeoDataDays"){: .img-thumbnail-left } On ne doute pas que la date est bien notée dans ton agenda. Tu as même déjà dû imprimer ton badge d'accès. - Bref, les GeoDataDays sont dans moins d'un mois, alors on te donne rendez-vous les 19 et 20 septembre à la Cité des Congrès de Nantes. -[Demandez l'programme !!!](https://www.geodatadays.fr/_medias/afigeo/files/GDD_2024/2024-GDD-LIVRETV12.pdf) +[:material-presentation-play: Demandez l'programme !!!](https://www.geodatadays.fr/_medias/afigeo/files/GDD_2024/2024-GDD-LIVRETV12.pdf){: .md-button } +{: align=middle } + +![GeoDataDays 2024 - Bannière](https://cdn.geotribu.fr/img/external/salons_conferences/geodatadays/2024/geodatadays_2024_banniere.webp){: .img-center loading=lazy } ---- ## Divers -### GDAL/OGR - Accroche ta tuque avec d’la broche ! +### GDAL/OGR - Attache ta tuque avec d’la broche ! ![Logo GDAL](https://cdn.geotribu.fr/img/logos-icones/logiciels_librairies/gdal.png "Logo GDAL"){: .img-thumbnail-left } diff --git a/requirements-insiders.txt b/requirements-insiders.txt index bfd2084e96..aaec5c3c9b 100644 --- a/requirements-insiders.txt +++ b/requirements-insiders.txt @@ -1,7 +1,7 @@ # Insiders # -------- -git+https://${GH_TOKEN_MATERIAL_INSIDERS}@github.com/squidfunk/mkdocs-material-insiders.git@9.5.31-insiders-4.53.12#egg=mkdocs-material +git+https://${GH_TOKEN_MATERIAL_INSIDERS}@github.com/squidfunk/mkdocs-material-insiders.git@9.5.36-insiders-4.53.13#egg=mkdocs-material # git+https://${GH_TOKEN_MATERIAL_INSIDERS}@github.com/squidfunk/mkdocs-material-insiders.git # social plugin requirements