23.1.13. Création de vecteurs¶
23.1.13.1. Tableau de lignes décalées (parallèles)¶
Crée des copies des entités linéaires dans une couche, en créant plusieurs versions décalées de chaque entité. Chaque nouvelle version est décalée de manière incrémentielle d’une distance spécifiée.
Une distance positive décalera les lignes vers la gauche et les distances négatives les décaleront vers la droite.
Permet la modification de la couche source
Voir aussi
23.1.13.1.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche en entrée |
|
[vector: line] |
Couche vecteur ligne d’entrée à utiliser pour les décalages. |
Nombre d’entités à créer |
|
Par défaut : 10 |
Nombre de copies offset à générer pour chaque entité |
Distance de pas de décalage |
|
Par défaut : 1.0 |
Distance entre deux copies offset consécutives |
Segments |
|
[number] Par défaut : 8 |
Nombre de segments de ligne à utiliser pour approximer un quart de cercle lors de la création de décalages arrondis |
Style de jointure |
|
[enumeration] Par défaut : 0 |
Spécifiez si les jointures arrondies, à onglet ou biseautées doivent être utilisées lors du décalage des coins d’une ligne. Un des:
|
Limite d’onglet |
|
[number] Par défaut : 2.0 |
S’applique uniquement aux styles de jointure à onglets et contrôle la distance maximale à partir de la courbe de décalage à utiliser lors de la création d’une jointure à onglets. |
Lignes décalées |
|
[vector: line] Par défaut: |
Spécifiez la couche de ligne de sortie avec des fonctions de décalage. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.1.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Lignes décalées |
|
[vector: line] |
Couche de ligne de sortie avec des fonctions de décalage. Les entités d’origine sont également copiées. |
23.1.13.1.3. Code Python¶
Algorithm ID: qgis:arrayoffsetlines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.2. Tableau d’entités traduites¶
Crée des copies d’entités dans une couche en créant plusieurs versions traduites de chacune. Chaque copie est déplacée de manière incrémentielle d’une quantité prédéfinie sur les axes X, Y et/ou Z.
Les valeurs M présentes dans la géométrie peuvent également être traduites.
Permet la modification de la couche source
Voir aussi
23.1.13.2.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle d’entrée à traduire |
Nombre d’entités à créer |
|
Par défaut : 10 |
Nombre de copies à générer pour chaque entite |
Distance de pas (axe x) |
|
Par défaut : 0.0 |
Déplacement à appliquer sur l’axe X |
Distance de pas (axe y) |
|
Par défaut : 0.0 |
Déplacement à appliquer sur l’axe Y |
Distance de pas (axe z) |
|
Par défaut : 0.0 |
Déplacement à appliquer sur l’axe Z |
Distance de pas (valeurs m) |
|
Par défaut : 0.0 |
Déplacement à appliquer sur M |
Traduit |
|
[same as input] Par défaut: |
Couche vectorielle de sortie avec des copies traduites (déplacées) des entités. Les entités d’origine sont également copiées. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.2.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Traduit |
|
[same as input] |
Couche vectorielle de sortie avec des copies traduites (déplacées) des entités. Les entités d’origine sont également copiées. |
23.1.13.2.3. Code Python¶
Algorithm ID: qgis:arraytranslatedfeatures
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.3. Créer une grille¶
Crée une couche vectorielle avec une grille couvrant une étendue donnée. Les cellules de la grille peuvent avoir différentes formes:
La taille de chaque élément de la grille est définie à l’aide d’un espacement horizontal et vertical.
Le SCR de la couche de sortie doit être défini.
L’étendue de la grille et les valeurs d’espacement doivent être exprimées dans les coordonnées et les unités de ce SCR.
Default menu:
23.1.13.3.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Type de grille |
|
[enumeration] Par défaut : 0 |
Forme de la grille. Un des:
|
Étendue de la grille |
|
[emprise] |
Étendue de la grille |
Espacement horizontal |
|
[number] Par défaut : 1.0 |
Taille d’une cellule de grille sur l’axe X |
Espacement vertical |
|
[number] Par défaut : 1.0 |
Taille d’une cellule de grille sur l’axe Y |
Superposition horizontale |
|
[number] Par défaut : 0.0 |
Superposition de la distance entre deux cellules de grille consécutives sur l’axe X |
Superposition verticale |
|
[number] Par défaut : 0.0 |
Superposition de la distance entre deux cellules de grille consécutives sur l’axe Y |
SCR grille |
|
[crs] Default: Project CRS |
Système de référence de coordonnées à appliquer à la grille |
la grille |
|
[vector: any] Par défaut: |
Couche de grille vectorielle résultante. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.3.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
la grille |
|
[vector: any] |
Couche de grille vectorielle résultante. Le type de géométrie en sortie (point, ligne ou polygone) dépend du type de grille. |
23.1.13.3.3. Code Python¶
Algorithm ID: qgis:creategrid
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.4. Créer une couche de points à partir de la table¶
Crée une couche de points à partir d’une table avec des colonnes contenant des champs de coordonnées.
Outre les coordonnées X et Y, vous pouvez également spécifier des champs Z et M.
23.1.13.4.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche en entrée |
|
[vector: any] |
Couche vectorielle ou table en entrée. |
Champ X |
|
[tablefield: any] |
Champ contenant la coordonnée X |
Champ Y |
|
[tablefield: any] |
Champ contenant la coordonnée Y |
Champ Z Optionnel |
|
[tablefield: any] |
Champ contenant la coordonnée Z |
Champ M Optionnel |
|
[tablefield: any] |
Champ contenant la valeur M |
SCR cible |
|
[crs] Par défaut : |
Système de référence de coordonnées à utiliser pour la couche. Les coordonnées fournies sont supposées conformes. |
Points de la table |
|
[vector: point] Par défaut: |
Spécifiez la couche de points résultante. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.4.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points de la table |
|
[vector: point] |
La couche de points résultante |
23.1.13.4.3. Code Python¶
Algorithm ID: qgis:createpointslayerfromtable
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.5. Générer des points (centroïdes de pixels) le long de la ligne¶
Génère une couche vectorielle ponctuelle à partir d’une couche raster et linéaire en entrée.
Les points correspondent aux centroïdes de pixels qui coupent la couche de ligne.
23.1.13.5.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche raster |
|
[raster] |
Couche raster source |
Couche vectorielle |
|
[vector: line] |
Couche vectorielle de ligne en entrée |
Points le long de la ligne |
|
[vector: point] Par défaut: |
Couche de points résultante avec centroïdes de pixels. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.5.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points le long de la ligne |
|
[vector: point] |
Couche de points résultante avec centroïdes de pixels |
23.1.13.5.3. Code Python¶
Algorithm ID: qgis:generatepointspixelcentroidsalongline
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.6. Générer des points (centroïdes de pixels) à l’intérieur du polygone¶
Génère une couche vectorielle ponctuelle à partir d’une couche raster et polygone en entrée.
Les points correspondent aux centroïdes de pixels qui coupent la couche de polygones.
23.1.13.6.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche raster |
|
[raster] |
Couche raster source |
Couche vectorielle |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Points à l’intérieur des polygones |
|
[vector: point] Par défaut: |
Couche de points résultante de centroïdes de pixels. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.6.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points à l’intérieur des polygones |
|
[vector: point] |
Couche de points résultante de centroïdes de pixels |
23.1.13.6.3. Code Python¶
Algorithm ID: qgis:generatepointspixelcentroidsinsidepolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.7. Importer des photos géolocalisées¶
Crée une couche de points correspondant aux emplacements géomarqués à partir d’images JPEG à partir d’un dossier source.
La couche de points contiendra une seule entité PointZ par fichier d’entrée à partir de laquelle les balises géographiques pourraient être lues. Toutes les informations d’altitude des géotags seront utilisées pour définir la valeur Z du point.
Outre la longitude et la latitude, les informations d’altitude, de direction et d’horodatage, si elles sont présentes sur la photo, seront ajoutées au point en tant qu’attributs.
23.1.13.7.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Dossier d’entrée |
|
[folder] |
Chemin d’accès au dossier source contenant les photos géolocalisées |
Scanner récursivement |
|
[boolean] Par défaut : Faux |
Si coché, le dossier et ses sous-dossiers seront analysés |
Photos |
|
[vector: point] Par défaut: |
Spécifiez la couche vecteur de points pour les photos géomarquées. Un des:
L’encodage du fichier peut également être modifié ici. |
Table de photos non valide Optionnel |
|
[table] Par défaut: |
Spécifiez la table des photos illisibles ou non géolocalisées. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.7.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Photos |
|
[vector: point] |
Couche vectorielle ponctuelle avec photos géomarquées. La forme de la couche est automatiquement remplie de chemins et de paramètres d’aperçu des photos. |
Table de photos non valide Optionnel |
|
[table] |
Une table de photos illisibles ou non géolocalisées peut également être créé. |
23.1.13.7.3. Code Python¶
Algorithm ID: qgis:importphotos
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.8. Points à suivre¶
Convertit une couche de points en une couche de lignes, en joignant les points dans un ordre défini par un champ dans la couche de points d’entrée (si le champ d’ordre est un champ date/heure, le format doit être spécifié).
Les points peuvent être regroupés par un champ pour distinguer les entités linéaires.
En plus de la couche vecteur de ligne, un fichier texte est généré qui décrit la ligne résultante comme un point de départ et une séquence de relèvements/directions (par rapport à l’azimut) et de distances.
23.1.13.8.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche de points d’entrée |
|
[vector: point] |
Couche vecteur point en entrée |
Champ ordre |
|
[tablefield: any] |
Champ contenant l’ordre de connexion des points dans le chemin |
Champ de groupage Optionnel |
|
[tablefield: any] |
Les entités ponctuelles de même valeur dans le champ seront regroupées sur la même ligne. S’il n’est pas défini, un seul chemin est tracé avec tous les points d’entrée. |
Format de date (si le champ de commande est DateTime) Optionnel |
|
[string] |
Le format à utiliser pour le paramètre |
Chemins |
|
[vector: line] Par défaut: |
Spécifiez la couche vecteur de ligne du chemin. Un des:
L’encodage du fichier peut également être modifié ici. |
Répertoire pour la sortie texte |
|
[folder] Par défaut: |
Spécifiez le répertoire qui contiendra les fichiers de description des points et des chemins. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.8.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Chemins |
|
[vector: line] |
Couche vecteur de ligne du chemin |
Répertoire pour la sortie texte |
|
[folder] |
Répertoire contenant les fichiers de description des points et des chemins |
23.1.13.8.3. Code Python¶
Algorithm ID: qgis:pointstopath
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.9. Points aléatoires le long de la ligne¶
Crée une nouvelle couche points, avec des points placés dans les lignes d’une autre couche.
Pour chaque ligne de la couche d’entrée, un nombre donné de points est ajouté à la couche résultante. Une distance minimale peut être spécifiée, pour éviter que les points ne soient trop proches les uns des autres.
23.1.13.9.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche de points d’entrée |
|
[vector: line] |
Couche vectorielle de ligne en entrée |
Nombre de points |
|
[number] Par défaut : 1 |
Nombre de points à créer |
Distance minimale entre les points |
|
[number] Par défaut : 0.0 |
La distance minimale entre les points |
Points aléatoires |
|
[vector: point] Par défaut: |
Les points aléatoires de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.9.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points aléatoires |
|
[vector: point] |
Couche de points aléatoires en sortie. |
23.1.13.9.3. Code Python¶
Algorithm ID: qgis:qgisrandompointsalongline
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.10. Points aléatoires dans l’étendue¶
Crée une nouvelle couche de points avec un nombre donné de points aléatoires, tous dans une étendue donnée.
Une distance minimale peut être spécifiée pour éviter que les points ne soient trop proches les uns des autres.
Default menu:
23.1.13.10.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Étendue en entrée |
|
[emprise] |
Étendue de la carte pour les points aléatoires |
Nombre de points |
|
[number] Par défaut : 1 |
Nombre de points à créer |
Distance minimale entre les points |
|
[number] Par défaut : 0.0 |
La distance minimale entre les points |
SCR cible |
|
[crs] Default: Project CRS |
SCR de la couche de points aléatoires |
Points aléatoires |
|
[vector: point] Par défaut: |
Les points aléatoires de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.10.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points aléatoires |
|
[vector: point] |
Couche de points aléatoires en sortie. |
23.1.13.10.3. Code Python¶
Algorithm ID: qgis:randompointsinextent
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.11. Points aléatoires dans les limites de la couche¶
Crée une nouvelle couche de points avec un nombre donné de points aléatoires, tous dans l’étendue d’une couche donnée.
Une distance minimale peut être spécifiée pour éviter que les points ne soient trop proches les uns des autres.
Default menu:
23.1.13.11.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de polygone d’entrée définissant la zone |
Nombre de points |
|
[number] Par défaut : 1 |
Nombre de points à créer |
Distance minimale entre les points |
|
[number] Par défaut : 0.0 |
La distance minimale entre les points |
Points aléatoires |
|
[vector: point] Par défaut: |
Les points aléatoires de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.11.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points aléatoires |
|
[vector: point] |
Couche de points aléatoires en sortie. |
23.1.13.11.3. Code Python¶
Algorithm ID: qgis:randompointsinlayerbounds
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.12. Points aléatoires à l’intérieur des polygones¶
Crée une nouvelle couche de points avec un nombre donné de points aléatoires à l’intérieur de chaque polygone de la couche de polygones en entrée.
Deux stratégies d’échantillonnage sont disponibles:
Nombre de points: nombre de points pour chaque entite
Densité de points: densité de points pour chaque entité
Une distance minimale peut être spécifiée pour éviter que les points ne soient trop proches les uns des autres.
Default menu:
23.1.13.12.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche en entrée |
|
[vector: polygon] |
Couche de vecteur de polygone en entrée |
Stratégie d’échantillonnage |
|
[enumeration] Par défaut : 0 |
Stratégie d’échantillonnage à utiliser. Un des:
|
Nombre de points ou densité |
|
Par défaut : 1.0 |
Le nombre ou la densité de points, selon le choix Stratégie d’échantillonnage. |
Distance minimale entre les points |
|
[number] Par défaut : 0.0 |
La distance minimale entre les points |
Points aléatoires |
|
[vector: point] Par défaut: |
Les points aléatoires de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.12.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points aléatoires |
|
[vector: point] |
Couche de points aléatoires en sortie. |
23.1.13.12.3. Code Python¶
Algorithm ID: qgis:randompointsinsidepolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.13. Pixels raster en points¶
Crée une couche vectorielle de points correspondant à chaque pixel d’une couche raster.
Convertit une couche raster en couche vecteur, en créant des entités ponctuelles pour le centre de chaque pixel individuel dans la couche raster. Tous les pixels nodata sont ignorés dans la sortie.
23.1.13.13.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche raster |
|
[raster] |
Couche raster source |
Numéro de bande |
|
[raster band] |
Bande raster pour extraire des données de |
Nom du champ |
|
[string] Default: “VALUE” |
Nom du champ pour stocker la valeur de la bande raster |
Points vecteur |
|
[vector: point] Par défaut: |
Spécifiez la couche de points résultante des pixels centroïdes. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.13.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points vecteur |
|
[vector: point] |
Couche de points résultante avec pixels centroïdes |
23.1.13.13.3. Code Python¶
Algorithm ID: qgis:pixelstopoints
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.14. Raster pixellisés en polygones¶
Crée une couche vectorielle de polygones correspondant à chaque pixel d’une couche raster.
Convertit une couche raster en couche vecteur, en créant des entités surfaciques pour l’étendue de chaque pixel individuel dans la couche raster. Tous les pixels nodata sont ignorés dans la sortie.
23.1.13.14.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Couche raster |
|
[raster] |
Couche raster source |
Numéro de bande |
|
[raster band] |
Bande raster pour extraire des données de |
Nom du champ |
|
[string] Default: “VALUE” |
Nom du champ pour stocker la valeur de la bande raster |
Polygones vectoriels |
|
[vector: polygon] Par défaut: |
Spécifiez la couche de polygones résultante d’étendues de pixels. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.14.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Polygones vectoriels |
|
[vector: polygon] |
Couche de polygones résultante d’étendues de pixels |
23.1.13.14.3. Code Python¶
Algorithm ID: qgis:pixelstopolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L”id de l’algorithme est affiché lors du survol du nom de l’algorithme dans la boîte à outils Traitements. Les nom et valeur de chaque paramètre sont fournis via un dictionnaire de paramètres. Voir Utiliser les algorithmes du module de traitements depuis la console Python pour plus de détails sur l’exécution d’algorithmes via la console Python.
23.1.13.15. Points réguliers¶
Crée une nouvelle couche de points avec ses points placés dans une grille régulière dans une étendue donnée.
La grille est spécifiée soit par l’espacement entre les points (même espacement pour toutes les dimensions) soit par le nombre de points à générer. Dans ce dernier cas, l’espacement sera déterminé à partir de l’étendue. Afin de générer une grille rectangulaire complète, au moins le nombre de points spécifié par l’utilisateur est généré pour ce dernier cas.
Des décalages aléatoires de l’espacement des points peuvent être appliqués, résultant en un motif de points non régulier.
Default menu:
23.1.13.15.1. Paramètres¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Étendue d’entrée (xmin, xmax, ymin, ymax) |
|
[emprise] |
Étendue de la carte pour les points aléatoires |
Espacement / comptage des points |
|
[number] Par défaut : 100 |
Espacement entre les points, ou le nombre de points, selon que |
Encart initial du coin (côté gauche) |
|
[number] Par défaut : 0.0 |
Décale les points par rapport au coin supérieur gauche. La valeur est utilisée pour les axes X et Y. |
Appliquer un décalage aléatoire à l’espacement des points |
|
[boolean] Par défaut : Faux |
Si coché, les points auront un espacement aléatoire |
Utiliser l’espacement des points |
|
[boolean] Par défaut : Vrai |
Si cette case n’est pas cochée, l’espacement des points n’est pas pris en compte |
SCR de la couche en sortie |
|
[crs] Default: Project CRS |
SCR de la couche de points aléatoires |
Points réguliers |
|
[vector: point] Par défaut: |
Spécifiez la couche de points régulier de sortie. Un des:
L’encodage du fichier peut également être modifié ici. |
23.1.13.15.2. Sorties¶
Étiquette |
Nom |
Type |
Description |
---|---|---|---|
Points réguliers |
|
[vector: point] |
Couche de points régulier en sortie. |
23.1.13.15.3. Code Python¶
Algorithm ID: qgis:regularpoints
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.