25.1.18. Géométrie vectorielle
25.1.18.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
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Ajout d’informations geom |
|
[identique à l’entrée] |
Copie de la couche vectorielle d’entrée avec l’ajout des champs de géométrie |
Code Python
ID de l’algorithme : 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.
25.1.18.2. Transformation affine
Applique une transformation affine aux géométries des couches. Les transformations affines peuvent inclure la translation, la mise à l’échelle et la rotation. Les opérations sont effectuées dans l’ordre suivant : mise à l’échelle, rotation et translation.
Les valeurs Z et M (si elles existent) peuvent être translatées et mises à l’échelle.
Fig. 25.48 Couche de points vecteur (points verts) avant (à gauche), et après (à droite) une translation affine (translation).
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Translation (axe des x) |
|
[number Par défaut : 0 |
Déplacement à appliquer sur l’axe X. |
Translation (axe des y) |
|
[number Par défaut : 0 |
Déplacement à appliquer sur l’axe Y. |
Translation (axe z) |
|
[number Par défaut : 0 |
Déplacement à appliquer sur l’axe Z. |
Translation (valeurs m) |
|
[number Par défaut : 0 |
décalage à appliquer sur les valeurs m. |
Facteur d’échelle (axe des x) |
|
[number Par défaut : 1 |
Valeur d’échelle (expansion ou contraction) à appliquer sur l’axe X. |
Facteur d’échelle (axe des y) |
|
[number Par défaut : 1 |
Valeur d’échelle (expansion ou contraction) à appliquer sur l’axe Y. |
Facteur d’échelle (axe z) |
|
[number Par défaut : 1 |
Valeur d’échelle (expansion ou contraction) à appliquer sur l’axe Z. |
Facteur d’échelle (valeurs m) |
|
[number Par défaut : 1 |
Valeur d’échelle (expansion ou contraction) à appliquer sur les valeurs m. |
Rotation autour de l’axe z (degrés dans le sens inverse des aiguilles d’une montre) |
|
[number Par défaut : 0 |
Angle de rotation en degrés. |
Transformé |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Transformé |
|
[identique à l’entrée] |
Couche vecteur de sortie (transformée). |
Code Python
ID de l’algorithme : native:affinetransform
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.
25.1.18.3. 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
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
expression Group by |
|
[champ : tout type] 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 |
[vecteur : tout type] |
Vous pouvez charger des champs d’une autre couche et les utiliser pour l’agrégation |
Agrégé |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie (agrégée)
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Agrégé |
|
[identique à l’entrée] |
Couche vectorielle multigeométrie avec les valeurs agrégées |
Code Python
ID de l’algorithme : native: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.
25.1.18.4. 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. 25.49 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. 25.50 Couche limite (points rouges) pour les lignes. En jaune une entité sélectionnée.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche vecteur ligne ou polygone en entrée |
limite |
|
[vecteur : point, ligne] Par défaut: |
Spécifiez la couche de sortie (limite). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
limite |
|
[vecteur : point, ligne] |
Limites de la couche d’entrée (point pour la ligne et ligne pour le polygone) |
Code Python
ID de l’algorithme : native: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.
25.1.18.5. Emprise
Calcule le rectangle d’encombrement (emprise) pour chaque entité de la couche en entrée. Polygones et lignes sont possibles.
Fig. 25.51 Les lignes noires représentent les rectangles d’encombrement de chaque entité.
Permet la modification de la couche source pour des entités de type polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche vecteur ligne ou polygone en entrée |
Bornes |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie (boîte englobante). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Bornes |
|
[vecteur : polygone] |
Boîtes de délimitation de la couche d’entrée |
Code Python
ID de l’algorithme : native: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.
25.1.18.6. 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. 25.52 Buffer (en jaune) de points, ligne et polygone
Permet la modification de la couche source pour des entités de type polygone
Menu par défaut:
Voir aussi
Variable distance buffer, Buffer multi-anneaux (distance constante), buffer à largeur variable (par valeur M)
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 Variable distance buffer). |
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 d’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. 25.53 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 :
Fig. 25.54 Round, miter, and bevel join styles |
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. 25.55 Tampon standard (gauche) et tampon fusionné (droite) |
Buffered |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vecteur : polygone] |
Couche de polygone de sortie (buffer) |
Code Python
ID de l’algorithme: native: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.
25.1.18.7. 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. 25.56 Les étoiles rouges représentent les centroïdes des caractéristiques de la couche d’entrée.
Permet la modification de la couche source pour des entités de type point
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 ** |
|
[vecteur : point] Par défaut: |
Spécifiez la couche de sortie (centroïde). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Centroids ** |
|
[vecteur : point] |
Couche vectorielle du point de sortie (centroïdes) |
Code Python
ID de l’algorithme: native: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.
25.1.18.8. 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 entités 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. 25.57 Gauche: la couche d’entrée. À droite: la couche valide (vert), la couche invalide (orange)
Menu par défaut:
Voir aussi
Correction des géométries et le plugin principal Extension Vérificateur de géométrie
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] 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 |
|
[identique à l’entrée] Par défaut: |
Couche vectorielle contenant une copie des entités non valides de la couche source avec le champ
L’encodage du fichier peut également être modifié ici. |
Sortie d’erreur |
|
[vecteur : 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nombre d’erreurs |
|
[number] |
Le nombre de géométries qui ont provoqué des erreurs. |
Sortie d’erreur |
|
[vecteur : 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 |
|
[identique à l’entrée] |
Couche vectorielle contenant une copie des entités non valides de la couche source avec le champ |
Nombre d’entités valides |
|
[number] |
Le nombre de géométries valides. |
Sortie valide |
|
[identique à l’entrée] |
Couche vectorielle contenant une copie des caractéristiques valides de la couche source. |
Code Python
ID de l’algorithme : 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.
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. |
|
25.1.18.9. 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.
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] |
Couche vectorielle avec des géométries collectées |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Collecté |
|
[identique à l’entrée] 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. |
Code Python
ID de l’algorithme: native: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.
25.1.18.10. Enveloppe concave (formes alpha)
Calcule l’enveloppe concave des entités dans une couche de points en entrée.
Fig. 25.58 Coques concaves avec différents seuils (0,3, 0,6, 0,9)
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche de points d’entrée |
|
[vecteur : 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 l’enveloppe 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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Coque concave |
|
[vecteur : polygone] |
Spécifiez la couche vectorielle de sortie |
Code Python
ID de l’algorithme : 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.
25.1.18.11. 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
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[champ : tout type] 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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Coque concave |
|
[vecteur : polygone] |
Spécifiez la couche vectorielle de sortie |
Code Python
ID de l’algorithme : 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.
25.1.18.12. 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.
La table attributaire de la couche de sortie est la même que celle de la couche d’entrée.
Toutes les conversions ne sont pas possibles. Par exemple, une couche de lignes peut être convertie en couche de points, mais une couche de points ne peut pas être convertie en une couche de lignes.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[vecteur : tout type] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Converti |
|
[vecteur : tout type] |
Couche vectorielle de sortie - le type dépend des paramètres |
Code Python
ID de l’algorithme : 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.
25.1.18.13. Convertir en géométries courbes
Converts a geometry into its curved geometry equivalent.
Already curved geometries will be retained without change.
Permet la modification de la couche source pour des entités de type ligne ou polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur: ligne, polygone] |
Couche vectorielle en entrée |
Tolérance de distance maximale |
|
[number] Default: 0.000001 |
The maximum distance allowed between the original location of vertices and where they would fall on the converted curved geometries |
Tolérance d’angle maximal |
|
[number] Default: 0.000001 |
Segments are considered as suitable for replacing with an arc if the points are all regularly spaced on the candidate arc. This parameter specifies the maximum angular deviation (in degrees) allowed when testing for regular point spacing. Between 0 and 45°. |
Courbes |
|
[vector: compoundcurve or curvepolygon] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Courbes |
|
[vector: compoundcurve or curvepolygon] |
Output vector layer with curved geometries |
Code Python
ID de l’algorithme : native:converttocurves
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.
25.1.18.14. 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. 25.59 Les lignes noires représentent les enveloppes convexes de chaque entité.
Permet la modification de la couche source pour des entités de type polygone
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Enveloppe convexe |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Enveloppe convexe |
|
[vecteur : polygone] |
La couche vectorielle de sortie (coque convexe) |
Code Python
ID de l’algorithme: native: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.
25.1.18.15. 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
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extent (xmin, xmax, ymin, ymax) |
|
[emprise] |
Étendue d’entrée Available methods are:
|
Extent |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extent |
|
[vecteur : polygone] |
Couche vectorielle de sortie (étendue) |
Code Python
ID de l’algorithme: native: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.
25.1.18.16. 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
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 |
|
[vecteur : point] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vecteur : point] |
Couche vectorielle du point de sortie contenant le point d’entrée. |
Code Python
ID de l’algorithme: native: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.
25.1.18.17. Créer des buffer compensés
Crée des buffer en forme de coin à partir des points d’entrée.
Fig. 25.60 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : 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. 25.61 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 calculée entre le point source et l’extrémité arrondie du cône. |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffers |
|
[vecteur : polygone] |
Couche vectorielle de sortie (tampon de coin) |
Code Python
ID de l’algorithme: native: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.
25.1.18.18. Triangulation de Delaunay
Crée une couche de polygones avec la triangulation de Delaunay correspondant à la couche de points d’entrée.
Fig. 25.62 Triangulation de Delaunay sur les points
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : point] |
Couche vecteur point en entrée |
Triangulation de Delaunay |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Triangulation de Delaunay |
|
[vecteur : polygone] |
La couche vectorielle de sortie (triangulation de Delaunay) |
Code Python
ID de l’algorithme : 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.
25.1.18.19. 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. 25.63 Avant et après le nettoyage
Permet la modification de la couche source pour des entités de type polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
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 superficie inférieure à ce seuil seront supprimés. Avec une valeur de |
Nettoyé |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nettoyé |
|
[identique à l’entrée] |
La couche vectorielle de sortie (nettoyée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.20. 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. 25.64 Les points rouges montrent les sommets avant et après la densification
Permet la modification de la couche source pour des entités de type ligne ou polygone
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche vecteur ligne ou polygone en entrée |
Vertex à ajouter |
|
[number] Par défaut : 1 |
Nombre de sommets à ajouter à chaque segment |
Densifié |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Densifié |
|
[identique à l’entrée] |
La couche vectorielle de sortie (densifiée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.21. 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. 25.65 Densifier la géométrie à un intervalle donné
Permet la modification de la couche source pour des entités de type ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Densifié |
|
[identique à l’entrée] |
La couche vectorielle de sortie (densifiée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.22. 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. 25.66 Regrouper la couche de polygones sur un attribut commun
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Dissous |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec des géométries dissoutes |
Code Python
ID de l’algorithme: native: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.
25.1.18.23. Draper (définir 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone ayant la coordonnée Z
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mis à jour |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec les valeurs Z de la couche raster |
Code Python
ID de l’algorithme: native: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.
25.1.18.24. Supprimer les valeurs M/Z.
Supprime les valeurs M (mesure) ou Z (altitude) des géométries en entrée.
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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** |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Z/M supprime** |
|
[identique à l’entrée] |
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). |
Code Python
ID de l’algorithme: native: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.
25.1.18.25. Éliminer 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.
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
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é |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Éliminé |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie. |
Code Python
ID de l’algorithme : 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.
25.1.18.26. 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. 25.67 La couche de ligne d’origine et celle éclatée
Permet la modification de la couche source pour des entités de type ligne
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Eclaté |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Eclaté |
|
[vecteur : ligne] |
Couche vectorielle de ligne de sortie avec des entités représentant chaque segment de la couche d’entrée. |
Code Python
ID de l’algorithme: native: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.
25.1.18.27. 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. 25.68 Les tirets rouges représentent l’extension initiale et finale de la couche d’origine
Permet la modification de la couche source pour des entités de type ligne
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Élargi |
|
[vecteur : ligne] |
Couche vectorielle de ligne de sortie (étendue). |
Code Python
ID de l’algorithme: native: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.
25.1.18.28. 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extrait |
|
[identique à l’entrée] |
La couche vectorielle de sortie (avec valeurs M) |
Code Python
ID de l’algorithme: native: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.
25.1.18.29. Extraire des vertex 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.
Permet la modification de la couche source pour des entités de type point
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Indices de vertex |
|
[string] Default: “0” |
Chaîne séparée par des virgules des indices des vertex à extraire. |
Vertex |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Vertex |
|
[vecteur : point] |
Couche vectorielle de sortie (point) contenant les vertex spécifiés à partir des géométries de la couche d’entrée. |
Code Python
ID de l’algorithme: native: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.
25.1.18.30. Extraire les vertex
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 points indiquant l’index du sommet (commençant à 0), la partie dans laquelle se trouve le sommet et son index dans la partie (ainsi que son anneau pour les polygones), la distance le long de la géométrie originale et l’angle de la bissectrice au niveau du sommet sur la géométrie d’origine.
Fig. 25.69 Vertex extraits pour la couche ligne et polygone
Permet la modification de la couche source pour des entités de type point
Menu par défaut:
Voir aussi
Extraire des vertex spécifiques, Filtrer les vertex par valeur M, Filtrer les vertex par valeur Z
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Vertex |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Vertex |
|
[vecteur : point] |
Couche vectorielle de sortie (point) contenant les sommets des géométries de la couche d’entrée. |
Code Python
ID de l’algorithme: native: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.
25.1.18.31. 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Extrait |
|
[identique à l’entrée] |
La couche vectorielle de sortie (avec des valeurs Z) |
Code Python
ID de l’algorithme: native: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.
25.1.18.32. Filtrer les vertex par valeur M
Filtre les vertex 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. 25.70 La ligne rouge représente la ligne noire avec uniquement des sommets dont la valeur M est <= 10.
Permet la modification de la couche source pour des entités de type ligne ou polygone ayant des valeurs M
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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche de vecteur ligne ou polygone d’entrée pour supprimer les vertex |
Minimum Optionnel |
|
[number Default: Not set |
Minimum de valeurs M autorisé |
Maximum Optionnel |
|
[number Default: Not set |
Maximum de M valeurs autorisées |
Filtré |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Filtré |
|
[identique à l’entrée] |
Couche vectorielle de sortie d’entités avec uniquement les vertex filtrés. |
Code Python
ID de l’algorithme: native: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.
25.1.18.33. Filtrer les vertex par valeur Z
Filtre les sommets en fonction de leur valeur Z, renvoyant des géométries avec uniquement des points ou sommets 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. 25.71 La ligne rouge représente la ligne noire avec uniquement des sommets dont la valeur Z est <= 10.
Permet la modification de la couche source pour des entités de type ligne ou polygone ayant des coordonnées Z
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é.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche de vecteur ligne ou polygone d’entrée pour supprimer les vertex |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Filtré |
|
[identique à l’entrée] |
Couche vectorielle de sortie d’entités avec uniquement les vertex filtrés. |
Code Python
ID de l’algorithme: native: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.
25.1.18.34. 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 vertex d’entrée. Les géométries déjà valides sont retournées sans autre intervention. Produit toujours une couche multi-géométrie.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone sans valeurs M
Note
Les valeurs M seront supprimées de la sortie.
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Corrections des geeométries |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Corrections des geeométries |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec les géométries corrigees. |
Code Python
ID de l’algorithme: native: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.
25.1.18.35. 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.
Permet la modification de la couche source pour des entités de type polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
Couche vectorielle en entrée |
Réorienté |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Réorienté |
|
[vecteur : polygone] |
Couche vectorielle de sortie avec des géométries réorientées. |
Code Python
ID de l’algorithme: native: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.
25.1.18.36. 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 sommets créés à l’antiméridien.
Permet la modification de la couche source pour des entités de type ligne
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Fractionner |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fractionner |
|
[vecteur : ligne] |
La couche de vecteur de ligne de sortie s’est divisée à l’antiméridien. |
Code Python
ID de l’algorithme: native: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.
25.1.18.37. 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[vecteur : tout type] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie modifiée |
|
[vecteur : tout type] |
Spécifiez la couche vectorielle de sortie |
Code Python
ID de l’algorithme: native: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.
25.1.18.38. Interpoler le point sur la 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. 25.72 Point interpolé à 500 m du début de la ligne
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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 |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Points interpolés |
|
[vecteur : 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 |
Code Python
ID de l’algorithme: native: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.
25.1.18.39. 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. 25.73 Dans le sens horaire à partir du haut à gauche: entité originale en plusieurs parties, une, deux et trois plus grandes parties conservées
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones |
|
[vecteur : polygone] |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Les parties |
|
[vecteur : polygone] |
La couche vectorielle de polygone en sortie avec les N plus grandes parties de chaque entité |
Code Python
ID de l’algorithme : 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.
25.1.18.40. 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. 25.74 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 pour des entités de type ligne
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Portion |
|
[vecteur : ligne] |
Couche de vecteur de ligne de sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.41. 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 d’entrée.
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Polygones |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie. |
Code Python
ID de l’algorithme : 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.
25.1.18.42. 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 pour des entités de type ligne
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Fusionné |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fusionné |
|
[vecteur : ligne] |
Couche de vecteur de ligne de sortie (fusionnée). |
Code Python
ID de l’algorithme: native: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.
25.1.18.43. 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. 25.75 Dans le sens horaire à partir du haut à gauche: enveloppe, rectangle orienté, cercle, enveloppe convexe
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Champ Optionnel |
|
[champ : tout type] |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie englobante |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie (englobante). |
Code Python
ID de l’algorithme : 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.
25.1.18.44. Cercles englobants minimum
Calcule le nombre minimum de cercles englobants des entités dans la couche d’entrée.
Fig. 25.76 Cercles fermés pour chaque entité
Permet la modification de la couche source pour des entités de type polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Cercles englobants minimum |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.45. 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. 25.77 Buffer multi-anneaux pour une couche de lignes, de points et de polygones
Permet la modification de la couche source pour des entités de type polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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) |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffer multi-anneaux (distance constante) |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.46. 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. 25.78 A gauche la couche source en plusieurs parties et à droite le résultat en partie unique
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Monoparties |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Monoparties |
|
[identique à l’entrée] |
La couche de vecteur de sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.47. 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. 25.79 En bleu la couche source, en rouge celui décalé
Permet la modification de la couche source pour des entités de type ligne
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 Variable distance buffer). |
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 :
Fig. 25.80 Round, miter, and bevel join styles |
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 |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche de sortie (décalage). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Décalage |
|
[vecteur : ligne] |
Couche de ligne de sortie (offset) |
Code Python
ID de l’algorithme: native: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.
25.1.18.48. 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. 25.81 Boîte de délimitation minimale orientée
Permet la modification de la couche source pour des entités de type polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Etendues |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Etendues |
|
[vecteur : polygone] |
Couche vectorielle de polygone en sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.49. 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. 25.82 En bleu la couche source et en rouge le résultat orthogonalisé
Permet la modification de la couche source pour des entités de type ligne ou polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Orthogonalisé |
|
[identique à l’entrée] |
Couche vectorielle de polygone en sortie avec angles ajustés. |
Code Python
ID de l’algorithme : native: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.
25.1.18.50. 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 pour des entités de type point
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle du point de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vecteur : point] |
Couche vectorielle du point de sortie. |
Code Python
ID de l’algorithme: native: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.
25.1.18.51. 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. 25.83 Points créés le long d la couche de ligne source
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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 |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Points interpolés |
|
[vecteur : 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. |
Code Python
ID de l’algorithme: native: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.
25.1.18.52. 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : 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é |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Déplacé |
|
[vecteur : point] |
Couche vectorielle de point de sortie |
Code Python
ID de l’algorithme : 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.
25.1.18.53. 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. 25.84 Pôle d’inaccessibilité
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
Couche vectorielle en entrée |
Tolerance |
|
[number] Par défaut : 1.0 |
Définit la tolérance pour le calcul |
Point |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Point |
|
[vecteur : point] |
La couche vectorielle de point de sortie |
Code Python
ID de l’algorithme: native: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.
25.1.18.54. 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. 25.85 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Keep fields from the input layer Optionnel |
|
[boolean] Par défaut : Faux |
Check to keep the fields (only the table structure, not the values) of the input layer |
Polygones à partir de lignes |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de polygone en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones à partir de lignes |
|
[vecteur : polygone] |
La couche vectorielle de polygone en sortie à partir des lignes |
Code Python
ID de l’algorithme: native: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.
25.1.18.55. 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.
La table attributaire de la couche de sortie est la même que celle de la couche d’entrée.
Fig. 25.86 Lignes noires résultant de l’algorithme
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
Couche de vecteur de polygone en entrée |
Lignes |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Lignes |
|
[vecteur : ligne] |
La couche vectorielle de lignes extraites des polygones |
Code Python
ID de l’algorithme: native: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.
25.1.18.56. 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 pour des entités de type point
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : 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é |
|
[vecteur : point] Par défaut: |
Spécifiez la couche vectorielle du point de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Projeté |
|
[vecteur : point] |
Couche vectorielle de points de sortie (projetée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.57. 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 pour des entités de type point, ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Multiparties |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle multipart en sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Multiparties |
|
[identique à l’entrée] |
La couche vectorielle de sortie en plusieurs parties |
Code Python
ID de l’algorithme: native: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.
25.1.18.58. Rectangles, ovales, diamants
Crée une zone tampon avec une forme rectangulaire, ovale ou en losange pour chaque entité de la couche de points entrée.
Les paramètres de forme peuvent être fixés pour toutes les entités ou être dynamiques en utilisant un champ ou une expression.
Fig. 25.87 Différentes formes de tampons avec des paramètres dynamiques
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : 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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Rendu |
|
[vecteur : polygone] |
La couche vectorielle de sortie (avec les formes du buffer) |
Code Python
ID de l’algorithme: native: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.
25.1.18.59. Supprimer les vertex en double
Supprime les vertex en double des entités, partout où la suppression des vertex 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Note
Les vertex 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.
Voir aussi
Extraire les vertex, Extraire des vertex spécifiques, Supprimer les géométries dupliquées
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Tolerance |
|
[number Default: 0.000001 |
Les vertex 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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Nettoyé |
|
[identique à l’entrée] |
La couche vectorielle de sortie (sans vertex en double) |
Code Python
ID de l’algorithme: native: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.
25.1.18.60. Supprimer les géométries nulles
Supprime les éléments qui n’ont pas de géométrie d’une couche vecteur. Toutes les autres entités seront copiées sans modification.
Les entités avec des géométries nulles peuvent être enregistrées sur une couche distincte.
Si Supprimer également les géométries vides est cochée, l’algorithme supprime les entités dont les géométries n’ont pas de coordonnées, c’est-à-dire les géométries qui sont vides. Dans ce cas, la sortie null reflétera également cette option, contenant à la fois des géométries nulles et vides.
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée (avec des géométries non NULL) |
Egalement supprimer les géométries vides |
|
[boolean] |
|
Géométries non nulles |
Optionnel |
[identique à l’entrée] Par défaut: |
Spécifiez la couche de vecteur de sortie pour les géométries non NULL (et non vides). L’un des :
L’encodage du fichier peut également être modifié ici. |
Géométries nulles Optionnel |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vecteur de sortie pour les géométries NULL (et vides). L’un des :
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométries nulles |
|
[identique à l’entrée] |
Couche vecteur de sortie (pour les géométries NULL et, si elles sont choisies, vides) |
Géométries non nulles |
|
[identique à l’entrée] |
La couche de vecteurs de sortie (sans NULL et, si elle est choisie, des géométries vides) |
Code Python
ID de l’algorithme: native: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.
25.1.18.61. Inverser la direction de la ligne
Inverse la direction d’une couche de ligne.
Fig. 25.88 Avant et après l’inversion de direction
Permet la modification de la couche source pour des entités de type ligne
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Renversé |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Renversé |
|
[vecteur : ligne] |
La couche de vecteur de ligne de sortie (avec des lignes inversées) |
Code Python
ID de l’algorithme: native: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.
25.1.18.62. Rotation
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 pour des entités de type point, ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Tourné |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec des géométries pivotées |
Code Python
ID de l’algorithme: native: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.
25.1.18.63. Segmentation 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 vertex 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 vertex 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
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
Couche vecteur ligne ou polygone en entrée |
Angle maximum entre les vertex (degrés) |
|
[number Default: 5.0 |
Angle de rayon maximal autorisé entre les vertex de la géométrie redressée |
Segmenté |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Segmenté |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec des géométries segmentées |
Code Python
ID de l’algorithme: native: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.
25.1.18.64. Segmentation 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
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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é |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Segmenté |
|
[identique à l’entrée] |
La couche vectorielle de sortie avec des géométries segmentées |
Code Python
ID de l’algorithme: native: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.
25.1.18.65. 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone ayant des valeurs M
Astuce
Utilisez le bouton 
Identifier les entités 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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
M ajouté |
|
[identique à l’entrée] |
La couche vectorielle de sortie (avec M valeurs affectées aux géométries) |
Code Python
ID de l’algorithme: native: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.
25.1.18.66. 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone ayant des valeurs M
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mis à jour |
|
[identique à l’entrée] |
La couche vectorielle de sortie (avec les valeurs M mises à jour) |
Code Python
ID de l’algorithme: native: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.
25.1.18.67. 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone ayant la coordonnée Z
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.
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Z ajouté |
|
[identique à l’entrée] |
La couche vectorielle de sortie (avec des valeurs Z attribuées) |
Code Python
ID de l’algorithme: native: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.
25.1.18.68. 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 vertex 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. 25.89 Dans le sens horaire à partir du haut à gauche: couche source et augmentation des tolérances de simplification
Permet la modification de la couche source pour des entités de type ligne ou polygone
Menu par défaut:
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie (simplifiée). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Simplifié |
|
[identique à l’entrée] |
La couche vectorielle de sortie (simplifiée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.69. 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. 25.90 Tampon gauche ou droit sur la même couche de lignes vectorielles
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
Couche vectorielle de ligne d’entrée |
Distance |
|
[number] Par défaut : 10.0 |
Distance buffer. |
Côté |
|
[enumeration] Par défaut : 0 |
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] 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 :
Fig. 25.91 Round, miter, and bevel join styles |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffer |
|
[vecteur : polygone] |
Couche de polygone de sortie (buffer) |
Code Python
ID de l’algorithme: native: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.
25.1.18.70. Lisser
Lisse les géométries d’une couche de lignes ou de polygones en ajoutant plus de vertex 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. 25.92 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. 25.93 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 pour des entités de type ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne, polygone] |
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 vertex). |
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é ** |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie (lissé). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
** Lissé ** |
|
[identique à l’entrée] |
Couche vectorielle de sortie (lissée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.71. 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
Couche vectorielle en entrée |
Couche de référence |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie (accrochée). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Géométrie accroché |
|
[identique à l’entrée] |
Couche vectorielle de sortie (accrochée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.72. 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.
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Note
L’accrochage à la grille peut générer une géométrie non valide dans certains cas d’angle.
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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é |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche de sortie (accrochée). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Accroché |
|
[identique à l’entrée] |
Couche vectorielle de sortie (accrochée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.73. 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.
Permet la modification de la couche source pour des entités de type ligne
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche vectorielle de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Fractionner |
|
[vecteur : ligne] |
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. |
Code Python
ID de l’algorithme: native: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.
25.1.18.74. Subdiviser
Subdivise la géométrie. La géométrie renvoyée sera une collection contenant des parties subdivisées de la géométrie d’origine, où aucune partie 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. 25.94 À gauche de la couche d’entrée, la valeur maximale des nœuds centraux est 100 et la valeur maximale droite est 200
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Note
La subdivision d’une géométrie peut générer des parties de géométrie qui peuvent ne pas être valides et peuvent contenir des auto-intersections.
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 partie géométrique peut avoir. Moins de sous-parties pour des valeurs plus élevées. |
Subdivisé |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie (subdivisé). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Subdivisé |
|
[identique à l’entrée] |
Couche vectorielle de sortie |
Code Python
ID de l’algorithme: native: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.
25.1.18.75. 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 pour des entités de type point, ligne ou polygone
Voir aussi
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
La couche de vecteur d’entrée |
Échangé |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Échangé |
|
[identique à l’entrée] |
Couche vectorielle de sortie (permutée) |
Code Python
ID de l’algorithme: native: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.
25.1.18.76. 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. 25.95 Exemple de buffer conique
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vecteur : polygone] |
Couche de polygone de sortie (buffer) |
Code Python
ID de l’algorithme: native: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.
25.1.18.77. 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. 25.96 Polygone en mosaïque (à droite)
Permet la modification de la couche source pour des entités de type polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : polygone] |
Couche de vecteur de polygone en entrée |
Mosaïqué |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Mosaïqué |
|
[vecteur : polygone] |
Couche multipolygoneZ en sortie |
Code Python
ID de l’algorithme: 3d: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.
25.1.18.78. 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’entité 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. 25.97 Les lignes rouges en pointillés représentent le transect de la couche de ligne d’entrée
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : ligne] Par défaut: |
Spécifiez la couche de ligne de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Transect |
|
[vecteur : ligne] |
Couche de ligne de sortie |
Code Python
ID de l’algorithme: native: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.
25.1.18.79. Translater
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. 25.98 Les lignes pointillées représentent la géométrie traduite de la couche d’entrée
Permet la modification de la couche source pour des entités de type point, ligne ou polygone
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : tout type] |
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 |
|
[identique à l’entrée] Par défaut: |
Spécifiez la couche vectorielle de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Traduit |
|
[identique à l’entrée] |
Couche vectorielle de sortie |
Code Python
ID de l’algorithme: native: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.
25.1.18.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. 25.99 Exemple de buffer variable
Voir aussi
Tampons coniques, Tampon, Définir la valeur M, Variable distance buffer
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : ligne] |
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 |
|
[vecteur : polygone] Par défaut: |
Spécifiez la couche de sortie (buffer). Un des:
L’encodage du fichier peut également être modifié ici. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Buffered |
|
[vecteur : polygone] |
Couche de polygone buffer variable |
Code Python
ID de l’algorithme: native: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.
25.1.18.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. 25.100 Polygones de Voronoi
Menu par défaut:
Paramètres
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Couche en entrée |
|
[vecteur : 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ï |
|
[vecteur : polygone] 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. |
Sorties
Étiquette |
Nom |
Type |
Description |
|---|---|---|---|
Polygones de Voronoï |
|
[vecteur : polygone] |
Polygones de Voronoï de la couche vectorielle de points d’entrée |
Code Python
ID de l’algorithme : 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.