23.1.15. Géométrie vectorielle¶
23.1.15.1. Ajouter les attributs de géométrie¶
Calcule les propriétés géométriques des entités dans une couche vectorielle et les inclut dans la couche de sortie.
Génère une nouvelle couche vectorielle avec le même contenu que la couche d’entrée, mais avec des attributs supplémentaires, contenant des mesures géométriques basées sur un SCR sélectionné.
Les attributs ajoutés à la table dépendent du type de géométrie et de la dimension de la couche d’entrée :
pour les couches point: coordonnées X (
xcoord), Y (ycoord), Z (zcoord) et/ou valeur M (mvalue)pour les couches ligne:
longueuret, pour les types de géométrie LineString et CompoundCurve, la caractéristiquesinuositéet distance droite (straightdis)pour les couches polygone:
périmètreetsurface
Default menu:
23.1.15.1.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Calculer en utilisant |
|
[enumeration] Par défaut : 0 |
Paramètres de calcul à utiliser pour les propriétés géométriques. Un des:
|
Ajout d’informations geom |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie (copie d’entrée avec géométrie). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.1.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Ajout d’informations geom |
|
[same as input] |
Copie de la couche vectorielle d’entrée avec l’ajout des champs de géométrie |
23.1.15.1.3. Code Python¶
Algorithm ID: qgis:exportaddgeometrycolumns
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.2. Agrégation¶
Créé une nouvelle couche en agrégeant les entités selon une expression de regroupement ( « group by » )
Les entités pour lesquelles l’agrégation retourne la même valeur sont regroupées.
Il est possible de regrouper toutes les entités en utilisant une valeur constante dans le « group by ». Par exemple : NULL
Il est aussi possible de regrouper suivant plusieurs champs à l’aide de fonctions Array, comme Array (« Colonne1 », « Colonne2 »).
Les géométries (lorsqu’elles sont présentes) sont agrégées en multi-géométries pour chaque groupe. Les attributs sont calculés avec une fonction d’agrégation propre à chacun.
Cet algorithme permet d’utiliser les fonctions d’agrégat par défaut du moteur d’expression QGIS.
Voir aussi
23.1.15.2.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
expression Group by |
|
[tablefield: any] Default: “NULL” |
Choisir le champ de regroupement. NULL pour grouper toutes les entités. |
Agrégats |
|
[list] |
Liste des définitions de champ de couche de sortie. Exemple de définition de champ: {“aggregate”: “sum”, “delimiter”: “,”, “input”: “ $area”, “length”: 10, “name”: “totarea”, “precision”: 0, “type”: 6} Par défaut, la liste contient tous les champs de la couche d’entrée. Dans l’interface graphique, vous pouvez modifier ces champs et leurs définitions, et vous pouvez également:
Pour chacun des champs à partir desquels vous souhaitez récupérer des informations, vous devez définir les éléments suivants:
|
Charger les champs à partir de la couche |
GUI only |
[vector: any] |
Vous pouvez charger des champs d’une autre couche et les utiliser pour l’agrégation |
Agrégé |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie (agrégée)
L’encodage du fichier peut également être modifié ici. |
23.1.15.2.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Agrégé |
|
[same as input] |
Couche vectorielle multigeométrie avec les valeurs agrégées |
23.1.15.2.3. Code Python¶
Algorithm ID: qgis:aggregate
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.3. Limite¶
Renvoie pour chaque entité la ou les limites de celle ci (c’est-à-dire la limite topologique de la géométrie).
Uniquement pour les couches de polygones et de lignes.
Pour les géométries de polygone, la limite est constituée de toutes les lignes constituant les anneaux du polygone.
Fig. 23.26 Limites (ligne en pointillés noirs) de la couche de polygones source¶
Pour les géométries de lignes, les limites sont leurs points d’extrémité.
Fig. 23.27 Couche limite (points rouges) pour les lignes. En jaune une entite sélectionnée.¶
23.1.15.3.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
limite |
|
[vector: point, line] Par défaut: |
Spécifiez la couche de sortie (limite). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.3.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
limite |
|
[vector: point, line] |
Limites de la couche d’entrée (point pour la ligne et ligne pour le polygone) |
23.1.15.3.3. Code Python¶
Algorithm ID: qgis:boundary
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.4. Emprise¶
Calcule le rectangle d’encombrement (emprise) pour chaque entité de la couche en entrée. Polygones et lignes sont possibles.
Fig. 23.28 Les lignes noires représentent les rectangles d’encombrement de chaque entité.¶
Permet la modification de la couche source
Voir aussi
23.1.15.4.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Bornes |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (boîte englobante). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.4.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Bornes |
|
[vector: polygon] |
Boîtes de délimitation de la couche d’entrée |
23.1.15.4.3. Code Python¶
Algorithm ID: qgis:boundingboxes
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.5. Tampon¶
Crée un tampon de largeur fixe pour chaque entité de la couche.
Il est possible d’utiliser une distance négative pour les couches d’entrée de polygone. Dans ce cas, le tampon se traduira par un polygone plus petit (retrait).
Fig. 23.29 Buffer (en jaune) de points, ligne et polygone¶
Permet la modification de la couche source
Default menu:
Voir aussi
buffer à distance variable, Buffer multi-anneaux (distance constante), buffer à largeur variable (par valeur M)
23.1.15.5.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Distance |
|
[number Par défaut : 10.0 |
Distance tampon (à partir de la limite de chaque entité). Vous pouvez utiliser le bouton Données définies à droite pour choisir un champ à partir duquel le rayon sera calculé. De cette façon, vous pouvez avoir un rayon différent pour chaque entité (voir buffer à distance variable). |
Segments |
|
[number] Par défaut: 5 |
Indique le nombre de segments de ligne à utiliser pour approcher un quart de cercle lors de la création de tampons arrondis |
** Style extrémité ** |
|
[enumeration] Par défaut : 0 |
Contrôle la façon dont les fins de ligne sont traitées dans le buffer. Un des:
Fig. 23.30 Style de terminaison rond, plat et carré¶ |
Jointure de style |
|
[enumeration] Par défaut : 0 |
Indique si les joints ronds, à angles droits ou biseautés doivent être utilisés lors du décalage des coins dans une ligne. Les options sont :
|
Limite d’onglet |
|
[number] Par défaut : 2.0 |
Contrôle la distance maximale à partir de la courbe de décalage à utiliser lors de la création d’une jointure en onglet (applicable uniquement aux styles de jointure en onglet). Minimum: 1. |
Dissoudre le résultat |
|
[boolean] Par défaut : Faux |
Dissolvez le tampon final. Si 
Fig. 23.31 Tampon standard (gauche) et tampon fusionné (droite)¶ |
Buffered |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.5.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vector: polygon] |
Couche de polygone de sortie (buffer) |
23.1.15.5.3. Code Python¶
Algorithm ID: qgis:buffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.6. Centroïdes¶
Crée une nouvelle couche de points, les points représentant les centroïdes des géométries de la couche d’entrée.
Le centroïde est un point unique représentant le barycentre (de toutes les parties) de l’entité, il peut donc être en dehors des bordures de l’entité. Mais peut également être un point sur chaque partie de l’entité.
Les attributs des points de la couche de sortie sont les mêmes que pour les entités d’origine.
Fig. 23.32 Les étoiles rouges représentent les centroïdes des caractéristiques de la couche d’entrée.¶
Permet la modification de la couche source
Default menu:
Voir aussi
23.1.15.6.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Créez un centroïde pour chaque partie |
|
[boolean Par défaut : Faux |
Si True (coché), un centroïde sera créé pour chaque partie de la géométrie |
** Centroids ** |
|
[vector: point] Par défaut: |
Spécifiez la couche de sortie (centroïde). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.6.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Centroids ** |
|
[vector: point] |
Couche vectorielle du point de sortie (centroïdes) |
23.1.15.6.3. Code Python¶
Algorithm ID: qgis:centroids
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.7. Vérifier la validité¶
Effectue un contrôle de validité sur les géométries d’une couche vectorielle.
Les géométries sont classées en trois groupes (valides, invalides et erreurs) et pour chaque groupe, une couche vectorielle avec ses caractéristiques est générée:
La couche Sortie valide contient uniquement les entités valides (sans erreurs topologiques).
La couche Sortie non valide contient toutes les entites non valides trouvées par l’algorithme.
La couche Sortie d’erreur est une couche de points qui pointe vers l’endroit où les entités non valides ont été trouvées.
Les tables d’attributs des couches générées contiendront des informations supplémentaires (« message » pour la couche error, « FID » et « _errors » pour la couche invalid et uniquement « FID » pour la couche valid):
La table attributaire de chaque couche vectorielle générée contiendra des informations supplémentaires (nombre d’erreurs trouvées et types d’erreur):
Fig. 23.33 Gauche: la couche d’entrée. À droite: la couche valide (vert), la couche invalide (orange)¶
Default menu:
Voir aussi
Correction des géométries et le plugin principal Extension Vérificateur de géométrie
23.1.15.7.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Méthode |
|
[enumeration] Par défaut : 2 |
Méthode à utiliser pour vérifier la validité. Options:
|
Ignorer l’auto-intersection de l’anneau |
|
[boolean] Par défaut : Faux |
Ignorez les anneaux qui se croisent lorsque vous vérifiez la validité. |
Sortie valide |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle pour contenir une copie des entités valides de la couche source. Un des:
L’encodage du fichier peut également être modifié ici. |
Sortie invalide |
|
[same as input] Par défaut: |
Couche vectorielle contenant une copie des entites non valides de la couche source avec le champ
L’encodage du fichier peut également être modifié ici. |
Sortie d’erreur |
|
[vector: point] Par défaut: |
Couche ponctuelle de la position exacte des problèmes de validité détectés avec le champ
L’encodage du fichier peut également être modifié ici. |
23.1.15.7.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nombre d’erreurs |
|
[number] |
Le nombre de géométries qui ont provoqué des erreurs. |
Sortie d’erreur |
|
[vector: point] |
Couche de points des positions exactes des problèmes de validité détectés avec le champ |
Nombre d’entités invalides |
|
[number] |
Le nombre de géométries non valides. |
Sortie invalide |
|
[same as input] |
Couche vectorielle contenant une copie des entites non valides de la couche source avec le champ |
Nombre d’entités valides |
|
[number] |
Le nombre de géométries valides. |
Sortie valide |
|
[same as input] |
Couche vectorielle contenant une copie des caractéristiques valides de la couche source. |
23.1.15.7.3. Code Python¶
Algorithm ID: qgis:checkvalidity
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.7.4. Types de messages d’erreur et leur signification¶
Message d’erreur |
Explication |
Exemple |
|---|---|---|
Point répété |
Cette erreur se produit lorsqu’un sommet donné est répété. |
|
Auto-intersection de l’anneau |
Cette erreur se produit lorsqu’une géométrie se touche et génère un anneau. |
|
Auto-intersection |
Cette erreur se produit lorsqu’une géométrie se touche. |
|
Erreur de validation de la topologie |
||
Le trou se trouve à l’extérieur de la coquille |
||
Les trous sont imbriqués |
||
L’intérieur est déconnecté |
||
Coquilles imbriquées |
Cette erreur se produit lorsqu’une géométrie de polygone se trouve au-dessus d’une autre géométrie de polygone. |
|
Anneaux en double |
Cette erreur se produit lorsque deux anneaux (extérieur ou intérieur) d’une géométrie de polygone sont identiques |
|
Trop peu de points dans le composant de géométrie |
||
Coordonnées invalides |
Pour une géométrie de point, cette erreur se produit lorsque la géométrie n’a pas de paire de coordonnées appropriée. La paire de coordonnées ne contient pas de valeur de latitude et de longitude dans cet ordre. |
|
L’anneau n’est pas fermé |
Message d’erreur |
Explication |
Exemple |
|---|---|---|
Le segment %1 de l’anneau %2 du polygone %3 coupe le segment %4 de l’anneau %5 du polygone %6 à %7 |
||
L’anneau %1 avec moins de quatre points |
||
L’anneau %1 n’est pas fermée |
||
Ligne %1 avec moins de deux points |
||
La ligne %1 contient 1%n nœud(s) en double sur %2 |
Cette erreur se produit lorsque des points consécutifs sur une ligne ont les mêmes coordonnées. |
|
Les segments %1 et %2 de la ligne %3 se croisent à %4 |
Cette erreur se produit lorsqu’une ligne s’entrecroise (deux segments de la ligne se croisent). |
|
Auto-intersection de l’anneau |
Cette erreur se produit lorsqu’un anneau/limite externe ou interne (îlot) d’une géométrie de polygone se coupe. |
|
L’anneau %1 du polygone %2 n’est pas dans l’anneau extérieur |
||
Le polygone %1 se trouve à l’intérieur du polygone %2 |
Cette erreur se produit lorsqu’une partie d’une géométrie MultiPolygone se trouve à l’intérieur d’un trou d’une géométrie MultiPolygon. |
|
23.1.15.8. Collecter les géométries¶
Prend une couche vectorielle et réunit ses géométries dans de nouvelles géométries multiparties.
Un ou plusieurs attributs peuvent être spécifiés pour collecter uniquement des géométries appartenant à la même classe (ayant la même valeur pour les attributs spécifiés), en variante, toutes les géométries peuvent être collectées.
Toutes les géométries de sortie seront converties en géométries multiples, même celles avec une seule partie. Cet algorithme ne dissout pas les géométries se chevauchant - elles seront rassemblées sans modifier la forme de chaque partie géométrique.
Voir les algorithmes «Convertir en multiparties» ou «Agrégat» pour des options alternatives.
Default menu:
Voir aussi
23.1.15.8.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Champs d’identifiant unique |
|
[champ: tout type] [liste] |
Choisissez un ou plusieurs attributs pour collecter les géométries |
Collecté |
|
[same as input] |
Couche vectorielle avec des géométries collectées |
23.1.15.8.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Collecté |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie pour les géométries collectées. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.8.3. Code Python¶
Algorithm ID: qgis:collect
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.9. Enveloppe concave (formes alpha)¶
Calcule l’enveloppe convexe des entités dans une couche de points en entrée.
Fig. 23.34 Coques concaves avec différents seuils (0,3, 0,6, 0,9)¶
23.1.15.9.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche de points d’entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Seuil |
|
[number] Default: 0.3 |
Nombre de 0 (enveloppe concave maximum) à 1 (enveloppe convexe) |
Autoriser les trous |
|
[boolean] Par défaut : Vrai |
Choisissez d’autoriser ou non les trous dans la coque concave finale |
Diviser la géométrie multipartie en géométries une seule partie |
|
[boolean] Par défaut : Vrai |
Cocher si vous voulez obtenir des géométries simples à la place des multiparties. |
Coque concave |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.9.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Coque concave |
|
[vector: polygon] |
Spécifiez la couche vectorielle de sortie |
23.1.15.9.3. Code Python¶
Algorithm ID: qgis:concavehull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.10. Enveloppe concave (voisin le plus proche)¶
Génère un polygone de coque concave à partir d’un ensemble de points. Si la couche d’entrée est une couche linéaire ou polygonal, il utilisera les sommets.
Le nombre de voisins à considérer détermine la concavité du polygone de sortie. Un chiffre plus bas donnera un polygone concave qui suit les points de très près, tandis qu’un chiffre plus élevé donnera une forme plus lisse. Le nombre minimum de points voisins à considérer est de 3. Une valeur égale ou supérieure au nombre de points donnera un polygone convexe.
Si un champ est sélectionné, l’algorithme regroupera les entités de la couche d’entrée ayant des valeurs uniques dans ce champ et générera des polygones individuels dans la couche de sortie pour chaque groupe.
Voir aussi
23.1.15.10.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Nombre de points voisins à considérer (un nombre inférieur est plus concave, un nombre plus élevé est plus lisse) |
|
[number] Default: 3 |
Détermine la concavité du polygone en sortie. Un petit nombre se traduira par une coque concave qui suit les points de très près, tandis qu’un nombre élevé rendra le polygone plus semblable à la coque convexe (si le nombre est égal ou supérieur au nombre d’entités, le résultat sera une enveloppe convexe). Valeur minimale: 3. |
Champ Optionnel |
|
[tablefield: any] Defaut: None |
Si spécifié, un polygone concave est généré pour chaque valeur unique du champ (en sélectionnant les entités utilisant cette valeur). |
Coque concave |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.10.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Coque concave |
|
[vector: polygon] |
Spécifiez la couche vectorielle de sortie |
23.1.15.10.3. Code Python¶
Algorithm ID: qgis:knearestconcavehull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.11. Convertir le type de géométrie¶
Génère une nouvelle couche basée sur une couche existante, avec un type de géométrie différent.
Toutes les conversions ne sont pas possibles. Par exemple, une ligne peut être convertie en un point, mais un point ne peut pas être converti en une ligne. Une ligne peut également être convertie en un polygone.
Voir aussi
23.1.15.11.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Nouveau type de géométrie |
|
[enumeration] Par défaut : 0 |
Type de géométrie à appliquer aux entités en sortie. Un des:
|
Converti |
|
[vector: any] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.11.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Converti |
|
[vector: any] |
Couche vectorielle de sortie - le type dépend des paramètres |
23.1.15.11.3. Code Python¶
Algorithm ID: qgis:convertgeometrytype
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.12. Enveloppe convexe¶
Calcule l’enveloppe convexe pour chaque entité dans une couche en entrée.
Voir l’algorithme “Géométrie de délimitation minimale” pour un calcul d’enveloppe convexe qui couvre la totalité de la couche ou des sous-ensembles groupés d’entités.
Fig. 23.35 Les lignes noires représentent les enveloppes convexes de chaque entité.¶
Permet la modification de la couche source
Default menu:
23.1.15.12.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Enveloppe convexe |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.12.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Enveloppe convexe |
|
[vector: polygon] |
La couche vectorielle de sortie (coque convexe) |
23.1.15.12.3. Code Python¶
Algorithm ID: qgis:convexhull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.13. Créer une couche à partir de l’étendue¶
Crée une nouvelle couche vectorielle qui contient une seule entité avec une géométrie correspondant à l’étendue de la couche d’entrée.
Il peut être utilisé dans les modèles pour convertir une étendue littérale (format xmin, xmax, ymin, ymax) en une couche qui peut être utilisée pour d’autres algorithmes qui nécessitent un entrée basée sur la couche.
Voir aussi
23.1.15.13.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extent (xmin, xmax, ymin, ymax) |
|
[emprise] |
Étendue d’entrée |
Extent |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.13.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extent |
|
[vector: polygon] |
Couche vectorielle de sortie (étendue) |
23.1.15.13.3. Code Python¶
Algorithm ID: qgis:extenttolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.14. Créer une couche à partir d’un point¶
Crée une nouvelle couche vectorielle qui contient une seule entité avec une géométrie correspondant à un paramètre de point. Il peut être utilisé dans les modèles pour convertir un point en une couche de points pour les algorithmes qui nécessitent une entrée basée sur une couche.
Voir aussi
23.1.15.14.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[coordinates] |
Point en entrée, y compris les informations du SCR (exemple: Si le SCR n’est pas fourni, le SCR du projet sera utilisé. Le point peut être spécifié en cliquant sur le canevas de la carte. |
Point |
|
[vector: point] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.14.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vector: point] |
Couche vectorielle du point de sortie contenant le point d’entrée. |
23.1.15.14.3. Code Python¶
Algorithm ID: qgis:pointtolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.15. Créer des buffer compensés¶
Crée des buffer en forme de coin à partir des points d’entrée.
Fig. 23.36 Buffer compensés¶
Les sorties natives de cet algorithme sont des géométries CurvePolygon, mais celles-ci peuvent être automatiquement segmentées en polygones en fonction du format de sortie.
23.1.15.15.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Azimut (degrés par rapport au nord) |
|
[number Par défaut : 0.0 |
Angle (en degrés) comme valeur médiane du coin |
Largeur de coin (en degrés) |
|
[number Par défaut: 45.0 |
Largeur (en degrés) du buffer. Le coin s’étendra jusqu’à la moitié de la largeur angulaire de chaque côté de la direction d’azimut. 
Fig. 23.37 Valeurs d’azimut et de largeur du buffer de coin¶ |
Rayon extérieur |
|
[number Par défaut : 1.0 |
La taille (longueur) extérieure du coin: la taille est définit du point source au bord de la forme du coin. |
Rayon intérieur Optionnel |
|
[number Par défaut : 0.0 |
Valeur du rayon intérieur. Si 0, le coin commencera à partir du point source. |
Buffers |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.15.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffers |
|
[vector: polygon] |
Couche vectorielle de sortie (tampon de coin) |
23.1.15.15.3. Code Python¶
Algorithm ID: qgis:wedgebuffers
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.16. Triangulation de Delaunay¶
Crée une couche de polygones avec la triangulation de Delaunay correspondant à la couche de points d’entrée.
Fig. 23.38 Triangulation de Delaunay sur les points¶
Default menu:
23.1.15.16.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Triangulation de Delaunay |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.16.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Triangulation de Delaunay |
|
[vector: polygon] |
La couche vectorielle de sortie (triangulation de Delaunay) |
23.1.15.16.3. Code Python¶
Algorithm ID: qgis:delaunaytriangulation
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.17. Supprimer les trous¶
Prend une couche de polygones et supprime les trous dans les polygones. Il crée une nouvelle couche vectorielle dans laquelle les polygones avec trous ont été remplacés par des polygones avec uniquement leur anneau externe. Les attributs ne sont pas modifiés.
Un paramètre de surface minimale facultatif permet de supprimer uniquement les trous inférieurs à un seuil de surface spécifié. Laisser ce paramètre à 0.0 entraîne la suppression de tous les trous.
Fig. 23.39 Avant et après le nettoyage¶
Permet la modification de la couche source
23.1.15.17.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Retirez les trous dont la surface est inférieure à Optionnel |
|
[number Par défaut : 0.0 |
Seuls les trous d’une surface inférieure à ce seuil seront supprimés. Si |
Nettoyé |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.17.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nettoyé |
|
[same as input] |
La couche vectorielle de sortie (nettoyée) |
23.1.15.17.3. Code Python¶
Algorithm ID: qgis:deleteholes
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.18. Densifier en nombre¶
Prend un polygone ou une couche de lignes et en génère un nouveau dans lequel les géométries ont un plus grand nombre de sommets que l’original.
Si les géométries ont des valeurs Z ou M présentes, celles-ci seront interpolées linéairement aux sommets ajoutés.
Le nombre de nouveaux sommets à ajouter à chaque segment est spécifié comme paramètre d’entrée.
Fig. 23.40 Les points rouges montrent les sommets avant et après la densification¶
Permet la modification de la couche source
Default menu:
Voir aussi
23.1.15.18.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Vertexs à ajouter |
|
[number] Par défaut : 1 |
Nombre de sommets à ajouter à chaque segment |
Densifié |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.18.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Densifié |
|
[same as input] |
La couche vectorielle de sortie (densifiée) |
23.1.15.18.3. Code Python¶
Algorithm ID: qgis:densifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.19. Densifier par intervalle¶
Prend un polygone ou une couche de lignes et en génère un nouveau dans lequel les géométries ont un plus grand nombre de sommets que l’original.
Les géométries sont densifiées en ajoutant des sommets supplémentaires placés régulièrement à l’intérieur de chaque segment afin que la distance maximale entre deux sommets ne dépasse pas la distance spécifiée.
Si les géométries ont des valeurs Z ou M présentes, celles-ci seront interpolées linéairement aux sommets ajoutés.
Exemple
Si vous spécifiez une distance de 3, le segment [0 0] -> [10 0] sera converti en [0 0] -> [2,5 0] -> [5 0] -> [7,5 0 ] -> [10 0], car 3 sommets supplémentaires sont nécessaires sur le segment et leur espacement à 2,5 incréments leur permet d’être régulièrement espacés sur le segment.
Fig. 23.41 Densifier la géométrie à un intervalle donné¶
Permet la modification de la couche source
Voir aussi
23.1.15.19.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Intervalle entre les sommets à ajouter |
|
[number Par défaut : 1.0 |
Distance maximale entre deux sommets consécutifs |
Densifié |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.19.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Densifié |
|
[same as input] |
La couche vectorielle de sortie (densifiée) |
23.1.15.19.3. Code Python¶
Algorithm ID: qgis:densifygeometriesgivenaninterval
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.20. Regrouper¶
Prend une couche vectorielle et combine ses entités dans de nouvelles entités. Un ou plusieurs attributs peuvent être spécifiés pour dissoudre des entités appartenant à la même classe (ayant la même valeur pour les attributs spécifiés), en variante toutes les entités peuvent être dissoutes en une seule entité.
Toutes les géométries en sortie seront converties en multigéométries. Dans le cas d’une couche de polygones, les frontières communes de polygones adjacents regroupés seront supprimées.
La table attributaire résultant aura les mêmes champs que la couche d’entrée. Les valeurs des champs de la couche de sortie seront celles de la première entité en entrée qui sera traitée.
Fig. 23.42 Regrouper la couche de polygones sur un attribut commun¶
Default menu:
Voir aussi
23.1.15.20.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Dissoudre le(s) champ(s) Optionnel |
|
[champ: tout type] [liste] Defaut: [] |
Les entités ayant la même valeur pour le ou les champ(s) spécifié(s) seront replacées par par une seule entité et leurs géométries seront fusionnées. Si aucun champ n’est fourni, toutes les entités sont dissoutes, ce qui entraîne une seule entité (en plusieurs parties). |
Dissous |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.20.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Dissous |
|
[same as input] |
La couche vectorielle de sortie avec des géométries dissoutes |
23.1.15.20.3. Code Python¶
Algorithm ID: qgis:dissolve
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.21. Drapé (régler la valeur z du raster)¶
Utilise des valeurs échantillonnées à partir d’une bande dans une couche raster pour définir la valeur Z pour chaque sommet se chevauchant dans la géométrie de l’entité. Les valeurs raster peuvent éventuellement être mises à l’échelle par une quantité prédéfinie.
Si des valeurs Z existent déjà dans la couche, elles seront remplacées par la nouvelle valeur. Si aucune valeur Z n’existe, la géométrie sera mise à niveau pour inclure la cote Z.
Voir aussi
23.1.15.21.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Couche raster |
|
[raster] |
Couche raster avec valeurs Z |
Numéro de bande |
|
[raster band] Par défaut : 1 |
La bande raster à partir de laquelle les valeurs Z |
Valeur pour nodata ou sommets non intersectés |
|
[number Par défaut : 0 |
Valeur à utiliser si le sommet n’intersecte pas (un pixel valide) le raster |
Facteur d’échelle |
|
[number Par défaut : 1.0 |
Valeur de mise à l’échelle: les valeurs de bande sont multipliées par cette valeur. |
Mis à jour |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (avec les valeurs Z de la couche raster). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.21.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mis à jour |
|
[same as input] |
La couche vectorielle de sortie avec les valeurs Z de la couche raster |
23.1.15.21.3. Code Python¶
Algorithm ID: qgis:setzfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.22. Supprimer les valeurs M/Z.¶
Supprime les valeurs M (mesure) ou Z (altitude) des géométries en entrée.
Voir aussi
23.1.15.22.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle d’entrée avec des valeurs M ou Z |
Supprimer valeurs M |
|
[boolean] Par défaut : Faux |
Supprime les valeurs M des géométries |
Supprimer les valeurs Z |
|
[boolean] Par défaut : Faux |
Supprime les valeurs Z des géométries |
** Z/M supprime** |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.22.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Z/M supprime** |
|
[same as input] |
La couche vectorielle de sortie (identique à la couche d’entrée, sauf que les dimensions M et/ou Z ont été supprimées des géométries). |
23.1.15.22.3. Code Python¶
Algorithm ID: qgis:dropmzvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.23. Élimine les polygones sélectionnés¶
Combine les polygones sélectionnés de la couche d’entrée avec certains polygones adjacents en effaçant leur limite commune. Le polygone adjacent peut être celui qui a la plus grande ou la plus petite surface ou celui qui partage la plus grande limite commune avec le polygone à éliminer.
L’élimination est normalement utilisée pour se débarrasser des éclats de polygones, c’est-à-dire de minuscules polygones qui sont le résultat de processus d’intersection de polygones où les limites des entrées sont similaires mais pas identiques.
Default menu:
Voir aussi
23.1.15.23.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Fusionner la sélection avec le polygone voisin avec le |
|
[enumeration] Defaut: None |
Choisissez le paramètre à utiliser pour vous débarrasser des polygones sélectionnés:
|
Éliminé |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.23.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Éliminé |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie. |
23.1.15.23.3. Code Python¶
Algorithm ID: qgis:eliminateselectedpolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.24. Exploser les lignes¶
Prend une couche de lignes et en crée une nouvelle dans laquelle chaque couche de lignes est remplacée par un ensemble de lignes représentant les segments de la ligne d’origine.
Chaque ligne de la couche résultante ne contient qu’un point de départ et un point d’arrivée, sans aucun sommet intermédiaire entre eux.
Fig. 23.43 La couche de ligne d’origine et celle éclatée¶
Permet la modification de la couche source
Voir aussi
23.1.15.24.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Eclaté |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.24.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Eclaté |
|
[vector: line] |
Couche vectorielle de ligne de sortie avec des entités représentant chaque segment de la couche d’entrée. |
23.1.15.24.3. Code Python¶
Algorithm ID: qgis:explodelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.25. Prolonger les lignes¶
Prolonge la géométrie de la ligne d’une quantité spécifiée au début et à la fin de la ligne.
Les lignes sont prolongées en utilisant le relèvement du premier et du dernier segment de la ligne.
Fig. 23.44 Les tirets rouges représentent l’extension initiale et finale de la couche d’origine¶
Permet la modification de la couche source
Voir aussi
23.1.15.25.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Distance de départ |
|
[number |
Distance sur laquelle prolonger le premier segment de la ligne (point de départ) |
Distance finale |
|
[number |
Distance sur laquelle prolonger le dernier segment de la ligne (point d’arrivée) |
Élargi |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.25.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Élargi |
|
[vector: line] |
Couche vectorielle de ligne de sortie (étendue). |
23.1.15.25.3. Code Python¶
Algorithm ID: qgis:extendlines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.26. Extraire les valeurs M¶
Extrait les valeurs M des géométries en attributs d’entité.
Par défaut, seule la valeur M du premier sommet de chaque entité est extraite, mais l’algorithme peut éventuellement calculer des statistiques sur toutes les valeurs M de la géométrie, y compris la somme, la moyenne, le minimum et le maximum.
23.1.15.26.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Résumés à calculer |
|
[enumeration] Par défaut: [0] |
Statistiques sur les valeurs M d’une géométrie. Un ou plusieurs de:
|
Préfixe de la colonne de sortie |
|
[string] Default: “m_” |
Le préfixe de la colonne de sortie (M) |
Extrait |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.26.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extrait |
|
[same as input] |
La couche vectorielle de sortie (avec valeurs M) |
23.1.15.26.3. Code Python¶
Algorithm ID: qgis:extractmvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.27. Extraire des vertexs spécifiques¶
Prend une couche vectorielle et génère une couche de points avec des points représentant des sommets spécifiques dans les géométries en entrée.
Par exemple, cet algorithme peut être utilisé pour extraire le premier ou le dernier sommet de la géométrie. Les attributs associés à chaque point sont les mêmes que ceux associés à l’entité à laquelle appartient le sommet.
Le paramètre indices de sommet accepte une chaîne séparée par des virgules spécifiant les indices des sommets à extraire. Le premier sommet correspond à un indice de 0, le deuxième sommet a un indice de 1, etc. Des indices négatifs peuvent être utilisés pour trouver des sommets à la fin de la géométrie, par exemple, un indice de -1 correspond au dernier sommet, - 2 correspond à l’avant-dernier sommet, etc.
Des champs supplémentaires sont ajoutés aux sommets indiquant la position spécifique du sommet (par exemple, 0, -1, etc.), l’indice du sommet d’origine, la partie du sommet et son index à l’intérieur de la partie (ainsi que son anneau pour les polygones), la distance le long de la géométrie d’origine et angle de bissectrice du sommet pour la géométrie d’origine.
23.1.15.27.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Indices de vertex |
|
[string] Default: “0” |
Chaîne séparée par des virgules des indices des vertexs à extraire. |
Vertexs |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.27.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Vertexs |
|
[vector: point] |
Couche vectorielle de sortie (point) contenant les vertexs spécifiés à partir des géométries de la couche d’entrée. |
23.1.15.27.3. Code Python¶
Algorithm ID: qgis:extractspecificvertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.28. Extraire les vertexs¶
Prend une couche vectorielle et génère une couche de points avec des points représentant les sommets dans les géométries en entrée.
Les attributs associés à chaque point sont les mêmes que ceux associés à l’entité à laquelle appartient le sommet.
Des champs supplémentaires sont ajoutés aux vertexs indiquant l’index du vertex (commençant à 0), la pièce de l’entité et son index dans la pièce (ainsi que son anneau pour les polygones), la distance le long de la géométrie d’origine et l’angle de bissectrice du sommet pour la géométrie d’origine.
Fig. 23.45 Vertexs extraits pour la couche ligne et polygone¶
Default menu:
Voir aussi
Extraire des vertexs spécifiques, Filtrer les vertexs par valeur M, Filtrer les vertexs par valeur Z
23.1.15.28.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Vertexs |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.28.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Vertexs |
|
[vector: point] |
Couche vectorielle de sortie (point) contenant les sommets des géométries de la couche d’entrée. |
23.1.15.28.3. Code Python¶
Algorithm ID: qgis:extractvertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.29. Extraire les valeurs Z¶
Extrait les valeurs Z des géométries en attributs d’entité.
Par défaut, seule la valeur Z du premier vertex de chaque entité est extraite, mais l’algorithme peut éventuellement calculer des statistiques sur toutes les valeurs Z de la géométrie, y compris la somme, la moyenne, le minimum et le maximum.
23.1.15.29.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Résumés à calculer |
|
[enumeration] Par défaut: [0] |
Statistiques sur les valeurs Z d’une géométrie. Un ou plusieurs de:
|
Préfixe de la colonne de sortie |
|
[string] Default: “z_” |
Le préfixe de la colonne de sortie (Z) |
Extrait |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.29.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extrait |
|
[same as input] |
La couche vectorielle de sortie (avec des valeurs Z) |
23.1.15.29.3. Code Python¶
Algorithm ID: qgis:extractzvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.30. Filtrer les vertexs par valeur M¶
Filtre les vertexs en fonction de leur valeur M, renvoyant les géométries avec uniquement des points de vertex ayant une valeur M supérieure ou égale à la valeur minimale spécifiée et / ou inférieure ou égale à la valeur maximale.
Si la valeur minimale n’est pas spécifiée, seule la valeur maximale est testée et, de même, si la valeur maximale n’est pas spécifiée, seule la valeur minimale est testée.
Fig. 23.46 La ligne rouge représente la ligne noire avec uniquement des sommets dont la valeur M est <= 10.¶
Note
Selon les attributs de géométrie en entrée et les filtres utilisés, les géométries résultantes créées par cet algorithme peuvent ne plus être valides.
23.1.15.30.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche de vecteur ligne ou polygone d’entrée pour supprimer les vertexs |
Minimum Optionnel |
|
[number Default: Not set |
Minimum de valeurs M autorisé |
Maximum Optionnel |
|
[number Default: Not set |
Maximum de M valeurs autorisées |
Filtré |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.30.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Filtré |
|
[same as input] |
Couche vectorielle de sortie d’entités avec uniquement les vertexs filtrés. |
23.1.15.30.3. Code Python¶
Algorithm ID: qgis:filterverticesbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.31. Filtrer les vertexs par valeur Z¶
Filtre les vertexs en fonction de leur valeur Z, renvoyant des géométries avec uniquement des points de vertex ayant une valeur Z supérieure ou égale à la valeur minimale spécifiée et/ou inférieure ou égale à la valeur maximale.
Si la valeur minimale n’est pas spécifiée, seule la valeur maximale est testée et, de même, si la valeur maximale n’est pas spécifiée, seule la valeur minimale est testée.
Fig. 23.47 La ligne rouge représente la ligne noire avec uniquement des sommets dont la valeur Z est <= 10.¶
Note
Selon les attributs de géométrie en entrée et les filtres utilisés, les géométries résultantes créées par cet algorithme peuvent ne plus être valides. Vous devrez peut-être exécuter l’algorithme Correction des géométries pour garantir leur validité.
23.1.15.31.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche de vecteur ligne ou polygone d’entrée pour supprimer les vertexs |
Minimum Optionnel |
|
[number Default: Not set |
Minimum de valeurs Z autorisées |
Maximum Optionnel |
|
[number Default: Not set |
Maximum de valeurs Z autorisées |
Filtré |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.31.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Filtré |
|
[same as input] |
Couche vectorielle de sortie d’entités avec uniquement les vertexs filtrés. |
23.1.15.31.3. Code Python¶
Algorithm ID: qgis:filterverticesbyz
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.32. Correction des géométries¶
Tente de créer une représentation valide d’une géométrie non valide donnée sans perdre aucun des vertexs d’entrée. Les géométries déjà valides sont retournées sans autre intervention. Produit toujours une couche multi-géométrie.
Note
Les valeurs M seront supprimées de la sortie.
Permet la modification de la couche source
Voir aussi
23.1.15.32.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Corrections des geeométries |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.32.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Corrections des geeométries |
|
[same as input] |
La couche vectorielle de sortie avec les géométries corrigees. |
23.1.15.32.3. Code Python¶
Algorithm ID: qgis:fixgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.33. Forcer la règle de droite¶
Force les géométries de polygone à respecter la règle de droite, dans laquelle la zone délimitée par un polygone se trouve à droite de la limite. En particulier, l’anneau extérieur est orienté dans le sens horaire et tous les anneaux intérieurs dans le sens antihoraire.
23.1.15.33.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche vectorielle en entrée |
Réorienté |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.33.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Réorienté |
|
[vector: polygon] |
Couche vectorielle de sortie avec des géométries réorientées. |
23.1.15.33.3. Code Python¶
Algorithm ID: qgis:forcerhr
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.34. Ligne géodésique divisée à l’antiméridien¶
Fractionne une ligne en plusieurs segments géodésiques, chaque fois que la ligne traverse l’antiméridien (± 180 degrés de longitude).
La division à l’antiméridien aide à l’affichage visuel des lignes dans certaines projections. La géométrie renvoyée sera toujours une géométrie en plusieurs parties.
Chaque fois que des segments de ligne dans la géométrie d’entrée traversent l’antiméridien, ils seront divisés en deux segments, la latitude du point d’arrêt étant déterminée à l’aide d’une ligne géodésique reliant les points de chaque côté de ce segment. Le paramètre ellipsoïde du projet actuel sera utilisé lors du calcul de ce point d’arrêt.
Si la géométrie d’entrée contient des valeurs M ou Z, celles-ci seront interpolées linéairement pour les nouveaux vertexs créés à l’antiméridien.
23.1.15.34.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Fractionner |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.34.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fractionner |
|
[vector: line] |
La couche de vecteur de ligne de sortie s’est divisée à l’antiméridien. |
23.1.15.34.3. Code Python¶
Algorithm ID: qgis:antimeridiansplit
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.35. Géométrie par expression¶
Met à jour les géométries existantes (ou crée de nouvelles géométries) pour les entités en entrée à l’aide d’une expression QGIS.
Cela permet des modifications de géométrie complexes qui peuvent utiliser toute la flexibilité du moteur d’expression QGIS pour manipuler et créer des géométries pour les entités en sortie.
Pour obtenir de l’aide sur les fonctions d’expression QGIS, consultez l’aide intégrée disponible dans le Constructeur d’expressions.
23.1.15.35.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Type de géométrie en sortie |
|
[enumeration] Par défaut : 0 |
La géométrie en sortie dépend fortement de l’expression: par exemple, si vous créez un buffer, le type de géométrie doit être un polygone. Un des:
|
La géométrie de sortie a des valeurs z |
|
[boolean] Par défaut : Faux |
Choisissez si la géométrie de sortie doit inclure la dimension Z |
La géométrie de sortie a valeurs m |
|
[boolean] Par défaut : Faux |
Choisissez si la géométrie de sortie doit inclure la dimension M |
Expression géométrique |
|
[expression] Default: “$geometry” |
Ajoutez l’expression de géométrie que vous souhaitez utiliser. Vous pouvez utiliser le bouton pour ouvrir la boîte de dialogue Expression. La boîte de dialogue répertorie toutes les expressions pertinentes, ainsi que leur aide et leur guide. |
Géométrie modifiée |
|
[vector: any] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.35.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie modifiée |
|
[vector: any] |
Spécifiez la couche vectorielle de sortie |
23.1.15.35.3. Code Python¶
Algorithm ID: qgis:geometrybyexpression
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.36. Interpoler le point en ligne¶
Crée une géométrie de point interpolée à une distance définie le long des géométries de ligne ou de courbe.
Les valeurs Z et M sont interpolées linéairement à partir des valeurs existantes.
Si une géométrie en plusieurs parties est rencontrée, seule la première partie est prise en compte lors du calcul de la sous-chaîne.
Si la distance spécifiée est supérieure à la longueur de l’entité en entrée, l’entité résultante aura une géométrie nulle.
Fig. 23.48 Point interpolé à 500 m du début de la ligne¶
Voir aussi
23.1.15.36.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Distance |
|
[number Par défaut : 0.0 |
Distance depuis le début de la ligne |
Points interpolés |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.36.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Points interpolés |
|
[vector: point] |
Couche vectorielle de point de sortie avec des entités à une distance définie le long de la ligne ou de la limite du polygone |
23.1.15.36.3. Code Python¶
Algorithm ID: qgis:interpolatepoint
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.37. Gardez les N plus grandes parties¶
Prend une couche avec des polygones ou des multipolygones et renvoie une nouvelle couche dans laquelle seuls les n plus grands polygones de chaque entité multipolygone sont conservés. Si une entité comporte n ou moins de parties, l’entité sera simplement copiée.
Fig. 23.49 Dans le sens horaire à partir du haut à gauche: fonction originale en plusieurs parties, une, deux et trois plus grandes pièces conservées¶
23.1.15.37.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Parties à conserver |
|
[number] Par défaut : 1 |
Nombre de parties à conserver. Si 1, seule la plus grande partie de l’entité sera conservée. |
Les parties |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.37.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Les parties |
|
[vector: polygon] |
La couche vectorielle de polygone en sortie avec les N plus grandes parties de chaque entité |
23.1.15.37.3. Code Python¶
Algorithm ID: qgis:keepnbiggestparts
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.38. Portion de ligne¶
Renvoie la partie d’une ligne (ou courbe) qui se situe entre les distances de début et de fin spécifiées (mesurées depuis le début de la ligne).
Les valeurs Z et M sont interpolées linéairement à partir des valeurs existantes.
Si une géométrie en plusieurs parties est rencontrée, seule la première partie est prise en compte lors du calcul de la sous-chaîne.
Fig. 23.50 Portion de Ligne avec une distance de départ fixée à 0 mètre et la distance de fin à 250 mètres.¶
Permet la modification de la couche source
Voir aussi
23.1.15.38.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Distance de départ |
|
[number |
Distance le long de la ligne d’entrée jusqu’au point de départ de l’entité de sortie |
Distance finale |
|
[number |
Distance le long de la ligne d’entrée jusqu’au point final de l’entité de sortie |
Portion |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.38.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Portion |
|
[vector: line] |
Couche de vecteur de ligne de sortie. |
23.1.15.38.3. Code Python¶
Algorithm ID: qgis:linesubstring
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.39. Lignes a polygones¶
Génère une couche de polygones en utilisant comme polygone les lignes d’une couche de lignes en entrée.
La table attributaire de la couche de sortie est la même que celle de la couche de ligne d’entrée.
Default menu:
Voir aussi
23.1.15.39.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Polygones |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.39.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie. |
23.1.15.39.3. Code Python¶
Algorithm ID: qgis:linestopolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.40. Fusionner des lignes¶
Joint toutes les parties connectées des géométries MultiLineString en géométries LineString uniques.
Si aucune partie des géométries MultiLineString en entrée n’est connectée, la géométrie résultante sera une MultiLineString contenant toutes les lignes qui pourraient être fusionnées et toutes les parties de ligne non connectées.
Permet la modification de la couche source
23.1.15.40.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Fusionné |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.40.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fusionné |
|
[vector: line] |
Couche de vecteur de ligne de sortie (fusionnée). |
23.1.15.40.3. Code Python¶
Algorithm ID: qgis:mergelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.41. Géométrie limite minimale¶
Crée des géométries qui entourent les entités d’une couche d’entrée. Les entités peuvent être regroupées par champ. La couche en sortie contiendra alors une entité par valeur de groupe avec une géométrie (MBB) qui couvre les géométries des entités avec une valeur correspondante.
Les types de géométrie englobants suivants sont pris en charge:
Etendue (enveloppe)
rectangle orienté
cercle
enveloppe convexe
Fig. 23.51 Dans le sens horaire à partir du haut à gauche: enveloppe, rectangle orienté, cercle, enveloppe convexe¶
Voir aussi
23.1.15.41.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Champ Optionnel |
|
[tablefield: any] |
Les entités peuvent être regroupées par champ. Si cette option est définie, la couche de sortie contient une entité par valeur groupée avec une géométrie minimale couvrant uniquement les entités avec des valeurs correspondantes. |
Type de géométrie |
|
[enumeration] Par défaut : 0 |
Types de géométrie enveloppante. Un des:
|
Géométrie englobante |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.41.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie englobante |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie (englobante). |
23.1.15.41.3. Code Python¶
Algorithm ID: qgis:minimumboundinggeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.42. Cercles englobants minimum¶
Calcule le nombre minimum de cercles englobants des entités dans la couche d’entrée.
Fig. 23.52 Cercles fermés pour chaque entité¶
Permet la modification de la couche source
Voir aussi
23.1.15.42.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Nombre de segments dans les cercles |
|
[number] Default: 72 |
Nombre de segments utilisés pour approximer un cercle. Minimum 8, maximum 100000. |
Cercles englobants minimum |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.42.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Cercles englobants minimum |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie. |
23.1.15.42.3. Code Python¶
Algorithm ID: qgis:minimumenclosingcircle
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.43. Buffer multi-anneaux (distance constante)¶
Calcule un buffer à anneaux multiples (donut) pour les caractéristiques de la couche d’entrée, en utilisant une distance et un nombre d’anneaux fixes ou dynamiques.
Fig. 23.53 Buffer multi-anneaux pour une couche de lignes, de points et de polygones¶
Permet la modification de la couche source
Voir aussi
Tampon, buffer à distance variable, Rectangles, ovales, diamants (fixed), Rectangles, ovales, diamants (variable), buffer simple face
23.1.15.43.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Nombre d’anneaux |
|
[number Par défaut : 1 |
Le nombre d anneaux. Il peut s’agir d’une valeur unique (même nombre d’anneaux pour toutes les entités) ou elle peut être extraite des données d’entités (le nombre d’anneaux dépend des valeurs des entités). |
Distance entre les anneaux |
|
[number Par défaut : 1.0 |
Distance entre les anneaux. Il peut s’agir d’une valeur unique (même distance pour toutes les entités) ou elle peut être extraite des données d’entités (la distance dépend des valeurs d’entités). |
Buffer multi-anneaux (distance constante) |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.43.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffer multi-anneaux (distance constante) |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie. |
23.1.15.43.3. Code Python¶
Algorithm ID: qgis:multiringconstantbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.44. Multipartie vers monopartie¶
Divise les entités à plusieurs parties de la couche d’entrée en entités à partie unique
Les attributs de la couche de sortie sont les mêmes que ceux d’origine mais divisés en entités uniques.
Fig. 23.54 A gauche la couche source en plusieurs parties et à droite le résultat de sortie de la pièce unique¶
Permet la modification de la couche source
Default menu:
23.1.15.44.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Monoparties |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.44.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Monoparties |
|
[same as input] |
La couche de vecteur de sortie. |
23.1.15.44.3. Code Python¶
Algorithm ID: qgis:multiparttosingleparts
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.45. Lignes décalées¶
Décale les lignes d’une distance spécifiée. Les distances positives décalent les lignes vers la gauche et les distances négatives les décalent vers la droite.
Fig. 23.55 En bleu la couche source, en rouge celui décalé¶
Permet la modification de la couche source
Voir aussi
23.1.15.45.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Distance |
|
[number Par défaut : 10.0 |
Distance de décalage. Vous pouvez utiliser le bouton Données définies à droite pour choisir un champ à partir duquel le rayon sera calculé. De cette façon, vous pouvez avoir un rayon différent pour chaque entité (voir buffer à distance variable). |
Segments |
|
[number] Par défaut : 8 |
Indique le nombre de segments de ligne à utiliser pour approcher un quart de cercle lors de la création de tampons arrondis |
Jointure de style |
|
[enumeration] Par défaut : 0 |
Indique si les joints ronds, à angles droits ou biseautés doivent être utilisés lors du décalage des coins dans une ligne. Les options sont :
|
Limite d’onglet |
|
[number] Par défaut : 2.0 |
Contrôle la distance maximale à partir de la courbe de décalage à utiliser lors de la création d’une jointure en onglet (applicable uniquement aux styles de jointure en onglet). Minimum: 1. |
Décalage |
|
[vector: line] Par défaut: |
Spécifiez la couche de sortie (décalage). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.45.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Décalage |
|
[vector: line] |
Couche de ligne de sortie (offset) |
23.1.15.45.3. Code Python¶
Algorithm ID: qgis:offsetline
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.46. Boîte de délimitation minimale orientée¶
Calcule la surface minimale pivotée du rectangle pour chaque entité de la couche d’entrée.
Fig. 23.56 Boîte de délimitation minimale orientée¶
Permet la modification de la couche source
Voir aussi
23.1.15.46.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Etendues |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.46.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Etendues |
|
[vector: polygon] |
Couche vectorielle de polygone en sortie. |
23.1.15.46.3. Code Python¶
Algorithm ID: qgis:orientedminimumboundingbox
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.47. Orthogonaliser¶
Tente d’orthogonaliser les géométries de la ligne d’entrée ou de la couche de polygones. Ce processus décale les sommets des géométries pour essayer de faire de chaque angle de la géométrie soit un angle droit soit une ligne droite.
Fig. 23.57 En bleu la couche source et en rouge le résultat orthogonalisé¶
Permet la modification de la couche source
23.1.15.47.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Tolérance d’angle maximale (degrés) |
|
[number] Par defaut: 15 |
Spécifiez l’écart maximal par rapport à un angle droit ou à une ligne droite qu’un sommet peut avoir pour qu’il soit ajusté. Des tolérances plus petites signifient que seuls les sommets qui sont déjà plus proches des angles droits seront ajustés, et des tolérances plus grandes signifient que les sommets qui s’écartent davantage des angles droits seront également ajustés. |
Nombre maximal d’itérations de l’algorithme |
|
[number] Default: 1000 |
La définition d’un nombre plus élevé pour le nombre maximal d’itérations se traduira par une géométrie plus orthogonale au prix d’un temps de traitement supplémentaire. |
Orthogonalisé |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.47.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Orthogonalisé |
|
[same as input] |
Couche vectorielle de polygone en sortie avec angles ajustés. |
23.1.15.47.3. Code Python¶
Algorithm ID: qgis:orthogonalize
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.48. Point sur la surface¶
Pour chaque entité de la couche en entrée, renvoie un point qui est garanti se trouver sur la surface de la géométrie de l’entité.
Permet la modification de la couche source
Voir aussi
23.1.15.48.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Créer un point sur la surface pour chaque partie |
|
[boolean |
Si cette case est cochée, un point sera créé pour chaque partie de la géométrie. |
Point |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle du point de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.48.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vector: point] |
Couche vectorielle du point de sortie. |
23.1.15.48.3. Code Python¶
Algorithm ID: qgis:pointonsurface
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.49. Points le long de la géométrie¶
Crée des points à intervalles réguliers le long des géométries de ligne ou de polygone. Les points créés auront de nouveaux attributs ajoutés pour la distance le long de la géométrie et l’angle de la ligne au point.
Un décalage de début et de fin facultatif peut être spécifié, qui contrôle la distance entre le début et la fin de la géométrie, les points doivent être créés.
Fig. 23.58 Points créés le long d la couche de ligne source¶
Voir aussi
23.1.15.49.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Distance |
|
[number Par défaut : 1.0 |
Distance entre deux points consécutifs le long de la ligne |
Décalage de début |
|
[number Par défaut : 0.0 |
Distance depuis le début de la ligne d’entrée, représentant la position du premier point. |
Décalage de fin |
|
[number Par défaut : 0.0 |
Distance à partir de la fin de la ligne d’entrée, représentant la position au-delà de laquelle aucune entité ponctuelle ne doit être créée. |
Points interpolés |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.49.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Points interpolés |
|
[vector: point] |
Couche vectorielle ponctuelle avec des entités placées le long des lignes ou des limites des polygones de la couche d’entrée. |
23.1.15.49.3. Code Python¶
Algorithm ID: qgis:pointsalonglines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.50. Déplacement des points¶
Étant donné une distance de proximité, identifie les entités ponctuelles proches et les répartit radialement sur un cercle dont le centre représente leur barycentre. Un outil pratique pour disperser les fonctionnalités superposées.
23.1.15.50.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Distance minimale à d’autres points |
|
[number] Par défaut : 1.0 |
Distance en dessous de laquelle les entités ponctuelles sont considérées comme proches. Les entités proches sont entièrement distribuées. |
Distance de déplacement |
|
[number] Par défaut : 1.0 |
Rayon du cercle sur lequel les entités proches sont placées |
Distribution horizontale pour cas à deux points |
|
[boolean] Par défaut : Faux |
Lorsque seuls deux points sont identifiés comme proches, les alignent horizontalement sur le cercle plutôt que verticalement. |
Déplacé |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.50.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Déplacé |
|
[vector: point] |
Couche vectorielle de point de sortie |
23.1.15.50.3. Code Python¶
Algorithm ID: qgis:pointsdisplacement
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.51. Pôle d’inaccessibilité¶
Calcule le pôle d’inaccessibilité pour une couche de polygones, qui est le point interne le plus éloigné de la limite de la surface.
Cet algorithme utilise l’algorithme polylabel (Vladimir Agafonkin, 2016), qui est une approche itérative garantie pour trouver le véritable pôle d’inaccessibilité dans une tolérance spécifiée. Une tolérance plus précise (valeur inférieure) nécessite plus d’itérations et prendra plus de temps à calculer.
La distance entre le pôle calculé et la limite du polygone sera stockée en tant que nouvel attribut dans la couche de sortie.
Fig. 23.59 Pôle d’inaccessibilité¶
23.1.15.51.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche vectorielle en entrée |
Tolerance |
|
[number] Par défaut : 1.0 |
Définit la tolérance pour le calcul |
Point |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.51.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vector: point] |
La couche vectorielle de point de sortie |
23.1.15.51.3. Code Python¶
Algorithm ID: qgis:poleofinaccessibility
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.52. Transformer en polygone¶
Crée une couche de polygone dont les limites des entités sont générées à partir d’une couche linéaire d’entités fermées.
Fig. 23.60 Les polygones jaunes générés à partir des lignes fermées¶
Note
La couche de lignes doit avoir des formes fermées afin d’être transformées en polygones.
Voir aussi
23.1.15.52.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Conserver la structure de la table de la couche de ligne Optionnel |
|
[boolean] Par défaut : Faux |
Cocher pour copier les attributs d’origine de la couche d’entrée |
Polygones à partir de lignes |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.52.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones à partir de lignes |
|
[vector: polygon] |
La couche vectorielle de polygone en sortie à partir des lignes |
23.1.15.52.3. Code Python¶
Algorithm ID: qgis:polygonize
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.53. Des polygones aux lignes¶
Prend une couche de polygones et crée une couche de lignes, avec des lignes représentant les limites des polygones dans la couche d’entrée.
Fig. 23.61 Lignes noires résultant de l’algorithme¶
Default menu:
Voir aussi
23.1.15.53.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Lignes |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.53.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Lignes |
|
[vector: line] |
La couche vectorielle de lignes extraites des polygones |
23.1.15.53.3. Code Python¶
Algorithm ID: qgis:polygonstolines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.54. Points de projet (cartésiens)¶
Projette des géométries de point selon une distance et un relèvement spécifiés (azimut).
Permet la modification de la couche source
23.1.15.54.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Relèvement (degrés par rapport au nord) |
|
[number Par défaut : 0.0 |
Angle horaire à partir du nord, en degrés (°) |
Distance |
|
[number Par défaut : 1.0 |
Distance de décalage des géométries, en unités de couche |
Projeté |
|
[vector: point] Par défaut: |
Spécifiez la couche vectorielle du point de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.54.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Projeté |
|
[vector: point] |
Couche vectorielle de points de sortie (projetée) |
23.1.15.54.3. Code Python¶
Algorithm ID: qgis:projectpointcartesian
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.55. Promouvoir en plusieurs parties¶
Prend une couche vectorielle avec des géométries à partie unique et en génère une nouvelle dans laquelle toutes les géométries sont en plusieurs parties.
Les entités en entrée qui sont déjà des entités en plusieurs parties resteront inchangées.
Cet algorithme peut être utilisé pour forcer les géométries à des types à plusieurs parties afin d’être compatible avec les fournisseurs de données qui nécessitent des entités à plusieurs parties.
Permet la modification de la couche source
Voir aussi
23.1.15.55.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Multiparties |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle multipart en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.55.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Multiparties |
|
[same as input] |
La couche vectorielle de sortie en plusieurs parties |
23.1.15.55.3. Code Python¶
Algorithm ID: qgis:promotetomulti
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.56. Rectangles, ovales, diamants (fixed)¶
Crée un buffer pour toutes les entités d’une couche d’entrée avec un choix de forme différent.
Les paramètres peuvent varier en fonction de la forme choisie.
Fig. 23.62 Différentes formes de buffer¶
Voir aussi
23.1.15.56.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Forme de buffer |
|
[enumeration] |
La forme à utiliser. Un des:
|
Largeur |
|
[number] Par défaut : 1.0 |
Largeur de la forme du buffer |
Hauteur |
|
[number] Par défaut : 1.0 |
Hauteur de la forme du buffer |
Rotation Optionnel |
|
[number] Defaut: None |
Rotation de la forme du buffer |
Nombre de segments |
|
[number] Default: 36 |
Nombre de segments pour un cercle complet (forme Ovales) |
Rendu |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.56.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Rendu |
|
[vector: polygon] |
La couche vectorielle de sortie (avec les formes du buffer) |
23.1.15.56.3. Code Python¶
Algorithm ID: qgis:rectanglesovalsdiamonds
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.57. Rectangles, ovales, diamants (variable)¶
Crée un buffer pour toutes les entités d’une couche d’entrée avec un choix de forme différent.
Les paramètres de forme du buffer sont spécifiés via l’attribut de la couche d’entrée.
Fig. 23.63 Différentes formes de buffer avec différents paramètres¶
Voir aussi
23.1.15.57.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Forme de buffer |
|
[enumeration] Par défaut : 0 |
La forme à utiliser. Un des:
|
Champ de largeur |
|
[tablefield: numeric] Default: First |
Largeur de la forme du buffer |
Champ de hauteur |
|
[tablefield: numeric] Default: First |
Hauteur de la forme du buffer |
Champ de rotation Optionnel |
|
[tablefield: numeric] |
Rotation de la forme du buffer |
Nombre de segments |
|
[number] Default: 36 |
Nombre de segments pour un cercle complet (forme Ovales) |
Rendu |
|
[vector: polygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.57.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Rendu |
|
[vector: polygon] |
La couche vectorielle de sortie (avec les formes du buffer) |
23.1.15.58. Supprimer les vertexs en double¶
Supprime les vertexs en double des entités, partout où la suppression des vertexs n’entraîne pas une géométrie dégénérée.
Le paramètre de tolérance spécifie la tolérance des coordonnées pour déterminer si les sommets sont identiques.
Par défaut, les valeurs Z ne sont pas prises en compte lors de la détection des sommets en double. Par exemple, deux sommets ayant les mêmes coordonnées X et Y mais des valeurs Z différentes seront toujours considérés comme des doublons et l’un d’eux sera supprimé. Si le paramètre Use Z Value est vrai, alors les valeurs Z sont également testées et les sommets ayant les mêmes X et Y mais des Z différents seront maintenus.
Note
Les vertexs en double ne sont pas testés entre différentes parties d’une géométrie en plusieurs parties, par ex. une géométrie multipoint avec des points qui se chevauchent ne sera pas modifiée par cette méthode.
Permet la modification de la couche source
Voir aussi
Extraire les vertexs, Extraire des vertexs spécifiques, Supprimer les géométries dupliquées
23.1.15.58.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Tolerance |
|
[number Default: 0.000001 |
Les vertexs plus proches que la distance spécifiée sont considérés comme des doublons |
Utilisez la valeur Z |
|
[boolean Par défaut : Faux |
Si le paramètre Use Z Value est vrai, alors les valeurs Z sont également testées et les sommets avec les mêmes X et Y mais des Z différents seront maintenus. |
Nettoyé |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.58.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nettoyé |
|
[same as input] |
La couche vectorielle de sortie (sans vertexs en double) |
23.1.15.58.3. Code Python¶
Algorithm ID: qgis:removeduplicatevertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.59. Supprimer les géométries nulles¶
Supprime toutes les entités qui n’ont pas de géométrie d’une couche vectorielle.
Toutes les autres entités seront copiées telles quelles.
Les entités avec des géométries nulles peuvent être enregistrées sur une couche distincte.
Voir aussi
23.1.15.59.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée (avec des géométries non NULL) |
Géométries non nulles |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie pour les géométries non NULL. Un des:
L’encodage du fichier peut également être modifié ici. |
Géométries nulles |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie pour les géométries NULL. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.59.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométries nulles |
|
[same as input] |
La couche vectorielle de sortie (uniquement les géométries NULL) |
Géométries non nulles |
|
[same as input] |
La couche vectorielle de sortie (sans géométries NULL) |
23.1.15.59.3. Code Python¶
Algorithm ID: qgis:removenullgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.60. Inverser la direction de la ligne¶
Inverse la direction d’une couche de ligne.
Fig. 23.64 Avant et après l’inversion de direction¶
Permet la modification de la couche source
23.1.15.60.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Renversé |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.60.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Renversé |
|
[vector: line] |
La couche de vecteur de ligne de sortie (avec des lignes inversées) |
23.1.15.60.3. Code Python¶
Algorithm ID: qgis:reverselinedirection
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.61. Tourner¶
Fait pivoter les géométries d’entités de l’angle spécifié dans le sens horaire. La rotation se produit autour du centre de gravité de chaque entité, ou éventuellement autour d’un point prédéfini unique.
Permet la modification de la couche source
Voir aussi
23.1.15.61.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Rotation (degrés dans le sens horaire) |
|
[number Par défaut : 0.0 |
Angle de rotation en degrés |
Point d’ancrage de rotation (x, y) Optionnel |
|
[point] Defaut: None |
Coordonnées X, Y du point pour faire pivoter les entités autour. S’il n’est pas défini, la rotation se produit autour du centre de gravité de chaque entité. |
Tourné |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (avec des géométries pivotées). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.61.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Tourné |
|
[same as input] |
La couche vectorielle de sortie avec des géométries pivotées |
23.1.15.61.3. Code Python¶
Algorithm ID: qgis:rotatefeatures
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.62. Segmentez par angle maximum¶
Segmente une géométrie en convertissant des sections courbes en sections linéaires.
La segmentation est effectuée en spécifiant l’angle de rayon maximal autorisé entre les vertexs sur la géométrie redressée (par exemple l’angle de l’arc créé à partir du centre de l’arc d’origine vers les vertexs de sortie consécutifs sur la géométrie linéarisée). Les géométries non courbes seront conservées sans changement.
Voir aussi
23.1.15.62.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Angle maximum entre les vertexs (degrés) |
|
[number Default: 5.0 |
Angle de rayon maximal autorisé entre les vertexs de la géométrie redressée |
Segmenté |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (avec des géométries segmentées). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.62.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Segmenté |
|
[same as input] |
La couche vectorielle de sortie avec des géométries segmentées |
23.1.15.62.3. Code Python¶
Algorithm ID: qgis:segmentizebymaxangle
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.63. Segmentez par distance maximale¶
Segmente une géométrie en convertissant des sections courbes en sections linéaires.
La segmentation est effectuée en spécifiant la distance de décalage maximale autorisée entre la courbe d’origine et la représentation segmentée. Les géométries non courbes seront conservées sans changement.
Voir aussi
23.1.15.63.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Distance de décalage maximale |
|
[number Par défaut : 1.0 |
Distance de décalage maximale autorisée entre la courbe d’origine et la représentation segmentée, dans les unités de la couche. |
Segmenté |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (avec des géométries segmentées). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.63.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Segmenté |
|
[same as input] |
La couche vectorielle de sortie avec des géométries segmentées |
23.1.15.63.3. Code Python¶
Algorithm ID: qgis:segmentizebymaxdistance
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.64. Définir la valeur M¶
Définit la valeur M pour les géométries d’une couche.
Si valeurs M existent déjà dans la couche, elles seront remplacées par la nouvelle valeur. Si aucune valeur M n’existe, la géométrie sera mise à niveau pour inclure les valeurs M et la valeur spécifiée utilisée comme valeur M initiale pour toutes les géométries.
Astuce
Utilisez le bouton 
Identifier les entites pour vérifier que la valeur M est ajoutée: les résultats sont disponibles dans la boîte de dialogue Identifier les résultats.
23.1.15.64.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Valeur M |
|
[number Par défaut : 0.0 |
Valeur M à affecter aux géométries d’entités |
M ajouté |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.64.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
M ajouté |
|
[same as input] |
La couche vectorielle de sortie (avec M valeurs affectées aux géométries) |
23.1.15.64.3. Code Python¶
Algorithm ID: qgis:setmvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.65. Définir la valeur M du raster¶
Utilise des valeurs échantillonnées à partir d’une bande dans une couche raster pour définir la valeur M pour chaque vertex se chevauchant dans la géométrie de l’entité. Les valeurs raster peuvent éventuellement être mises à l’échelle par une quantité prédéfinie.
Si les valeurs M existent déjà dans la couche, elles seront remplacées par la nouvelle valeur. Si aucune valeur M n’existe, la géométrie sera mise à niveau pour inclure les valeurs M.
23.1.15.65.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Couche raster |
|
[raster] |
Couche raster avec valeurs M |
Numéro de bande |
|
[raster band] Par défaut : 1 |
La bande raster dont les valeurs M sont tirées |
Valeur pour nodata ou sommets non intersectés |
|
[number |
Valeur à utiliser si le sommet n’intersecte pas (un pixel valide) le raster |
Facteur d’échelle |
|
[number Par défaut : 1.0 |
Valeur de mise à l’échelle: les valeurs de bande sont multipliées par cette valeur. |
Mis à jour |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (avec les valeurs M mises à jour). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.65.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mis à jour |
|
[same as input] |
La couche vectorielle de sortie (avec les valeurs M mises à jour) |
23.1.15.65.3. Code Python¶
Algorithm ID: qgis:setmfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.66. Définir la valeur Z¶
Définit la valeur Z pour les géométries d’une couche.
Si des valeurs Z existent déjà dans la couche, elles seront remplacées par la nouvelle valeur. S’il n’existe aucune valeur Z, la géométrie sera mise à niveau pour inclure les valeurs Z et la valeur spécifiée utilisée comme valeur Z initiale pour toutes les géométries.
Astuce
Utilisez le bouton Identifier les entités pour vérifier la valeur Z ajoutée: les résultats sont disponibles dans la boîte de dialogue Identifier les résultats.
23.1.15.66.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Valeur Z |
|
[number Par défaut : 0.0 |
Valeur Z à affecter aux géométries d’entités |
Z ajouté |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.66.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Z ajouté |
|
[same as input] |
La couche vectorielle de sortie (avec des valeurs Z attribuées) |
23.1.15.66.3. Code Python¶
Algorithm ID: qgis:setzvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.67. Simplifier¶
Simplifie les géométries d’une couche de lignes ou de polygones. Il crée une nouvelle couche avec les mêmes caractéristiques que celles de la couche d’entrée, mais avec des géométries contenant un nombre de vertexs inférieur.
L’algorithme offre un choix de méthodes de simplification, notamment la distance (l’algorithme « Douglas-Peucker »), la zone (l’algorithme « Visvalingam ») et l’alignement des géométries sur la grille.
Fig. 23.65 Dans le sens horaire à partir du haut à gauche: couche source et augmentation des tolérances de simplification¶
Permet la modification de la couche source
Default menu:
Voir aussi
23.1.15.67.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Méthode de simplification |
|
[enumeration] Par défaut : 0 |
Méthode de simplification. Un des:
|
Tolerance |
|
[number Par défaut : 1.0 |
Tolérance de seuil (en unités de la couche): si la distance entre deux nœuds est inférieure à la valeur de tolérance, le segment sera simplifié et les sommets seront supprimés. |
Simplifié |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (simplifiée). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.67.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Simplifié |
|
[same as input] |
La couche vectorielle de sortie (simplifiée) |
23.1.15.67.3. Code Python¶
Algorithm ID: qgis:simplifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.68. buffer simple face¶
Calcule un buffer sur les lignes d’une distance spécifiée d’un côté de la ligne uniquement.
Le buffer produit toujours une couche polygonale.
Fig. 23.66 Tampon gauche ou droit sur la même couche de lignes vectorielles¶
Voir aussi
23.1.15.68.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Distance |
|
[number] Par défaut : 10.0 |
Distance buffer. |
Côté |
|
[enumeration] |
De quel côté créer le buffer. Un des:
|
Segments |
|
[number] Par défaut : 8 |
Indique le nombre de segments de ligne à utiliser pour approcher un quart de cercle lors de la création de tampons arrondis |
Jointure de style |
|
[enumeration] |
Indique si les joints ronds, à angles droits ou biseautés doivent être utilisés lors du décalage des coins dans une ligne. Les options sont :
|
Limite d’onglet |
|
[number] Par défaut : 2.0 |
Contrôle la distance maximale à partir de la courbe de décalage à utiliser lors de la création d’une jointure en onglet (applicable uniquement aux styles de jointure en onglet). Minimum: 1,0 |
Buffer |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.68.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffer |
|
[vector: polygon] |
Couche de polygone de sortie (buffer) |
23.1.15.68.3. Code Python¶
Algorithm ID: qgis:singlesidedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.69. Lisse¶
Lisse les géométries d’une couche de lignes ou de polygones en ajoutant plus de vertexs et coins aux géométries d’entités.
Le paramètre d’itérations détermine le nombre d’itérations de lissage qui seront appliquées à chaque géométrie. Un nombre d’itérations plus élevé se traduit par des géométries plus lisses avec le coût d’un plus grand nombre de nœuds dans les géométries.
Fig. 23.67 L’augmentation du nombre d’itérations entraîne des géométries plus lisses¶
Le paramètre de décalage contrôle le degré de « serrage » des géométries lissées par rapport aux géométries d’origine. Des valeurs plus petites entraînent un ajustement plus serré, et des valeurs plus grandes créeront un ajustement plus lâche.
Fig. 23.68 Bleu: la couche d’entrée. Le décalage 0,25 donne la ligne rouge, tandis que le décalage 0,50 donne la ligne verte.¶
Le paramètre d’angle maximal peut être utilisé pour empêcher le lissage des nœuds avec de grands angles. Tout nœud dont l’angle des segments de chaque côté est supérieur à celui-ci ne sera pas lissé. Par exemple, si vous définissez l’angle maximum à 90 degrés ou moins, les angles droits de la géométrie seront préservés.
Permet la modification de la couche source
Voir aussi
23.1.15.69.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line, polygon] |
Couche vecteur ligne ou polygone en entrée |
Iterations |
|
[number Par défaut : 1 |
L’augmentation du nombre d’itérations donnera des géométries plus lisses (et plus de vertexs). |
Décalage |
|
[number Default: 0.25 |
Des valeurs croissantes déplaceront les lignes / limites lissées plus loin des lignes / limites d’entrée. |
Angle de nœud maximum pour lisser |
|
[number Default: 180.0 |
Chaque nœud en dessous de cette valeur sera lissé |
** Lissé ** |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie (lissé). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.69.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Lissé ** |
|
[same as input] |
Couche vectorielle de sortie (lissée) |
23.1.15.69.3. Code Python¶
Algorithm ID: qgis:smoothgeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.70. Accrochage des géométries à la couche¶
Accroche les géométries d’une couche aux géométries d’une autre couche ou aux géométries de la même couche.
La correspondance est effectuée sur la base d’une distance de tolérance, et les sommets seront insérés ou supprimés selon les besoins pour que les géométries correspondent aux géométries de référence.
Voir aussi
23.1.15.70.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Couche de référence |
|
[vector: any] |
Couche de vecteur à accrocher |
Tolerance |
|
[number] Par défaut : 10.0 |
Contrôlez la distance entre les sommets en entrée et les géométries de la couche de référence avant leur accrochage. |
Comportement* |
|
[enumeration] Par défaut : 0 |
La capture peut être effectuée sur un nœud ou un segment existant (son point le plus proche du sommet à déplacer). Options de capture disponibles:
|
Géométrie accroché |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie (accrochée). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.70.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie accroché |
|
[same as input] |
Couche vectorielle de sortie (accrochée) |
23.1.15.70.3. Code Python¶
Algorithm ID: qgis:snapgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.71. Accrocher les points à la grille¶
Modifie les coordonnées des géométries dans une couche vectorielle, afin que tous les points ou sommets soient accrochés au point le plus proche d’une grille.
Si la géométrie capturée ne peut pas être calculée (ou est totalement réduite), la géométrie de l’entité sera effacée.
L’alignement peut être effectué sur les axes X, Y, Z ou M. Un espacement de grille de 0 pour n’importe quel axe désactivera l’accrochage pour cet axe.
Note
L’accrochage à la grille peut générer une géométrie non valide dans certains cas d’angle.
Permet la modification de la couche source
Voir aussi
23.1.15.71.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Espacement de la grille X |
|
[number Par défaut : 1.0 |
Espacement de la grille sur l’axe X |
Espacement de la grille Y |
|
[number Par défaut : 1.0 |
Espacement de la grille sur l’axe Y |
Espacement de la grille Z |
|
[number Par défaut : 0.0 |
Espacement de la grille sur l’axe Z |
Espacement de la grille M |
|
[number Par défaut : 0.0 |
Espacement de la grille sur l’axe M |
Accroché |
|
[same as input] Par défaut: |
Spécifiez la couche de sortie (accrochée). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.71.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Accroché |
|
[same as input] |
Couche vectorielle de sortie (accrochée) |
23.1.15.71.3. Code Python¶
Algorithm ID: qgis:snappointstogrid
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.72. Fractionner les lignes par longueur maximale¶
Prend une couche de ligne (ou courbe) et divise chaque entité en plusieurs parties, chaque partie ayant une longueur maximale spécifiée. Les valeurs Z et M au début et à la fin des nouvelles lignes de lignes sont interpolées linéairement à partir des valeurs existantes.
23.1.15.72.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
La couche de vecteur de ligne d’entrée |
Longueur de ligne maximale |
|
[number Par défaut : 10.0 |
La longueur maximale d’une ligne dans la sortie. |
Fractionner |
|
[vector: line] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.72.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fractionner |
|
[vector: line] |
La nouvelle couche de vecteur de ligne - la longueur des géométries d’entité est inférieure ou égale à la longueur spécifiée dans le paramètre LENGTH. |
23.1.15.72.3. Code Python¶
Algorithm ID: qgis:splitlinesbylength
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.73. Subdiviser¶
Subdivise la géométrie. La géométrie renvoyée sera une collection contenant des pièces subdivisées de la géométrie d’origine, où aucune pièce n’a plus que le nombre maximal de nœuds spécifié.
Ceci est utile pour diviser une géométrie complexe en parties moins complexes, plus facile à indexer spatialement et plus rapide pour effectuer des opérations spatiales. Les géométries courbes seront segmentées avant subdivision.
Fig. 23.69 À gauche de la couche d’entrée, la valeur maximale des nœuds centraux est 100 et la valeur maximale droite est 200¶
Note
La subdivision d’une géométrie peut générer des pièces de géométrie qui peuvent ne pas être valides et peuvent contenir des auto-intersections.
Permet la modification de la couche source
Voir aussi
23.1.15.73.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
La couche de vecteur d’entrée |
Nombre maximal de nœuds en parties |
|
[number Par défaut : 256 |
Nombre maximal de sommets que chaque nouvelle pièce géométrique peut avoir. Moins de sous-parties pour des valeurs plus élevées. |
Subdivisé |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie (subdivisé). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.73.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Subdivisé |
|
[same as input] |
Couche vectorielle de sortie |
23.1.15.73.3. Code Python¶
Algorithm ID: qgis:subdivide
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.74. Permuter les coordonnées X et Y¶
Bascule les valeurs des coordonnées X et Y dans les géométries en entrée.
Il peut être utilisé pour réparer des géométries dont les valeurs de latitude et de longitude ont accidentellement été inversées.
Permet la modification de la couche source
23.1.15.74.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
La couche de vecteur d’entrée |
Échangé |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.74.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Échangé |
|
[same as input] |
Couche vectorielle de sortie (permutée) |
23.1.15.74.3. Code Python¶
Algorithm ID: qgis:swapxy
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.75. Tampons coniques¶
Crée un buffer conique le long des géométries de ligne, en utilisant un diamètre de tampon de début et de fin spécifié.
Fig. 23.70 Exemple de buffer conique¶
23.1.15.75.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Largeur de départ |
|
[number Par défaut : 0.0 |
Représente le rayon du buffer appliqué au point de départ de l’entité linéaire |
Largeur d’extrémité |
|
[number Par défaut : 0.0 |
Représente le rayon du buffer appliqué au point final de l’entité linéaire. |
Segments |
|
[number Default: 16 |
Indique le nombre de segments de ligne à utiliser pour approcher un quart de cercle lors de la création de tampons arrondis |
Buffered |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.75.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vector: polygon] |
Couche de polygone de sortie (buffer) |
23.1.15.75.3. Code Python¶
Algorithm ID: qgis:taperedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.76. Tessellate¶
une couche mosaïque de géométrie polygonale, divisant les géométries en composants triangulaires.
La couche de sortie se compose de géométries multipolygones pour chaque entité en entrée, chaque multipolygone étant composé de plusieurs polygones triangulaires.
Fig. 23.71 Polygone en mosaïque (à droite)¶
Permet la modification de la couche source
23.1.15.76.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Mosaïqué |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.76.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mosaïqué |
|
[vector: polygon] |
Couche multipolygoneZ en sortie |
23.1.15.76.3. Code Python¶
Algorithm ID: qgis:tessellate
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.77. Transect¶
Crée des transects sur les sommets pour les (multi)ligne.
Un transect est une ligne orientée d’un angle (par défaut perpendiculaire) aux polylignes d’entrée (aux sommets).
Les champs des entités sont retournés dans le transect avec ces nouveaux champs:
TR_FID: ID de l’entite d’origine
TR_ID: ID du transect. Chaque transect a un identifiant unique
TR_SEGMENT: ID du segment de la ligne
TR_ANGLE: Angle en degrés par rapport à la ligne d’origine au sommet
TR_LENGTH: longueur totale du transect retourné
TR_ORIENT: Côté du transect (uniquement à gauche ou à droite de la ligne, ou les deux côtés)
Fig. 23.72 Les lignes rouges en pointillés représentent le transect de la couche de ligne d’entrée¶
23.1.15.77.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Longueur du transect |
|
[number Default: 5.0 |
Longueur en unité de carte du transect |
Angle en degrés par rapport à la ligne d’origine au niveau des sommet |
|
[number Default: 90.0 |
Changer l’angle du transect |
Côté pour créer le transect |
|
[enumeration] |
Choisissez le côté du transect. Les options disponibles sont:
|
Transect |
|
[vector: line] Par défaut: |
Spécifiez la couche de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.77.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Transect |
|
[vector: line] |
Couche de ligne de sortie |
23.1.15.77.3. Code Python¶
Algorithm ID: qgis:transect
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.78. Traduire¶
Déplace les géométries dans une couche, en les décalant avec un déplacement X et Y prédéfini.
Les valeurs Z et M présentes dans la géométrie peuvent également être traduites.
Fig. 23.73 Les lignes pointillées représentent la géométrie traduite de la couche d’entrée¶
Permet la modification de la couche source
23.1.15.78.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Distance de décalage (axe x) |
|
[number Par défaut : 0.0 |
Déplacement à appliquer sur l’axe X |
Distance de décalage (axe y) |
|
[number Par défaut : 0.0 |
Déplacement à appliquer sur l’axe Y |
Distance de décalage (axe z) |
|
[number Par défaut : 0.0 |
Déplacement à appliquer sur l’axe Z |
Distance de décalage (valeurs m) |
|
[number Par défaut : 0.0 |
Déplacement à appliquer sur l’axe M |
Traduit |
|
[same as input] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.78.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Traduit |
|
[same as input] |
Couche vectorielle de sortie |
23.1.15.78.3. Code Python¶
Algorithm ID: qgis:translategeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.79. buffer à distance variable¶
Calcule un buffer pour toutes les entités d’une couche d’entrée.
La taille du buffer pour une entité donnée est définie par un attribut, ce qui permet à différentes entités d’avoir des tailles de mémoire tampon différentes.
Note
Cet algorithme n’est disponible que depuis Graphical modeler.
Voir aussi
23.1.15.79.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle en entrée |
Champ de distance |
|
[tablefield: numeric] |
Attribut pour le rayon de distance du buffer |
Segments |
|
[number] Défaut: 5 |
Indique le nombre de segments de ligne à utiliser pour approcher un quart de cercle lors de la création de tampons arrondis |
Dissoudre le résultat |
|
[boolean] Par défaut : Faux |
Choisissez de dissoudre le buffer final, résultant en une seule entité couvrant toutes les entités en entrée.
Fig. 23.74 buffer normal et dissous¶ |
** Style extrémité ** |
|
[enumeration] |
Contrôle la façon dont les fins de ligne sont traitées dans le buffer.
Fig. 23.75 Style de terminaison rond, plat et carré¶ |
Jointure de style |
|
[enumeration] |
Spécifie si les jointures arrondies, à onglet ou biseautées doivent être utilisées lors du décalage des coins d’une ligne. |
Limite d’onglet |
|
[number] Par défaut : 2.0 |
S’applique uniquement aux styles de jointure à onglets et contrôle la distance maximale à partir de la courbe de décalage à utiliser lors de la création d’une jointure à onglets. |
23.1.15.79.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffer |
|
[vector: polygon] |
Couche vectorielle de polygone correspondant au tampon. |
23.1.15.79.3. Code Python¶
Algorithm ID: qgis:variabledistancebuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.80. buffer à largeur variable (par valeur M)¶
Crée des buffers de largeur variable le long des lignes, en utilisant la valeur M des géométries de ligne comme diamètre du buffer à chaque sommet.
Fig. 23.76 Exemple de buffer variable¶
Voir aussi
23.1.15.80.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vectorielle de ligne d’entrée |
Segments |
|
[number Default: 16 |
Nombre de segments buffer par quart de cercle. Il peut s’agir d’une valeur unique (même valeur pour toutes les entités), ou elle peut être extraite des données d’entités (la valeur peut dépendre des attributs des entités). |
Buffered |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.80.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vector: polygon] |
Couche de polygone buffer variable |
23.1.15.80.3. Code Python¶
Algorithm ID: qgis:bufferbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.15.81. Polygones de Voronoi¶
Prend une couche de points et génère une couche de polygones contenant les polygones Voronoi (également appelés polygones Thiessen) correspondant à ces points d’entrée.
Tout emplacement dans un polygone Voronoi est plus proche du point associé que de tout autre point.
Fig. 23.77 Polygones de Voronoi¶
Default menu:
23.1.15.81.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Buffer region (% of extent) |
|
[number] Par défaut : 0.0 |
L’étendue de la couche de sortie sera beaucoup plus grande que l’étendue de la couche d’entrée |
Polygones de Voronoï |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de sortie (avec les polygones de Voronoi). Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.15.81.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones de Voronoï |
|
[vector: polygon] |
Polygones de Voronoï de la couche vectorielle de points d’entrée |
23.1.15.81.3. Code Python¶
Algorithm ID: qgis:voronoipolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.