27.1.18. Geometria vettore
27.1.18.1. Aggiungi attributi della geometria
Calcola le proprietà geometriche degli elementi in un vettore e le include nel layer in uscita.
Si genera un nuovo vettore con gli stessi contenuti del livello in ingresso, ma con attributi aggiuntivi contenenti le misure geometriche basate sul SR selezionato.
Gli attributi aggiunti alla tabella dipendono dal tipo di geometria e dimensioni del vettore in ingresso:
per layer puntuali: coordinate X (
xcoord), Y (ycoord), Z (zcoord) e/o valore M (mvalue)per layer lineari:
lunghezzae, per geometrie di tipo LineString e CompoundCurve, lasinuositàdegli elementi e la distanza rettilinea (straightdis)per layer poligonali:
perimetroearea
Menu predefinito:
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Calcola usando |
|
[enumeration] Predefinito: 0 |
Parametri di calcolo da usare per le proprietà geometriche. Uno tra:
|
Informazioni geometriche aggiunte |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (copia di quello in ingresso con informazioni geometriche). Uno tra:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Informazioni geometriche aggiunte |
|
[same as input] |
Copia del layer vettoriale in ingresso con l’aggiunta dei campi della geometria |
Codice Python
ID Algoritmo: qgis:exportaddgeometrycolumns
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.2. Trasformazione affine
Applica una trasformazione affine alle geometrie del layer. Le trasformazioni affini possono includere traslazione, scalatura e rotazione. Le operazioni vengono eseguite nel seguente ordine: scala, rotazione e traslazione.
I valori Z e M (se presenti) possono essere traslati e scalati.
Fig. 27.50 Layer vettoriale punto (punti verdi) prima (a sinistra) e dopo (a destra) una trasformazione affine (traslazione).
Permette features in-place modification di punti, linee e poligoni
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Traslazione (asse x) |
|
[number Predefinito: 0 |
Spostamento da applicare sull’asse X. |
Traslazione (asse-y) |
|
[number Predefinito: 0 |
Spostamento da applicare sull’asse Y. |
Traslazione (asse-z) |
|
[number Predefinito: 0 |
Spostamento da applicare sull’asse Z. |
Traslazione (valori-m) |
|
[number Predefinito: 0 |
Offset da applicare ai valori m. |
Fattore di scala (asse-x) |
|
[number Predefinito: 1 |
Valore di scala (espansione o contrazione) da applicare sull’asse X. |
Fattore di scala (asse-y) |
|
[number Predefinito: 1 |
Valore di scala (espansione o contrazione) da applicare sull’asse Y. |
Fattore di scala (asse-z) |
|
[number Predefinito: 1 |
Valore di scala (espansione o contrazione) da applicare sull’asse Z. |
Fattore di scala (valore-m) |
|
[number Predefinito: 1 |
Il valore della scala (espansione o contrazione) da applicare ai valori m. |
Rotazione intorno all’asse z (gradi in senso antiorario) |
|
[number Predefinito: 0 |
Angolo di rotazione in gradi. |
Trasformato |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Trasformato |
|
[same as input] |
Layer vettoriale in uscita (trasformato) |
Codice Python
ID Algoritmo: native:affinetransform
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.3. Aggrega
Prende un vettore o una tabella e crea un nuovo layer aggregando gli elementi basati su un’espressione di tipo raggruppa in base a
Gli elementi per cui l’espressione ID univoco restituisce lo stesso valore sono raggruppati insieme.
È possibile raggruppare insieme tutti gli elementi della risorsa usando un valore costante nel parametro ID univoco, ad esempio: NULL.
È anche possibile raggruppare elementi in base a multipli campi usando funzioni Array, ad esempio: Array(«Campo1», «Campo2»).
Le geometrie (se presenti) sono combinate in un’unica geometria multi parte per ogni gruppo. Gli attributi in uscita sono calcolati in base ad ogni definizione di raggruppamento data.
Questo algoritmo permette di utilizzare le funzioni predefinite aggregates del motore Espressioni di QGIS.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Raggruppa tramite un’espressione |
|
[tablefield: any] Predefinito: “NULL” |
Scegli il campo di raggruppamento. Se NULL tutte gli elementi saranno aggregati. |
Aggregati |
|
[list] |
Elenco delle definizioni dei campi del layer in uscita. Esempio di definizione campo: {“aggregate”: “sum”, “delimiter”: “,”, “input”: “ $area”, “length”: 10, “name”: “totarea”, “precision”: 0, “type”: 6} Per impostazione predefinita, la lista contiene tutti i campi del layer in ingresso. Nella GUI, puoi modificare questi campi e le loro definizioni, e puoi anche:
Per ognuno dei campi da cui vorresti recuperare informazioni, devi definire quanto segue:
|
Caricare i campi dal layer |
Solo GUI |
[vector: any] |
Puoi caricare campi da un altro layer e usarli per l’aggregazione |
Aggregati |
|
[same as input] Predefinito: |
Specificare il layer in uscita (aggregato) Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Aggregati |
|
[same as input] |
Layer vettoriale multigeometria con i valori aggregati |
Codice Python
ID Algoritmo: native:aggregate
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.4. Confine
Restituisce la chiusura del confine combinato della geometria (cioè il confine topologico della geometria)
Solo per i layer poligonali e lineari.
Per le geometrie poligonali , il confine è costituito da tutte le linee che compongono gli archi del poligono.
Fig. 27.51 Confini (linea tratteggiata nera) del vettore poligonale di origine
Per le geometrie lineari, i confini sono i punti finali.
Fig. 27.52 Confine layer (punti rossi) per inee. In giallo un elemento selezionato.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Confine |
|
[vector: point, line] Predefinito: |
Specificare il layer in uscita (confine). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Confine |
|
[vector: point, line] |
Confini dal layer in ingresso (punto per linea, e linea per poligono) |
Codice Python
ID Algoritmo: native:boundary
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.5. Perimetri di delimitazione
Questo algoritmo calcola il perimetro di delimitazione (inviluppo) per ciascun elemento in un vettore in ingresso. Sono supportati geometrie poligonali e lineari.
Fig. 27.53 Le linee nere rappresentano i perimetri di delimitazione di ogni poligono dell’elemento
Permette features in-place modification degli elementi del poligono
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Perimetri |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (perimetro di delimitazione). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Perimetri |
|
[vector: polygon] |
Perimetro di delimitazione del layer in ingresso |
Codice Python
ID Algoritmo: native:boundingboxes
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.6. Buffer
Calcola un’area di buffer per tutti gli elementi di un layer in ingresso, utilizzando una distanza fissa o definita dai dati.
È possibile usare una distanza negativa per i layer in ingresso dei poligoni. In questo caso il buffer risulterà in un poligono più piccolo (setback).
Fig. 27.54 Buffer (in giallo) di punti, linea, poligono con buffer positivo e poligono con buffer negativo
Permette features in-place modification degli elementi del poligono
Menu predefinito:
Vedi anche
Buffer a distanza variabile, Buffer multi-anello (distanza costante), Buffer larghezza variabile (valore M)
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Distanza |
|
[number Predefinito: 10.0 |
Distanza del buffer (dal confine di ogni elemento). Puoi usare il pulsante Sovrascrittura definita dai dati sulla destra per scegliere un campo dal quale il raggio sarà calcolato. In questo modo puoi avere un raggio diverso per ogni elemento (vedi Buffer a distanza variabile). |
Segmenti |
|
[number] Predefinito: 5 |
Controlla il numero di segmenti di linea da usare per approssimare un quarto di cerchio quando si creano offset arrotondati. |
Stile testata terminale |
|
[enumeration] Predefinito: 0 |
Controlla come vengono gestiti i terminali di linea nel buffer. Uno di:
Fig. 27.55 Stile testata arrotondato, piatto e quadrato |
Stile unione |
|
[enumeration] Predefinito: 0 |
Specifica se devono essere utilizzati stile di unione di tipo arrotondato, seghettato o smussato quando si esegue l’offset degli angoli in una linea. Le opzioni sono:
Fig. 27.56 Stili di giunzione arrotondati, squadrati e smussati |
Limite a taglio obliquo |
|
[number] Predefinito: 2.0 |
Imposta la distanza massima dalla geometria di offset da utilizzare per creare una giunzione a mitria come fattore della distanza di offset (applicabile solo agli stili di giunzione a mitria). Minimo: 1.0 
Fig. 27.57 Un buffer di 10 m con un limite di 2 e un buffer di 10 m con un limite di 1 |
Dissolvere il risultato |
|
[boolean] Predefinito: False |
Dissolvere il buffer terminale. Se 
Fig. 27.58 Standard (tre elementi singoli - sinistra), dissolto (1 elemento multi parte con 2 parti - destra) |
Bufferizzato |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (buffer). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Bufferizzato |
|
[vector: polygon] |
Vettore poligonale in uscita (buffer) |
Codice Python
ID Algoritmo: native:buffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.7. Centroidi
Crea un nuovo layer di punti, con punti che rappresentano i centroidi delle geometrie del layer in ingresso.
Il centroide è un singolo punto che rappresenta il baricentro (di tutte le parti) dell” elemento, quindi può essere fuori dai confini dell’elemento. Ma può anche essere un punto su ogni parte dell” elemento.
Gli attributi dei punti nel layer in uscita sono gli stessi degli elementi originali.
Fig. 27.59 Le stelle rosse rappresentano i centroidi degli elementi del layer in ingresso.
Permette features in-place modification degli elementi punto
Menu predefinito:
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Crea il centroide per ogni parte |
|
[boolean Predefinito: False |
Se True (selezionato), verrà creato un centroide per ogni parte della geometria |
Centroidi |
|
[vector: point] Predefinito: |
Specifica il layer in uscita (centroide). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Centroidi |
|
[vector: point] |
Risultato layer di punti (centroidi) |
Codice Python
ID Algoritmo: native:centroids
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.8. Controllo validità
Esegue un controllo di validità delle geometrie del vettore.
Le geometrie sono classificate in tre gruppi (valido, non valido ed errore) e per ogni gruppo, viene generato uno layer vettoriale con i suoi elementi:
Il layer Risultato valido contiene solo gli elementi validi (senza errori topologici).
Il layer Risultato non valido contiene tutte gli elementi non validi trovati dall’algoritmo.
Il layer Risultato con errore è un layer puntuale che segnala il punto in cui sono state trovate gli elementi non validi.
Le tabelle degli attributi dei layer generati conterranno alcune informazioni aggiuntive («message» per il layer error, «FID» e «_errors» per il layer invalid e solo «FID» per il layer valid):
La tabella degli attributi di ogni layer vettoriale generato conterrà alcune informazioni aggiuntive (numero di errori trovati e tipi di errore):
Fig. 27.60 A sinistra: il layer in ingresso. A destra: il layer valido (verde), il layer non valido (arancione)
Menu predefinito:
Vedi anche
Ripara geometrie e il plugin di base Plugin Controllo Geometria
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Metodo |
|
[enumeration] Predefinito: 2 |
Metodo da usare per verificare la validità. Opzioni:
|
Ignora auto intersezione dell’anello |
|
[boolean] Predefinito: False |
Ignorare gli anelli che si auto intersecano quando viene controllata la validità. |
Risultato valido |
|
[same as input] Predefinito: |
Specificare il layer vettoriale per salvare una copia degli elementi validi del layer di origine. Uno di:
La codifica del file può anche essere cambiata qui. |
Risultato non valido |
|
[same as input] Predefinito: |
Layer vettoriale contenente la copia degli elementi non validi del layer di origine con il campo
La codifica del file può anche essere cambiata qui. |
Errore in uscita |
|
[vector: point] Predefinito: |
Layer puntuale della posizione esatta dei problemi di validità rilevati con il campo
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Conteggio errori |
|
[number] |
Il numero di geometrie che hanno causato errori. |
Errore in uscita |
|
[vector: point] |
Vettore puntuale dell’esatta posizione del problema di validità individuato con il campo |
Conteggio di elementi non validi |
|
[number] |
Il numero di geometrie non valide. |
Risultato non valido |
|
[same as input] |
Layer vettoriale contenente la copia degli elementi non validi del layer di origine con il campo |
Conteggio degli elementi validi |
|
[number] |
Il numero di geometrie valide. |
Risultato valido |
|
[same as input] |
Layer vettoriale che contiene una copia degli elementi validi del layer di origine. |
Codice Python
ID Algoritmo: qgis:checkvalidity
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
Tipi di messaggi di errore e loro significati
Messaggio di errore |
Spiegazione |
Esempio |
|---|---|---|
Punto ripetuto |
Questo errore si verifica quando un dato vertice viene ripetuto. |
|
Auto intersezione con anello |
Questo errore si verifica quando una geometria tocca se stessa e genera un anello. |
|
Auto intersezione |
Questo errore si verifica quando una geometria tocca se stessa. |
|
Errore di validazione topologica |
||
Il buco si trova all’esterno del confine |
||
I buchi sono annidati |
||
Internamente è scollegato |
||
Confini annidati |
Questo errore si verifica quando una geometria poligonale è sopra un’altra geometria poligonale. |
|
Anelli duplicati |
Questo errore si verifica quando due anelli (esterni o interni) di una geometria poligonale sono identici |
|
Troppi pochi punti nella geometria |
||
Coordinata non valida |
Per una geometria puntuale, questo errore si verifica quando la geometria non ha una coppia di coordinate adeguata. La coppia di coordinate non contiene un valore di latitudine e un valore di longitudine in ordine coerente. |
|
Anello non chiuso |
Messaggio di errore |
Spiegazione |
Esempio |
|---|---|---|
Il segmento %1 dell’anello %2 del poligono %3 interseca il segmento %4 dell’anello %5 del poligono %6 in %7 |
||
Anello %1 con meno di quattro punti |
||
Anello %1 non chiuso |
||
Linea %1 con meno di due punti |
||
La linea %1 contiene %n nodo(i) duplicato in %2 |
Questo errore si verifica quando punti consecutivi su una linea hanno le stesse coordinate. |
|
Segmenti %1 e %2 della linea %3 interseca in %4 |
Questo errore si verifica quando una linea si interseca (due segmenti della linea si intersecano tra loro). |
|
Auto intersezione con anello |
Questo errore si verifica quando un anello/confine esterno o interno (isola) di una geometria poligonale interseca se stesso. |
|
L’anello %1 del poligono %2 non è nell’anello esterno |
||
Il poligono %1 è all” interno del poligono %2 |
Questo errore si verifica quando una parte di una geometria MultiPoligono è dentro un buco di una geometria MultiPoligono. |
|
27.1.18.9. Raggruppa geometrie
Prende un layer vettoriale e riassembla le sue geometrie in nuove geometrie multiparte.
Uno o più attributi possono essere specificati per raggruppare le geometrie appartenenti alla stessa classe (che hanno lo stesso valore per gli attributi specificati), in alternativa possono essere riassemblate tutte le geometrie.
Tutte le geometrie in uscita saranno convertite in multi geometrie, anche quelle con una sola parte. Questo algoritmo non dissolve le geometrie sovrapposte - saranno riassemblate insieme senza modificare la forma di ogni parte della geometria.
Vedi gli algoritmi “Promote to multipart” o “Aggregate” per opzioni alternative.
Menu predefinito:
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Campi con ID univoco |
|
[tablefield: any] [list] |
Scegli uno o più attributi per raggruppare le geometrie |
Riassemblate |
|
[same as input] |
Layer vettoriale con le geometrie riassemblate |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Riassemblate |
|
[same as input] Predefinito: |
Specifica il layer vettoriale in uscita per le geometrie riassemblate. Uno di:
La codifica del file può anche essere cambiata qui. |
Codice Python
ID Algoritmo: native:collect
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.10. Poligono concavo (forme alfa)
Calcolare il poligono concavo degli elementi in un layer di punti in ingresso.
Fig. 27.61 Poligoni concavi con diverse soglie (0,3, 0,6, 0,9)
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer puntuale in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Soglia |
|
[number] Predefinito: 0.3 |
Numero da 0 ( massimo involucro concavo) a 1 (involucro convesso). |
Permettere buchi |
|
[boolean] Predefinito: True |
Scegliere se permettere buchi nel poligono concavo finale |
Dividere geometria multiparte in geometrie a parti singole |
|
[boolean] Predefinito: True |
Verifica se vuoi avere geometrie a parti singole invece di quelle multi parte. |
Poligono concavo |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligono concavo |
|
[vector: polygon] |
Layer vettoriale in uscita |
Codice Python
ID Algoritmo: qgis:concavehull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.11. Poligono concavo (vicino più prossimo-k)
Genera un poligono concavo da un insieme di punti. Se il layer in ingresso è un vettore lineare o un vettore poligonale, userà i vertici.
Il numero di punti vicini da considerare determina la concavità del poligono di uscita. Un numero più basso risulterà in un guscio concavo che segue i punti molto da vicino, mentre un numero più alto avrà una forma più liscia. Il numero minimo di punti vicini da considerare è 3. Un valore uguale o superiore al numero di punti produrrà una poligono convesso.
Se viene selezionato un campo, l’algoritmo raggrupperà gli elementi nel layer in ingresso usando valori unici in quel campo e genererà poligoni singoli nel layer in uscita per ogni gruppo.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Numero di punti vicini da considerare (un numero più basso ha un effetto più concavo, un numero più alto ha un effetto più liscio) |
|
[number] Predefinito: 3 |
Determina la concavità del poligono di uscita. Un numero piccolo risulterà in un poligono concavo che segue molto da vicino i punti, mentre un numero alto farà sì che il poligono assomigli di più al poligono convesso (se il numero è uguale o maggiore del numero di elementi, il risultato sarà il poligono convesso). Valore minimo: 3. |
Campo Opzionale |
|
[tablefield: any] Predefinito: None |
Se specificato, viene generato un poligono concavo per ogni valore univoco del campo (selezionando gli elementi che utilizzano questo valore). |
Poligono concavo |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligono concavo |
|
[vector: polygon] |
Layer vettoriale in uscita |
Codice Python
ID Algoritmo: qgis:knearestconcavehull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.12. Converti tipo di geometria
Genera un nuovo layer basato su uno esistente, con un diverso tipo di geometria.
La tabella degli attributi del layer in uscita è la stessa di quella del layer in entrata.
Non tutte le conversioni sono possibili. Per esempio, un layer lineare può essere convertito in un layer di punti, ma un layer di punti non può essere convertito in un layer lineare.
Vedi anche
Poligonizza, Da linee a poligoni, Da poligoni a linee, Da punti a linea
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Nuovo tipo di geometria |
|
[enumeration] Predefinito: 0 |
Tipo di geometria da applicare agli elementi in uscita. Uno di:
|
Convertito |
|
[vector: any] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Convertito |
|
[vector: any] |
Layer vettoriale in uscita - il tipo dipende dai parametri |
Codice Python
ID Algoritmo: qgis:convertgeometrytype
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.13. Converti in geometrie curvate
Converte una geometria nella sua corrispondente geometria curva.
Le geometrie già curve saranno mantenute senza modifiche.
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line or polygon] |
Vettore in ingresso |
Tolleranza distanza massima |
|
[number] Predefinito: 0.000001 |
La distanza massima consentita tra la posizione originale dei vertici e dove cadrebbero sulle geometrie curve convertite |
Tolleranza angolo massimo |
|
[number] Predefinito: 0.000001 |
I segmenti sono considerati adatti alla sostituzione con un arco se i punti sono tutti regolarmente spaziati sull’arco potenziale. Questo parametro specifica la massima deviazione angolare (in gradi) consentita quando si verifica la spaziatura regolare dei punti. Tra 0 e 45°. |
Curve |
|
[vector: compoundcurve or curvepolygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Curve |
|
[vector: compoundcurve or curvepolygon] |
Layer vettoriale in uscita con geometrie curvilinee |
Codice Python
ID Algoritmo: native:converttocurves
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.14. Poligono convesso
Calcola il poligono convesso per ogni elemento in un layer in ingresso.
Vedi l’algoritmo “Minimum bounding geometry” per un calcolo del poligono convesso che copre l’intero layer o sottoinsiemi raggruppati di elementi.
Fig. 27.62 Le linee nere identificano il poligono convesso per ogni elemento del layer
Permette features in-place modification degli elementi del poligono
Menu predefinito:
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Poligono convesso |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligono convesso |
|
[vector: polygon] |
Il layer vettoriale in uscita (poligono convesso) |
Codice Python
ID Algoritmo: native:convexhull
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.15. Crea layer da estensione
Crea un nuovo layer vettoriale che contiene un singolo elemento con una geometria corrispondente all’estensione del layer in ingresso.
Può essere usato nei modelli per convertire un’estensione in formato letterale (xmin, xmax, ymin, ymax) in un layer che può essere usato per altri algoritmi che richiedono dati in ingresso basati sul layer.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Estensione (xmin, xmax, ymin, ymax) |
|
[estensione] |
Estensione in ingresso I metodi disponibili sono:
|
Estensione |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Estensione |
|
[vector: polygon] |
Il layer vettoriale in uscita (estensione) |
Codice Python
ID Algoritmo: native:extenttolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.16. Crea layer da punti
Crea un nuovo layer vettoriale che contiene un singolo elemento con una geometria corrispondente ad un parametro punto. Può essere usato nei modelli per convertire un punto in un layer puntuale per algoritmi che richiedono un dato in ingresso basato su layer.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punto |
|
[coordinates] |
Punto in ingresso, incluse le informazioni SR (esempio: Se il SR non viene fornito, verrà utilizzato il SR del progetto. Il punto può essere specificato cliccando sull’area grafica della mappa. |
Punto |
|
[vector: point] Predefinito: |
Specifica il layer in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punto |
|
[vector: point] |
Il layer vettoriale punto in uscita che contiene il punto in ingresso. |
Codice Python
ID Algoritmo: native:pointtolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.17. Crea buffer a spicchi
Crea buffer a forma di spicchio dai punti in ingresso.
Fig. 27.63 Buffer a spicchio
Il risultato finale di questo algoritmo sono geometrie CurvePolygon, ma queste possono essere automaticamente segmentate in Poligoni a seconda del formato in uscita.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Azimut (gradi da Nord) |
|
[number Predefinito: 0.0 |
Angolo (in gradi) come valore medio dello spicchio |
Larghezza dello spicchio (in gradi) |
|
[number Predefinito: 45.0 |
Larghezza (in gradi) del buffer. Lo spicchio si estenderà fino alla metà della larghezza angolare su entrambi i lati della direzione dell’azimut. 
Fig. 27.64 Valori di azimut e larghezza del buffer a spicchio |
Raggio esterno |
|
[number Predefinito: 1.0 |
La dimensione esterna (lunghezza) dello spicchio: la dimensione è intesa dal punto di origine al margine della forma dello spicchio. |
Raggio interno Opzionale |
|
[number Predefinito: 0.0 |
Valore del raggio interno. Se 0 lo spicchio inizierà dal punto di origine. |
Buffer |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Buffer |
|
[vector: polygon] |
Il layer vettoriale in uscita (buffer a spicchio) |
Codice Python
ID Algoritmo: native:wedgebuffers
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.18. Triangolazione di Delaunay
Crea un vettore poligonale con la triangolazione Delaunay in corrispondenza al layer punto in ingresso.
Fig. 27.65 Triangolazione di Delaunay su punti
Menu predefinito:
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Triangolazione di Delaunay |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Triangolazione di Delaunay |
|
[vector: polygon] |
Il layer vettoriale in uscita (triangolazione Delaunay) |
Codice Python
ID Algoritmo: qgis:delaunaytriangulation
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.19. Elimina buchi
Prende un vettore poligonale e rimuove i buchi nei poligoni. Crea un nuovo layer vettoriale in cui i poligoni con buchi sono stati sostituiti da poligoni con solo il loro anello esterno. Gli attributi non vengono modificati.
Un parametro opzionale di area minima permette di rimuovere solo i buchi che sono più piccoli di una soglia di area specificata. Lasciando questo parametro a 0.0 si ottiene la rimozione di tutti i buchi.
Fig. 27.66 Prima e dopo la pulizia
Permette features in-place modification degli elementi del poligono
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Layer vettoriale poligonale in ingresso |
Rimuovere i buchi con area inferiore a Opzionale |
|
[number Predefinito: 0.0 |
Solo i buchi con un’area inferiore a questa soglia saranno eliminati. Con un valore di |
Pulito |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Pulito |
|
[same as input] |
Il layer vettoriale in uscita (ripulito) |
Codice Python
ID Algoritmo: native:deleteholes
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.20. Infittisci secondo un conteggio
Prende un layer poligonale o lineare e ne genera uno nuovo in cui le geometrie hanno un numero di vertici maggiore di quello originale.
Se le geometrie hanno valori Z o M presenti, questi saranno interpolati linearmente ai vertici aggiunti.
Il numero di nuovi vertici da aggiungere ad ogni segmento è specificato come parametro in ingresso.
Fig. 27.67 I punti rossi mostrano i vertici prima e dopo l’addensamento
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Menu predefinito:
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Vertici da aggiungere |
|
[number] Predefinito: 1 |
Numero di vertici da aggiungere per ogni segmento |
Infittito |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Infittito |
|
[same as input] |
Il layer vettoriale in uscita (infittito) |
Codice Python
ID Algoritmo: native:densifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.21. Infittisci secondo un intervallo
Prende un layer poligonale o lineare e ne genera uno nuovo in cui le geometrie hanno un numero di vertici maggiore di quello originale.
Le geometrie vengono infittite aggiungendo regolarmente dei vertici extra all’interno di ogni segmento in modo che la distanza massima tra due vertici qualsiasi non superi la distanza specificata.
Se le geometrie hanno valori Z o M presenti, questi saranno interpolati linearmente ai vertici aggiunti.
Esempio
Specificando una distanza di 3, il segmento [0 0] -> [10 0] verrebbe convertito in [0 0] -> [2.5 0] -> [5 0] -> [7.5 0] -> [10 0], poiché sono richiesti 3 vertici extra sul segmento e la spaziatura di questi a incrementi di 2.5 permette di distanziarli uniformemente sul segmento.
Fig. 27.68 Infittisci secondo un intervallo
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Intervallo tra i vertici da aggiungere |
|
[number Predefinito: 1.0 |
Distanza massima tra due vertici consecutivi |
Infittito |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Infittito |
|
[same as input] |
Il layer vettoriale in uscita (infittito) |
Codice Python
ID Algoritmo: native:densifygeometriesgivenaninterval
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.22. Dissolvi
Prende un layer vettoriale e combina i suoi elementi in nuovi elementi. Uno o più attributi possono essere specificati per dissolvere le caratteristiche appartenenti alla stessa classe (avendo lo stesso valore per gli attributi specificati), in alternativa tutte gli elementi possono essere dissolti in un singolo elemento.
Tutte le geometrie in uscita saranno convertite in multi geometrie. Se l’input è un layer poligono, i confini comuni dei poligoni adiacenti che vengono dissolti verranno cancellati. Se attivata, l’impostazione opzionale «Mantieni separati gli elementi disgiunti» fa sì che gli elementi e le parti che non si sovrappongono o si toccano vengano esportati come elementi separati (invece che come parti di un unico elemento multi parte).
La tabella degli attributi risultante avrà gli stessi campi del layer in ingresso. I valori nei campi del layer in uscita sono quelli del primo elemento in ingresso che viene elaborato.
Fig. 27.69 Dissolvere un layer in un unico elemento multi parte
Menu predefinito:
Vedi anche
Parametri
Parametri di base
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
**Dissolvere campo(i) Opzionale |
|
[tablefield: any] [list] Predefinito: [] |
Gli elementi che hanno lo stesso valore per i campi selezionati vengono sostituiti con uno solo e le loro geometrie vengono unite. Se non viene fornito alcun campo, allora tutte gli elementi vengono dissolti, risultando in un unico elemento (multiparte). 
Fig. 27.70 Dissolvere il layer poligono su un attributo comune (2 elementi multi parte) |
Dissolto |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
Parametri avanzati
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Mantieni separati gli elementi disgiunti
|
|
[boolean] Predefinito: False |
Le parti di elementi dissolti vengono esportate come elementi separati (invece che come parti di un elemento multi parte). 
Fig. 27.71 origine (sinistra), dissolvere tutto (3 elementi distinti - destra) 
Fig. 27.72 origine (sinistra), dissolvere sul campo (5 elementi distinti - destra) |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Dissolto |
|
[same as input] |
Il layer vettoriale in uscita con le geometrie dissolte |
Codice Python
ID Algoritmo: native:dissolve
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.23. Drappeggia (imposta il valore Z da raster)
Utilizza valori campionati da una banda all’interno di un layer raster per impostare il valore Z per ogni vertice sovrapposto nella geometria dell’elemento. I valori raster possono opzionalmente essere scalati di una quantità preimpostata.
Se i valori Z esistono già nel layer, saranno sovrascritti con il nuovo valore. Se non esistono valori Z, la geometria sarà aggiornata per includere la dimensione Z.
Permette features in-place modification di punti, linee e poligoni con Z abilitato
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Layer raster |
|
[raster] |
Layer raster layer con valori Z |
Numero banda |
|
[raster band] Predefinito: 1 |
La banda raster da cui prendere i valori Z |
Valore per nodata o vertici non intersecanti |
|
[number Predefinito: 0 |
Valore da usare nel caso in cui il vertice non intersechi (in un pixel valido) il raster |
Fattore di scala |
|
[number Predefinito: 1.0 |
Valore di scala: i valori della banda sono moltiplicati per questo valore. |
Offset
|
|
[number Predefinito: 0.0 |
Valore di offset: viene aggiunto algebricamente ai valori della banda dopo aver applicato il «Fattore di scala». |
Aggiornato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (con i valori Z del layer raster). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Aggiornato |
|
[same as input] |
Il layer vettoriale in uscita con i valori Z del layer raster |
Codice Python
ID Algoritmo: native:setzfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.24. Elimina valori M/Z
Rimuove i valori M (misura) o Z (altitudine) dalle geometrie in ingresso.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Layer vettoriale in ingresso con valori M o Z |
Eliminare valori M |
|
[boolean] Predefinito: False |
Rimuove i valori M dalle geometrie |
Eliminare valori Z |
|
[boolean] Predefinito: False |
Rimuove i valori Z dalle geometrie |
Z/M Dropped |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Z/M Dropped |
|
[same as input] |
Il layer vettoriale in uscita (identico al layer in ingresso, tranne per il fatto che le dimensioni M e/o Z sono state rimosse dalle geometrie). |
Codice Python
ID Algoritmo: native:dropmzvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.25. Elimina i poligoni selezionati
Combina i poligoni selezionati del layer in ingresso con alcuni poligoni adiacenti cancellando il loro confine comune. Il poligono adiacente può essere quello con l’area più grande o più piccola o quello che condivide il confine comune più grande con il poligono da eliminare.
Elimina i poligoni selezionati è normalmente usato per sbarazzarsi dei poligoni sliver, cioè dei piccoli poligoni che sono il risultato di processi di intersezione di poligoni dove i confini degli elementi in ingresso sono simili ma non identici.
Menu predefinito:
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Layer vettoriale poligonale in ingresso |
Fusione della selezione al poligono più vicino |
|
[enumeration] Predefinito: None |
Scegli il parametro da utilizzare per ottenere eliminazioni tra i poligoni selezionati:
|
Eliminati |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Eliminati |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita. |
Codice Python
ID Algoritmo: qgis:eliminateselectedpolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.26. Esplodi linee
Prende un layer lineare e ne crea uno nuovo in cui ogni layer lineare è sostituito da un insieme di linee che rappresentano i segmenti della linea originale.
Ogni linea nel layer risultante contiene solo un punto iniziale e uno finale, senza vertici intermedi tra loro.
Fig. 27.73 Il layer lineare originale e quello esploso
Permette features in-place modification di elementi linea
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Esploso |
|
[vector: line] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Esploso |
|
[vector: line] |
Il layer vettoriale lineare in uscita con gli elementi che rappresentano ogni segmento del layer in ingresso. |
Codice Python
ID Algoritmo: native:explodelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.27. Estendi linee
Prolunga la geometria lineare di una quantità specificata all’inizio e alla fine della linea.
Le linee sono prolungate usando il posizionamento del primo e dell’ultimo segmento della linea.
Fig. 27.74 I trattini rossi rappresentano l’estensione iniziale e finale del layer originale
Permette features in-place modification di elementi linea
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Distanza iniziale |
|
[number |
Distanza con cui prolungare il primo segmento della linea (punto di partenza) |
Distanza finale |
|
[number |
Distanza con cui prolungare l’ultimo segmento della linea (punto finale) |
Prolungato |
|
[vector: line] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Prolungato |
|
[vector: line] |
Il layer vettoriale lineare in uscita (prolungato). |
Codice Python
ID Algoritmo: native:extendlines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.28. Estrai i valori M
Estrae i valori M dalle geometrie negli attributi degli elementi.
Per impostazione predefinita viene estratto solo il valore M dal primo vertice di ogni elemento, tuttavia l’algoritmo può opzionalmente calcolare statistiche su tutti i valori M della geometria, compresi somma, media, minimo e massimo.
Vedi anche
Estrai i valori della Z, Imposta il valore M, Elimina valori M/Z
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Dati di sintesi da calcolare |
|
[enumeration] Predefinito: [0] |
Statistiche sui valori M di una geometria. Uno o più di:
|
Prefisso colonna in uscita |
|
[string] Predefinito: “m_” |
Il prefisso per la colonna (M) in uscita |
Estratti |
|
[same as input] Predefinito: |
Specifica il layer in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Estratti |
|
[same as input] |
Il layer vettoriale in uscita (con valori M) |
Codice Python
ID Algoritmo: native:extractmvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.29. Estrai vertici specifici
Prende un layer vettoriale e genera un layer punto con punti che rappresentano specifici vertici nelle geometrie in ingresso.
Per esempio, questo algoritmo può essere usato per estrarre il primo o l’ultimo vertice della geometria. Gli attributi associati ad ogni punto sono gli stessi associati all’elemento a cui il vertice appartiene.
Il parametro degli indici dei vertici accetta una stringa separata da virgole che specifica gli indici dei vertici da estrarre. Il primo vertice corrisponde a un indice 0, il secondo vertice ha un indice 1, ecc. Gli indici negativi possono essere utilizzati per trovare i vertici alla fine della geometria, ad esempio, un indice di -1 corrisponde all’ultimo vertice, -2 corrisponde al penultimo vertice, ecc.
Ai vertici vengono aggiunti campi aggiuntivi che indicano la posizione specifica del vertice (ad esempio, 0, -1, ecc.), l’indice del vertice originale, la parte del vertice e il suo indice all’interno della parte (così come il suo anello per i poligoni), la distanza lungo la geometria originale e l’angolo della bisettrice del vertice per la geometria originale.
Permette features in-place modification degli elementi punto
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Indici dei vertici |
|
[string] Predefinito: “0” |
Stringa separata da virgole degli indici dei vertici da estrarre. |
Vertici |
|
[vector: point] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Vertici |
|
[vector: point] |
Il layer vettoriale in uscita (punto) contenente i vertici specificati dalle geometrie del layer in ingresso. |
Codice Python
ID Algoritmo: native:extractspecificvertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.30. Estrai vertici
Prende un layer vettoriale e genera un layer punto con punti che rappresentano i vertici nelle geometrie in ingresso.
Gli attributi associati ad ogni punto sono gli stessi associati all’elemento a cui appartiene il vertice.
Ai vertici vengono aggiunti campi aggiuntivi che indicano l’indice del vertice (a partire da 0), la parte dell’elemento e il suo indice all’interno della parte (così come il suo anello per i poligoni), la distanza lungo la geometria originale e l’angolo della bisettrice del vertice per la geometria originale.
Fig. 27.75 Vertici estratti per il vettore lineare e poligonare
Permette features in-place modification degli elementi punto
Menu predefinito:
Vedi anche
Estrai vertici specifici, Filtra vertici per il valore di M, Filtra vertici per il valore di Z
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Vertici |
|
[vector: point] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Vertici |
|
[vector: point] |
Il layer vettoriale in uscita (punto) che contiene i vertici delle geometrie del layer in ingresso. |
Codice Python
ID Algoritmo: native:extractvertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.31. Estrai i valori della Z
Estrae i valori Z dalle geometrie in attributi dell’elemento.
Per impostazione predefinita viene estratto solo il valore Z dal primo vertice di ogni elemento, tuttavia l’algoritmo può opzionalmente calcolare statistiche su tutti i valori Z della geometria, compresi somma, media, minimo e massimo.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Dati di sintesi da calcolare |
|
[enumeration] Predefinito: [0] |
Statistiche sui valori Z di una geometria. Uno o più di:
|
Prefisso colonna in uscita |
|
[string] Predefinito: “z_” |
Il prefisso per la colonna in uscita (Z) |
Estratti |
|
[same as input] Predefinito: |
Specifica il layer in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Estratti |
|
[same as input] |
Il layer vettoriale in uscita (con valori Z) |
Codice Python
ID Algoritmo: native:extractzvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.32. Filtra vertici per il valore di M
Filtra i vertici in base al loro valore M, restituendo geometrie con solo punti di vertice che hanno un valore M maggiore o uguale al valore minimo specificato e/o minore o uguale al valore massimo.
Se il valore minimo non è specificato allora viene testato solo il valore massimo, e allo stesso modo se il valore massimo non è specificato allora viene testato solo il valore minimo.
Fig. 27.76 La linea rossa mostra la linea nera con solo i vertici il cui valore M è <=10.
Permette features in-place modification di linee e poligoni con M abilitato
Nota
A seconda degli attributi della geometria in ingresso e dei filtri utilizzati, le geometrie risultanti generate da questo algoritmo potrebbero non essere più valide.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso da cui rimuovere i vertici |
Minimo Opzionale |
|
[number Predefinito: Not set |
Minimo dei valori M ammessi |
Massimo Opzionale |
|
[number Predefinito: Not set |
Massimo dei valori M ammessi |
Filtrati |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Filtrati |
|
[same as input] |
Il layer vettoriale in uscita di elementi con solo i vertici filtrati. |
Codice Python
ID Algoritmo: native:filterverticesbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.33. Filtra vertici per il valore di Z
Filtra i vertici in base al loro valore Z, restituendo geometrie con solo i punti dei vertici che hanno un valore Z maggiore o uguale al valore minimo specificato e/o minore o uguale al valore massimo.
Se il valore minimo non è specificato allora viene testato solo il valore massimo, e allo stesso modo se il valore massimo non è specificato allora viene testato solo il valore minimo.
Fig. 27.77 La linea rossa raffigura la linea nera con solo i vertici il cui valore Z è <=10.
Permette features in-place modification di linee e poligoni con Z abilitato
Nota
A seconda degli attributi della geometria in ingresso e dei filtri utilizzati, le geometrie risultanti create da questo algoritmo potrebbero non essere più valide. Potrebbe essere necessario eseguire l’algoritmo Ripara geometrie per assicurare la loro validità.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso da cui rimuovere i vertici |
Minimo Opzionale |
|
[number Predefinito: Not set |
Minimo dei valori Z ammessi |
Massimo Opzionale |
|
[number Predefinito: Not set |
Massimo dei valori Z ammessi |
Filtrati |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Filtrati |
|
[same as input] |
Il layer vettoriale in uscita di elementi con solo i vertici filtrati. |
Codice Python
ID Algoritmo: native:filterverticesbyz
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.34. Ripara geometrie
Tenta di ricreare una rappresentazione valida di una data geometria non valida senza perdere nessuno dei vertici in ingresso. Le geometrie già valide vengono restituite senza ulteriori interventi. Restituisce sempre layer multi-geometria.
Permette features in-place modification di punti, linee e poligoni senza M abilitato
Nota
I valori M saranno eliminati dal risultato.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Modalità di riparazione
|
|
[enumeration] Predefinito: 1 |
Metodo utilizzato per riparare le geometrie. Uno di:
|
Geometrie validate |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Geometrie validate |
|
[same as input] |
Il layer vettoriale in uscita con geometrie validate. |
Codice Python
ID Algoritmo: native:fixgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.35. Forza regola della mano destra
Costringe le geometrie dei poligoni a rispettare la Right-Hand-Rule, in cui l’area che è delimitata da un poligono è a destra del confine. In particolare, l’anello esterno è orientato in senso orario e qualsiasi anello interno in senso antiorario.
Permette features in-place modification degli elementi del poligono
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Vettore in ingresso |
Riorentato |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Riorentato |
|
[vector: polygon] |
Il layer vettoriale in uscita con le geometrie riorientate. |
Codice Python
ID Algoritmo: native:forcerhr
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.36. Linea geodetica suddivisa in antimeridiano
Suddivide una linea in più segmenti geodetici, ogni volta che la linea attraversa l’antimeridiano (±180 gradi di longitudine).
La suddivisione all’antimeridiano aiuta la visualizzazione delle linee in alcune proiezioni. La geometria restituita sarà sempre una geometria a parti multiple.
Ogni volta che i segmenti di linea nella geometria in ingresso attraversano l’antimeridiano, saranno divisi in due segmenti, con la latitudine del punto di rottura determinata utilizzando una linea geodetica che collega i punti su entrambi i lati di questo segmento. L’impostazione corrente dell’ellissoide del progetto sarà usata per calcolare questo punto di rottura.
Se la geometria di input contiene valori M o Z, questi saranno interpolati linearmente per i nuovi vertici creati all’antimeridiano.
Permette features in-place modification di elementi linea
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Suddiviso |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Suddiviso |
|
[vector: line] |
Il layer vettoriale della linea in uscita suddiviso sull’antimeridiano. |
Codice Python
ID Algoritmo: native:antimeridiansplit
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.37. Geometria tramite espressione
Aggiorna le geometrie esistenti (o crea nuove geometrie) degli elementi in ingresso utilizzando un’espressione QGIS.
Questo permette complesse modifiche della geometria che possono utilizzare tutta la flessibilità del motore di espressione di QGIS per manipolare e creare geometrie per gli elementi in uscita.
Per un aiuto sulle funzioni di espressione di QGIS, vedi l’aiuto incorporato disponibile nel expression builder.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Tipo di geometria in uscita |
|
[enumeration] Predefinito: 0 |
La geometria in uscita dipende fortemente dall’espressione: per esempio, se si crea un buffer il tipo di geometria deve essere poligono. Uno di:
|
La geometria in uscita ha valori z |
|
[boolean] Predefinito: False |
Scegli se la geometria in uscita deve includere la dimensione Z |
La geometria in uscita ha valori m |
|
[boolean] Predefinito: False |
Scegli se la geometria in uscita deve includere la dimensione M |
Espressione geometria |
|
[expression] Predefinito: “$geometry” |
Aggiungi l’espressione geometria che vuoi usare. Puoi usare il pulsante per aprire la finestra di dialogo delle espressioni. La finestra di dialogo elenca tutte le espressioni pertinenti, insieme al loro aiuto e guida. |
Geometria modificata |
|
[vector: any] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Geometria modificata |
|
[vector: any] |
Layer vettoriale in uscita |
Codice Python
ID Algoritmo: native:geometrybyexpression
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.38. Interpola punto sulla linea
Crea una geometria punto interpolata ad una distanza impostata lungo geometrie lineari o curve.
I valori Z e M sono interpolati linearmente sulla base dei valori esistenti.
Se si incontra una geometria multi parte, solo la prima parte viene considerata nel calcolo della sottostringa.
Se la distanza specificata è maggiore della lunghezza dell’elemento in ingresso, l’elemento risultante avrà una geometria nulla.
Fig. 27.78 Punto interpolato a 500m dall’inizio della linea
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Distanza |
|
[number Predefinito: 0.0 |
Distanza dall’inizio della linea |
Punti di interpolazione |
|
[vector: point] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punti di interpolazione |
|
[vector: point] |
Il layer vettoriale punto in uscita con gli elementi ad una distanza impostata lungo la linea o il confine del poligono |
Codice Python
ID Algoritmo: native:interpolatepoint
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.39. Mantieni le N parti più grandi
Prende un layer con poligoni o multipoligoni e restituisce un nuovo layer in cui vengono mantenuti solo gli n poligoni più grandi di ogni elemento multipoligono. Se una elemento ha n o meno parti, l’elemento sarà semplicemente copiato.
Fig. 27.79 In senso orario da sinistra in alto: originale multi parte, una, due e tre parti più grandi conservate
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligoni |
|
[vector: polygon] |
Layer vettoriale poligonale in ingresso |
Parti da mantenere |
|
[number] Predefinito: 1 |
Numero di parti da mantenere. Se 1, solo la parte più grande dell” elemento sarà conservata. |
Parti |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Parti |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita con le N parti più grandi di ogni elemento |
Codice Python
ID Algoritmo: qgis:keepnbiggestparts
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.40. Sottostringa di Linea
Restituisce la porzione di una linea (o curva) che cade tra le distanze iniziale e finale specificate (misurate dall’inizio della linea).
I valori Z e M sono interpolati linearmente sulla base dei valori esistenti.
Se si incontra una geometria multi parte, solo la prima parte viene considerata nel calcolo della sottostringa.
Fig. 27.80 Linea sottostringa con distanza iniziale impostata a 0 metri e distanza finale a 250 metri.
Permette features in-place modification di elementi linea
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Distanza iniziale |
|
[number |
Distanza lungo la linea in ingresso dal punto di partenza dell” elemento in uscita |
Distanza finale |
|
[number |
Distanza lungo la linea in ingresso al punto finale della linea in uscita |
Substringa |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Substringa |
|
[vector: line] |
Il layer vettoriale lineare in uscita. |
Codice Python
ID Algoritmo: native:linesubstring
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.41. Da linee a poligoni
Genera un vettore poligonale usando come anelli poligonali le linee di un vettore lineare in ingresso.
La tabella degli attributi del layer in uscita è la stessa di quella del layer in entrata.
Menu predefinito:
Vedi anche
Da poligoni a linee, Poligonizza, Converti tipo di geometria
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Poligoni |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligoni |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita. |
Codice Python
ID Algoritmo: qgis:linestopolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.42. Fondi linee (merge)
Unisce tutte le parti connesse delle geometrie MultiLineString in singole geometrie LineString.
Se alcune parti delle geometrie MultiLineString in ingresso non sono connesse, la geometria risultante sarà una MultiLineString contenente tutte le linee che potrebbero essere unite e tutte le parti di linea non connesse.
Permette features in-place modification di elementi linea
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Fusione |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Fusione |
|
[vector: line] |
Il layer vettoriale linea in uscita (fuso). |
Codice Python
ID Algoritmo: native:mergelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.43. Geometria di delimitazione minima
Crea geometrie che racchiudono gli elementi di un layer in ingresso. Gli elementi possono essere raggruppati da un campo. Il layer in uscita conterrà quindi un elemento per valore di gruppo con una geometria (MBB) che copre le geometrie degli elementi con valore corrispondente.
Sono supportati i seguenti tipi di geometrie di delimitazione:
perimetro di delimitazione (inviluppo)
rettangolo orientato
cerchio
poligono convesso
Fig. 27.81 In senso orario dall’alto a sinistra: inviluppo, rettangolo orientato, cerchio, poligono convesso
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Campo Opzionale |
|
[tablefield: any] |
Gli elementi possono essere raggruppati in base a un campo. Se impostato, questo fa sì che il layer in uscita contenga un elemento per ogni valore raggruppato con una geometria minima che copre solo gli elementi con valori corrispondenti. |
Tipo di geometria |
|
[enumeration] Predefinito: 0 |
Tipi di geometria di delimitazione. Uno di:
|
Geometria delimitante |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Geometria delimitante |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita (di delimitazione). |
Codice Python
ID Algoritmo: qgis:minimumboundinggeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.44. Circonferenza circoscritta minima
Calcola i cerchi minimi che delimitano gli elementi nel layer in ingresso.
Fig. 27.82 Cerchio circoscritto per ogni elemento
Permette features in-place modification degli elementi del poligono
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Numero di segmenti nei cerchi |
|
[number] Predefinito: 72 |
Il numero di segmenti usati per approssimare un cerchio. Minimo 8, massimo 100000. |
Circonferenza minima circoscritta |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Circonferenza minima circoscritta |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita. |
Codice Python
ID Algoritmo: native:minimumenclosingcircle
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.45. Buffer multi-anello (distanza costante)
Calcola il buffer multi-anello (donut) per gli elementi del layer in ingresso, utilizzando una distanza e un numero di anelli fissi o dinamici.
Fig. 27.83 Buffer a più anelli per un layer linea, punto e poligono
Permette features in-place modification degli elementi del poligono
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Numero di anelli |
|
[number Predefinito: 1 |
Il numero di anelli. Può essere un valore unico (stesso numero di anelli per tutte gli elementi) o può essere preso dai dati degli elementi (il numero di anelli dipende dai valori degli elementi). |
Distanza tra gli anelli |
|
[number Predefinito: 1.0 |
Distanza tra gli anelli. Può essere un valore unico (stessa distanza per tutti gli elementi) o può essere preso dai dati degli elementi (la distanza dipende dai valori degli elementi). |
Buffer multi-anello (distanza costante) |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Buffer multi-anello (distanza costante) |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita. |
Codice Python
ID Algoritmo: native:multiringconstantbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.46. Da parti multiple a parti singole
Divide elementi multiparte nel layer in ingresso in elementi a parti singole.
Gli attributi del layer in uscita sono gli stessi di quelli originali, ma divisi in elementi singoli.
Fig. 27.84 A sinistra il layer multiparte di origine e a destra il risultato in uscita a parte singola
Permette features in-place modification di punti, linee e poligoni
Menu predefinito:
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Parti singole |
|
[same as input] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Parti singole |
|
[same as input] |
Il layer vettoriale in uscita. |
Codice Python
ID Algoritmo: native:multiparttosingleparts
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.47. Linee di offset
Sposta le linee ad una distanza specificata. Le distanze positive spostano le linee a sinistra, mentre le distanze negative le spostano a destra.
Fig. 27.85 In blu il layer di origine, in rosso quello di offset
Permette features in-place modification di elementi linea
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Distanza |
|
[number Predefinito: 10.0 |
Distanza di offset. Puoi usare il pulsante Sovriscrittura definita dai dati sulla destra per scegliere un campo da cui verrà calcolato il raggio. In questo modo puoi avere un raggio diverso per ogni elemento (vedi Buffer a distanza variabile). |
Segmenti |
|
[number] Predefinito: 8 |
Controlla il numero di segmenti di linea da usare per approssimare un quarto di cerchio quando si creano offset arrotondati. |
Stile unione |
|
[enumeration] Predefinito: 0 |
Specifica se devono essere utilizzati stile di unione di tipo arrotondato, seghettato o smussato quando si esegue l’offset degli angoli in una linea. Le opzioni sono:
Fig. 27.86 Stili di giunzione arrotondati, squadrati e smussati |
Limite a taglio obliquo |
|
[number] Predefinito: 2.0 |
Imposta la distanza massima dalla geometria di offset da utilizzare per creare una giunzione a mitria come fattore della distanza di offset (applicabile solo agli stili di giunzione a mitria). Minimo: 1.0
Fig. 27.87 Un buffer di 10 m con un limite di 2 e un buffer di 10 m con un limite di 1 |
Offset |
|
[vector: line] Predefinito: |
Specificare il layer in uscita (offset). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Offset |
|
[vector: line] |
Vettore lineare in uscita (offset) |
Codice Python
ID Algoritmo: native:offsetline
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.48. Perimetro di delimitazione minimo orientato
Calcola la superficie minima del rettangolo ruotato per ogni elemento nel layer in ingresso.
Fig. 27.88 Perimetro di delimitazione minimo orientato
Permette features in-place modification degli elementi del poligono
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Perimetri di delimitazione |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Perimetri di delimitazione |
|
[vector: polygon] |
Il layer vettoriale poligonale in uscita. |
Codice Python
ID Algoritmo: native:orientedminimumboundingbox
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.49. Ortogonalizza
Tenta di ortogonalizzare le geometrie del layer linea o poligono in ingresso. Questo processo sposta i vertici delle geometrie per cercare di rendere ogni angolo della geometria un angolo retto o una linea retta.
Fig. 27.89 In blu il layer di origine e in rosso il risultato ortogonalizzato
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Tolleranza massima dell’angolo (gradi) |
|
[number] Predefinito: 15 |
Specifica la massima deviazione da un angolo retto o da una linea retta che un vertice può avere per essere aggiustato. Tolleranze più piccole significano che solo i vertici che sono già più vicini all’angolo retto saranno aggiustati, e tolleranze più grandi significano che anche i vertici che si discostano di più dall’angolo retto saranno aggiustati. |
Numero massimo di iterazioni per l’algoritmo |
|
[number] Predefinito: 1000 |
Impostando un numero maggiore come numero massimo di iterazioni, si otterrà una geometria più ortogonale al costo di un tempo di processing maggiore. |
Ortogonalizzato |
|
[same as input] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Ortogonalizzato |
|
[same as input] |
Il vettore poligono in uscita con angoli aggiustati. |
Codice Python
ID Algoritmo: native:orthogonalize
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.50. Punto sulla superficie
Per ogni elemento del layer in ingresso, restituisce un punto che sicuramente giace sulla superficie della geometria dell’elemento.
Permette features in-place modification degli elementi punto
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Creare un punto sulla superficie per ogni parte |
|
[boolean |
Se spuntato, verrà creato un punto per ogni parte della geometria. |
Punto |
|
[vector: point] Predefinito: |
Specifica il layer vettoriale punto in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punto |
|
[vector: point] |
Il layer vettoriale punto in uscita. |
Codice Python
ID Algoritmo: native:pointonsurface
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.51. Punti lungo la geometria
Crea punti a intervalli regolari lungo geometrie lineari o poligonali. I punti creati avranno nuovi attributi aggiunti per la distanza lungo la geometria e l’angolo della linea nel punto.
Può essere specificato un offset opzionale di inizio e fine, che controlla quanto lontano dall’inizio e dalla fine della geometria i punti dovrebbero essere creati.
Fig. 27.90 Punti generati lungo il vettore lineare di origine
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Distanza |
|
[number Predefinito: 1.0 |
Distanza tra due punti consecutivi lungo la linea |
Inizio offset |
|
[number Predefinito: 0.0 |
Distanza dall’inizio della linea in ingresso, che rappresenta la posizione del primo punto. |
Fine offset |
|
[number Predefinito: 0.0 |
Distanza dalla fine della linea in ingresso, che rappresenta la posizione oltre la quale non deve essere creata alcun punto. |
Punti di interpolazione |
|
[vector: point] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punti di interpolazione |
|
[vector: point] |
Layer vettoriale punto con elementi posizionate lungo le linee o i confini dei poligoni del layer in ingresso. |
Codice Python
!ID Algoritmo*: native:pointsalonglines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.52. Spostamento punti
Data una distanza di prossimità, identifica gli elementi puntuali vicini e le distribuisce radialmente su un cerchio il cui centro rappresenta il loro baricentro. Un comodo strumento per sparpagliare gli elementi sovrapposti.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Distanza minima da altri punti |
|
[number] Predefinito: 1.0 |
Distanza al di sotto della quale gli elementi punto sono considerati vicini. Gli elementi vicini sono distribuiti tutti insieme. |
Distanza spostamento |
|
[number] Predefinito: 1.0 |
Raggio del cerchio su cui sono posizionati gli elementi vicini |
Distribuzione orizzontale per il caso di due punti |
|
[boolean] Predefinito: False |
Quando solo due punti sono identificati come vicini, li allinea orizzontalmente sul cerchio invece che verticalmente. |
Spostato |
|
[vector: point] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Spostato |
|
[vector: point] |
Layer vettoriale punto in uscita |
Codice Python
ID Algoritmo: qgis:pointsdisplacement
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.53. Polo di inaccessibilità
Calcola il polo di inaccessibilità per un vettore poligonale, che è il punto interno più distante dal confine della superficie.
Questo algoritmo utilizza l’algoritmo “polylabel” (Vladimir Agafonkin, 2016), che è un approccio iterativo che garantisce di trovare il vero polo di inaccessibilità entro una tolleranza specificata. Una tolleranza più precisa (valore più basso) richiede più iterazioni e richiederà più tempo per il calcolo.
La distanza dal polo calcolato al confine del poligono sarà memorizzata come un nuovo attributo nel layer in uscita.
Fig. 27.91 Polo di inaccessibilità
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Vettore in ingresso |
Tolleranza |
|
[number] Predefinito: 1.0 |
Impostare la tolleranza per il calcolo |
Punto |
|
[vector: point] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Punto |
|
[vector: point] |
Il layer vettoriale punto in uscita |
Codice Python
ID Algoritmo: native:poleofinaccessibility
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.54. Poligonizza
Crea un vettore poligonale i cui confini degli elementi sono generati da un vettore lineare di elementi chiusi.
Fig. 27.92 I poligoni gialli generati dalle linee chiuse
Nota
Il vettore lineare deve avere forme chiuse per essere trasformato in un poligono.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Mantieni i campi dal layer in ingresso Opzionale |
|
[boolean] Predefinito: False |
Controllo per mantenere i campi (solo la struttura della tabella, non i valori) del layer in ingresso. |
Poligoni da linee |
|
[vector: polygon] Predefinito: |
Specifica il layer vettoriale poligonale in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligoni da linee |
|
[vector: polygon] |
Il layer vettore poligono da linee in uscita |
Codice Python
ID Algoritmo: native:polygonize
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.55. Da poligoni a linee
Prende un vettore poligonale e crea un vettore lineare, con linee che rappresentano i confini dei poligoni nel layer in ingresso.
La tabella degli attributi del layer in uscita è la stessa di quella del layer in entrata.
Fig. 27.93 Linee nere come risultato dell’algoritmo
Menu predefinito:
Vedi anche
Da linee a poligoni, Poligonizza, Converti tipo di geometria
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Layer vettoriale poligonale in ingresso |
Linee |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Linee |
|
[vector: line] |
Il layer vettoriale linea da poligoni in uscita |
Codice Python
ID Algoritmo: native:polygonstolines
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.56. Proietta punti (Cartesiano)
Proietta le geometrie punto da una distanza e un orientamento specificati (azimut).
Permette features in-place modification degli elementi punto
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Cuscinetto (gradi da nord) |
|
[number Predefinito: 0.0 |
Angolo in senso orario partendo da Nord, in unita” di grado (°) |
Distanza |
|
[number Predefinito: 1.0 |
Distanza di offset dalle geometrie, in unità layer |
Proiettare |
|
[vector: point] Predefinito: |
Specifica il layer vettoriale punto in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Proiettare |
|
[vector: point] |
Il layer vettoriale punto in uscita (proiettato) |
Codice Python
ID Algoritmo: native:projectpointcartesian
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.57. Trasforma in parti multiple
Prende un layer vettoriale con geometrie a parti singole e ne genera uno nuovo in cui tutte le geometrie sono multi parte.
Gli elementi in ingresso che sono già elementi multi parte rimarranno invariati.
Questo algoritmo può essere usato per forzare le geometrie a tipi multi parte per essere compatibili con i fornitori di dati che richiedono elementi multi parte.
Permette features in-place modification di punti, linee e poligoni
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Multi parte |
|
[same as input] Predefinito: |
Specificare il layer vettoriale multiparte in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Multi parte |
|
[same as input] |
Il layer vettoriale multiparte in uscita |
Codice Python
ID Algoritmo: native:promotetomulti
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.58. Rettangoli, ellissi, rombi
Crea un’area buffer a forma di rettangolo, ellisse o rombo per ogni elemento del layer punto in ingresso
I parametri di forma possono essere fissi per tutti gli elementi o dinamici usando un campo o un’espressione.
Fig. 27.94 Diverse forme di buffer con parametri dinamici
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Forma Buffer |
|
[enumeration] |
La forma da usare. Una di
|
Larghezza |
|
[number Predefinito: 1.0 |
Larghezza della forma del buffer |
Altezza |
|
[number Predefinito: 1.0 |
Altezza della forma del buffer |
Rotazione Opzionale |
|
[number Predefinito: None |
Rotazione della forma del buffer |
Numero di segmenti |
|
[number] Predefinito: 36 |
Numero di segmenti per un cerchio completo (forma Ellissi) |
Output |
|
[vector: polygon] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Output |
|
[vector: polygon] |
Il layer vettoriale in uscita (con le forme del buffer) |
Codice Python
ID Algoritmo: native:rectanglesovalsdiamonds
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.59. Rimuovi vertici duplicati
Rimuove i vertici duplicati dagli elementi, ovunque la rimozione dei vertici non dia luogo a una geometria incongrua.
Il parametro tolerance specifica la tolleranza per le coordinate quando si determina se i vertici sono da considerare identici.
Per impostazione predefinita, i valori Z non sono considerati quando si individuano i vertici duplicati. Ad esempio, due vertici con la stessa coordinata X e Y ma valori Z diversi saranno comunque considerati duplicati e uno verrà rimosso. Se il parametro Usa valore Z è true, allora anche i valori Z vengono testati e i vertici con la stessa X e Y ma Z diversi verranno mantenuti.
Permette features in-place modification di punti, linee e poligoni
Nota
I vertici duplicati non vengono testati tra le diverse parti di una geometria multi parte, ad esempio una geometria a più punti con punti sovrapposti non verrà modificata da questo metodo.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Tolleranza |
|
[number Predefinito: 0.000001 |
I vertici più vicini della distanza specificata sono considerati duplicati |
Usa valore Z |
|
[boolean Predefinito: False |
Se il parametro Usa valore Z è vero, allora anche i valori Z sono testati e i vertici con la stessa X e Y ma Z diversi saranno mantenuti. |
Pulito |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Pulito |
|
[same as input] |
Il layer vettoriale in uscita (senza vertici duplicati) |
Codice Python
ID Algoritmo: native:removeduplicatevertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.60. Rimuovi geometrie nulle
Rimuove tutti gli elementi che non hanno una geometria di layer vettoriale. Tutte gli altri elementi saranno copiati invariati.
Gli elementi con geometrie nulle possono essere salvati in un layer separato.
Se Rimuovere anche geometrie vuote è selezionato, l’algoritmo rimuove gli elementi le cui geometrie non hanno coordinate, cioè le geometrie che sono vuote. In tal caso, anche il risultato null rifletterà questa opzione, contenendo sia le geometrie nulle che quelle vuote.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Layer vettoriale in ingresso (con geometrie non NULL) |
Rimuovi anche le geometrie vuote |
|
[boolean] |
|
Geometrie non nulle |
Opzionale |
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita per le geometrie non-NULL (e non-empty). Uno di:
La codifica del file può anche essere cambiata qui. |
Geometrie Null Opzionale |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita per le geometrie NULL (e vuote). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Geometrie Null |
|
[same as input] |
Layer vettoriale in uscita (per NULL e, se scelto, geometrie vuote) |
Geometrie non nulle |
|
[same as input] |
Il layer vettoriale in uscita (senza geometrie NULL e, se scelto, senza geometrie vuote) |
Codice Python
ID Algoritmo: native:removenullgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.61. Inverti verso linea
Inverte la direzione di un vettore lineare.
Fig. 27.95 Prima e dopo l’inversione di direzione
Permette features in-place modification di elementi linea
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Invertite |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Invertite |
|
[vector: line] |
Il layer vettoriale lineare in uscita (con linee invertite) |
Codice Python
ID Algoritmo: native:reverselinedirection
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.62. Ruota
Ruota le geometrie dell’angolo specificato in senso orario. La rotazione avviene intorno al centroide di ogni elemento, o opzionalmente intorno ad un unico punto preimpostato.
Permette features in-place modification di punti, linee e poligoni
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Rotazione (gradi in senso orario) |
|
[number Predefinito: 0.0 |
Angolo di rotazione in gradi |
Punto di ancoraggio della rotazione (x, y) Opzionale |
|
[point] Predefinito: None |
Coordinate X,Y del punto attorno al quale ruotare gli elementi. Se non è impostato, la rotazione avviene intorno al centroide di ogni elemento. |
Ruotato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (con geometrie ruotate). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Ruotato |
|
[same as input] |
Il layer vettoriale in uscita con geometrie ruotate |
Codice Python
ID Algoritmo: native:rotatefeatures
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.63. Rotondità
NEW in 3.24
Calcola la rotondità di ogni elemento e la memorizza come nuovo campo. Il layer vettoriale in ingresso deve essere composto da poligoni.
La rotondità di un poligono è definita come 4π × area del poligono / perimetro². Il valore di rotondità varia da 0 a 1. Un cerchio perfetto ha una rotondità pari a 1, mentre un poligono completamente piatto ha una rotondità pari a 0.
Nota
L’algoritmo restituisce NULL per gli elementi poligono multi parte.
Permette features in-place modification degli elementi del poligono
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Vettore in ingresso |
Rotondità |
|
[vector: polygon] Predefinito: |
Specificare il layer del vettore in uscita (con campo di rotondità). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Ruotato |
|
[same as input] |
Il layer del vettore in uscita con il valore di rotondità in un campo |
Codice Python
ID Algoritmo: native:roundness
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.64. Segmenta in base all’angolo massimo
Segmenta una geometria convertendo sezioni curve in sezioni lineari.
La segmentazione viene eseguita specificando il massimo angolo di curvatura consentito tra i vertici sulla geometria raddrizzata (ad esempio l’angolo dell’arco creato dal centro dell’arco originale ai vertici consecutivi in uscita sulla geometria linearizzata). Le geometrie non curve saranno mantenute senza modifiche.
Vedi anche
Segmenta in base alla distanza massima, Semplifica, Lisciatura
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Angolo massimo tra i vertici (gradi) |
|
[number Predefinito: 5.0 |
Massimo angolo di curvatura consentito tra i vertici della geometria raddrizzata |
Segmentato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (con geometrie segmentate). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Segmentato |
|
[same as input] |
Il layer vettoriale in uscita con le geometrie segmentate |
Codice Python
ID Algoritmo: native:segmentizebymaxangle
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.65. Segmenta in base alla distanza massima
Segmenta una geometria convertendo sezioni curve in sezioni lineari.
La segmentazione viene eseguita specificando la massima distanza di offset consentita tra la curva originale e la rappresentazione segmentata. Le geometrie non curve saranno mantenute senza modifiche.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Massima distanza di offset |
|
[number Predefinito: 1.0 |
Massima distanza di offset consentita tra la curva originale e la rappresentazione segmentata, in unità layer. |
Segmentato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (con geometrie segmentate). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Segmentato |
|
[same as input] |
Il layer vettoriale in uscita con le geometrie segmentate |
Codice Python
ID Algoritmo: native:segmentizebymaxdistance
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.66. Imposta il valore M
Imposta il valore M per le geometrie in un layer.
Se i valori M esistono già nel layer, saranno sovrascritti con il nuovo valore. Se non esistono valori M, la geometria sarà aggiornata per includere valori M e il valore specificato sarà usato come valore M iniziale per tutte le geometrie.
Permette features in-place modification di punti, linee e poligoni con M abilitato
Suggerimento
Usa il pulsante 
Identifica elementi per controllare il valore M aggiunto: i risultati sono disponibili nella finestra di dialogo Identifica risultati.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Valore M |
|
[number Predefinito: 0.0 |
Valore M da assegnare agli elementi geometrici |
Aggiunto M |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Aggiunto M |
|
[same as input] |
Il layer vettoriale in uscita (con valori M assegnati alle geometrie) |
Codice Python
*ID Algoritmo: native:setmvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.67. Imposta valore M dal raster
Utilizza valori campionati da una banda all’interno di un layer raster per impostare il valore M per ogni vertice sovrapposto nella geometria dell” elemento. I valori raster possono opzionalmente essere scalati di una quantità preimpostata.
Se i valori M esistono già nel layer, saranno sovrascritti con il nuovo valore. Se non esistono valori M, la geometria sarà aggiornata per includere i valori M.
Permette features in-place modification di punti, linee e poligoni con M abilitato
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Layer raster |
|
[raster] |
Layer raster con valori M |
Numero banda |
|
[raster band] Predefinito: 1 |
La banda raster da cui sono presi i valori M |
Valore per nodata o vertici non intersecanti |
|
[number |
Valore da usare nel caso in cui il vertice non intersechi (in un pixel valido) il raster |
Fattore di scala |
|
[number Predefinito: 1.0 |
Valore di scala: i valori della banda sono moltiplicati per questo valore. |
Offset
|
|
[number Predefinito: 0.0 |
Valore di offset: viene aggiunto algebricamente ai valori della banda dopo aver applicato il «Fattore di scala». |
Aggiornato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale in uscita (con i valori M aggiunti). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Aggiornato |
|
[same as input] |
Il layer vettoriale in uscita (con i valori M aggiornati) |
Codice Python
ID Algoritmo: native:setmfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.68. Imposta il valore Z
Imposta il valore Z per le geometrie in un layer.
Se i valori Z esistono già nel layer, saranno sovrascritti con il nuovo valore. Se non esistono valori Z, la geometria sarà aggiornata per includere valori Z e il valore specificato sarà usato come valore Z iniziale per tutte le geometrie.
Permette features in-place modification di punti, linee e poligoni con Z abilitato
Suggerimento
Usa il pulsante Identifica elementi per controllare il valore Z aggiunto: i risultati sono disponibili nella finestra di dialogo Identifica risultati.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Valore Z |
|
[number Predefinito: 0.0 |
Valore Z da assegnare agli elementi geometrici |
**Aggiunto Z ** |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
**Aggiunto Z ** |
|
[same as input] |
Il layer del vettore in uscita (con i valori Z assegnati) |
Codice Python
ID Algoritmo: native:setzvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.69. Semplifica
Semplifica le geometrie di un vettore lineare o poligonale. Crea un nuovo layer con gli stessi elementi del layer in ingresso, ma con geometrie contenenti un numero inferiore di vertici.
L’algoritmo dà una scelta di metodi di semplificazione, compresi quelli basati sulla distanza (l’algoritmo «Douglas-Peucker»), basati sull’area (algoritmo «Visvalingam») e l’aggancio delle geometrie al reticolo.
Fig. 27.96 In senso orario dall’alto a sinistra: layer di origine e aumento delle tolleranze di semplificazione
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Menu predefinito:
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Metodo di semplificazione |
|
[enumeration] Predefinito: 0 |
Metodo di semplificazione. Uno di:
|
Tolleranza |
|
[number Predefinito: 1.0 |
Soglia di tolleranza (in unità del layer): se la distanza tra due nodi è inferiore al valore di tolleranza, il segmento sarà semplificato e i vertici saranno rimossi. |
Semplificato |
|
[same as input] Predefinito: |
Specificare il layer vettoriale (semplificato) in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Semplificato |
|
[same as input] |
Il layer vettoriale in uscita (semplificato) |
Codice Python
ID Algoritmo: native:simplifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.70. Buffer su un solo lato
Calcola un buffer sulle linee per una distanza specificata su un solo lato della linea.
Il buffer genera sempre un vettore poligonale.
Fig. 27.97 Buffer laterale sinistro rispetto a quello destro sullo stesso layer del vettore lineare
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Distanza |
|
[number] Predefinito: 10.0 |
Distanza Buffer |
Lato |
|
[enumeration] Predefinito: 0 |
Su quale lato creare il buffer. Uno dei due:
|
Segmenti |
|
[number] Predefinito: 8 |
Controlla il numero di segmenti di linea da usare per approssimare un quarto di cerchio quando si creano offset arrotondati. |
Stile unione |
|
[enumeration] Predefinito: 0 |
Specifica se devono essere utilizzati stile di unione di tipo arrotondato, seghettato o smussato quando si esegue l’offset degli angoli in una linea. Le opzioni sono:
Fig. 27.98 Stili di giunzione arrotondati, squadrati e smussati |
Limite a taglio obliquo |
|
[number] Predefinito: 2.0 |
Imposta la distanza massima dalla geometria di offset da utilizzare per creare una giunzione a mitria come fattore della distanza di offset (applicabile solo agli stili di giunzione a mitria). Minimo: 1.0
Fig. 27.99 Un buffer di 10 m con un limite di 2 e un buffer di 10 m con un limite di 1 |
Buffer |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (buffer). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Buffer |
|
[vector: polygon] |
Vettore poligonale in uscita (buffer) |
Codice Python
ID Algoritmo: native:singlesidedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.71. Lisciatura
Smussa le geometrie in un vettore lineare o poligonale aggiungendo più vertici e angoli agli elementi geometrici.
Il parametro iterations detta quante iterazioni di smussamento saranno applicate ad ogni geometria. Un numero maggiore di iterazioni produce geometrie più lisce al costo di un numero maggiore di nodi nelle geometrie.
Fig. 27.100 L’aumento del numero di iterazioni causa geometrie più lisce
Il parametro offset controlla quanto «strettamente» le geometrie smussate seguono le geometrie originali. Valori più piccoli si traducono in un adattamento più stretto, e valori più grandi creeranno un adattamento meno stretto.
Fig. 27.101 Blu: il layer in ingresso. L’offset 0,25 genera la linea rossa, mentre l’offset 0,50 genera la linea verde.
Il parametro dell’angolo massimo può essere usato per prevenire lo smussamento dei nodi con grandi angoli. Qualsiasi nodo dove l’angolo dei segmenti da entrambi i lati è più grande di questo non sarà smussato. Per esempio, impostando l’angolo massimo a 90 gradi o inferiore si preservano gli angoli retti nella geometria.
Permette :ref:``features in-place modification <processing_inplace_edit>` di linee e poligoni
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line, polygon] |
Layer vettoriale di linee o poligoni in ingresso |
Iterazioni |
|
[number Predefinito: 1 |
Aumentando il numero di iterazioni si ottengono geometrie più lisce (e più vertici). |
Offset |
|
[number Predefinito: 0.25 |
Aumentando i valori si spostano le linee/confini smussati più lontano dalle linee/confini in ingresso. |
Angolo massimo al nodo da smussare |
|
[number Predefinito: 180.0 |
Al di sotto di questo valore ogni nodo sarà smussato |
Smussato |
|
[same as input] Predefinito: |
Specificare il layer in uscita (smussato). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Smussato |
|
[same as input] |
Layer vettoriale in uscita (smussato) |
Codice Python
ID Algoritmo: native:smoothgeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.72. Aggancia geometrie al vettore
Aggancia le geometrie in un vettore con quelle con quelle di un altro o con quelle all’interno dello stesso vettore.
La correzione è fatta sulla base di una distanza di tolleranza, e i vertici saranno inseriti o rimossi come richiesto per far sì che le geometrie corrispondano a quelle di riferimento.
Permette features in-place modification di punti, linee e poligoni
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Layer di riferimento |
|
[vector: any] |
Layer vettoriale al quale agganciarsi |
Tolleranza |
|
[number] Predefinito: 10.0 |
Controlla quanto i vertici in ingresso devono essere vicini alle geometrie del layer di riferimento prima di essere agganciati. |
Comportamento |
|
[enumeration] Predefinito: 0 |
L’aggancio può essere fatto su un nodo esistente o su un segmento (il suo punto più vicino al vertice da spostare). Opzioni di aggancio disponibili:
|
Geometria agganciata |
|
[same as input] Predefinito: |
Specificare il layer in uscita (snapped). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Geometria agganciata |
|
[same as input] |
Layer vettoriale in uscita (agganciato) |
Codice Python
ID Algoritmo: native:snapgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.73. Aggancia punti al reticolo
Modifica le coordinate delle geometrie in un vettore, così che tutti i punti o vertici siano agganciati al più vicino punto di un reticolo.
Se una geometria agganciata non può essere calcolata (o è totalmente collassata) la geometria dell’elemento sarà eliminata.
L’aggancio può essere eseguito sugli assi X, Y, Z o M. Una spaziatura del reticolo di 0 per qualsiasi asse disabiliterà l’aggancio per quell’asse.
Permette features in-place modification di punti, linee e poligoni
Nota
Agganciare al reticolo può generare una geometria non valida in alcuni casi particolari.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Spaziatura X del reticolo |
|
[number Predefinito: 1.0 |
Spaziatura del reticolo sull’asse X |
Spaziatura Y del reticolo |
|
[number Predefinito: 1.0 |
Spaziatura del reticolo sull’asse Y |
Spaziatura Z del reticolo |
|
[number Predefinito: 0.0 |
Spaziatura del reticolo sull’asse Z |
Spaziatura M del reticolo |
|
[number Predefinito: 0.0 |
Spaziatura del reticolo sull’asse M |
Agganciato |
|
[same as input] Predefinito: |
Specificare il layer in uscita (snapped). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Agganciato |
|
[same as input] |
Layer vettoriale in uscita (agganciato) |
Codice Python
ID Algoritmo: native:snappointstogrid
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.74. Dividi linee secondo lunghezza massima
Prende un layer linea (o curva) e divide ogni elemento in più parti, dove ogni parte ha una lunghezza massima specificata. I valori Z e M all’inizio e alla fine delle nuove sottostringhe di linea sono interpolati linearmente dai valori esistenti.
Permette features in-place modification di elementi linea
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Il layer vettoriale della linea in ingresso |
Lunghezza massima della linea |
|
[number Predefinito: 10.0 |
La lunghezza massima di una linea in uscita. |
Suddiviso |
|
[vector: line] Predefinito: |
Specifica il layer vettoriale della linea in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Suddiviso |
|
[vector: line] |
Il nuovo layer del vettore linea - la lunghezza degli elementi geometrici è inferiore o uguale alla lunghezza specificata nel parametro LENGTH. |
Codice Python
ID Algoritmo: native:splitlinesbylength
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.75. Suddividi
Suddivide la geometria. La geometria restituita sarà una collezione contenente parti suddivise della geometria originale, dove nessuna parte ha più del numero massimo di nodi specificato.
Questo è utile per dividere una geometria complessa in parti meno complesse, più facile da indicizzare spazialmente e più veloce per eseguire operazioni spaziali. Le geometrie curve saranno segmentate prima della suddivisione.
Fig. 27.102 A sinistra il layer in ingresso, il valore massimo dei nodi al centro è 100 e il valore massimo a destra è 200
Permette features in-place modification di punti, linee e poligoni
Nota
La suddivisione di una geometria può generare parti di geometria che possono non essere valide e possono contenere autointersecazioni.
Vedi anche
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Il layer vettore in ingresso |
Massimo numero di nodi nelle parti |
|
[number Predefinito: 256 |
Numero massimo di vertici che ogni nuova parte della geometria può avere. Meno sub-parts per valori più alti. |
Suddiviso |
|
[same as input] Predefinito: |
Specifica il layer vettoriale in uscita (suddiviso). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Suddiviso |
|
[same as input] |
Layer vettore in uscita |
Codice Python
ID Algoritmo: native:subdivide
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.76. Scambia le coordinate X e Y
Cambia i valori della coordinata X e Y nelle geometrie in ingresso.
Può essere usato per correggere le geometrie che hanno accidentalmente i loro valori di latitudine e longitudine invertiti.
Permette features in-place modification di punti, linee e poligoni
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Il layer vettore in ingresso |
Scambiato |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Scambiato |
|
[same as input] |
Layer vettoriale in uscita (scambiato) |
Codice Python
ID Algoritmo: native:swapxy
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.77. Buffer arrotondati
Crea un buffer arrotondato lungo le geometrie lineari, utilizzando uno specificato diametro iniziale e finale per il buffer.
Fig. 27.103 Esempio di buffer arrotondato
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Larghezza iniziale |
|
[number Predefinito: 0.0 |
Rappresenta il raggio del buffer applicato al punto iniziale dell’elemento lineare. |
Larghezza finale |
|
[number Predefinito: 0.0 |
Rappresenta il raggio del buffer applicato al punto finale dell’elemento lineare. |
Segmenti |
|
[number Predefinito: 16 |
Controlla il numero di segmenti di linea da usare per approssimare un quarto di cerchio quando si creano offset arrotondati. |
Bufferizzato |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (buffer). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Bufferizzato |
|
[vector: polygon] |
Vettore poligonale in uscita (buffer) |
Codice Python
ID Algoritmo: native:taperedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.78. Mosaicatura
Tassella un vettore poligonale, dividendo le geometrie in triangoli.
Il risultato consiste in geometrie multipoligonali per ogni elemento in ingresso, con ogni multi poligono costituito da poligoni triangolari.
Fig. 27.104 Poligono tassellato (destra)
Permette features in-place modification degli elementi del poligono
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: polygon] |
Layer vettoriale poligonale in ingresso |
Tassellato |
|
[vector: polygon] Predefinito: |
Specifica il layer in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Tassellato |
|
[vector: polygon] |
Layer multipoligonoZ in uscita |
Codice Python
ID Algoritmo: 3d:tessellate
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.79. Transetto
Crea transetti sui vertici per (multi)linee.
Un transetto è una linea orientata da un angolo (predefinito: perpendicolare) ad una polilinea in ingresso (ai vertici).
Il campo(i) dell’elemento(i) sono restituiti nel transetto con questi nuovi campi:
TR_FID: ID dell’elemento originale
TR_ID: ID del transetto. Ogni transetto ha un ID univoco
TR_SEGMENT: ID del segmento della linea
TR_ANGLE: Angolo in gradi dalla linea originale al vertice
TR_LENGTH: Lunghezza totale del transetto
TR_ORIENT: Lato del transetto (solamente a sinistra o a destra della linea, o entrambi i lati)
Fig. 27.105 La linea rossa tratteggiata rappresenta il transetto del vettore lineare in ingresso.
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Lunghezza del transetto |
|
[number Predefinito: 5.0 |
Lunghezza in unità di mappa del transetto |
Angolo in gradi dalla linea originale ai vertici |
|
[number Predefinito: 90.0 |
Cambiare l’angolo del transetto |
Lato per creare il transetto |
|
[enumeration] |
Scegli il lato del transetto. Le opzioni disponibili sono:
|
Transetto |
|
[vector: line] Predefinito: |
Specifica il vettore lineare in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Transetto |
|
[vector: line] |
Vettore lineare in uscita |
Codice Python
ID Algoritmo: native:transect
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.80. Trasla
Sposta le geometrie di un layer, con uno spostamento di offset X e Y prestabilito.
Anche i valori Z e M presenti nella geometria possono essere traslati.
Fig. 27.106 Le linee tratteggiate rappresentano la geometria traslata del layer in ingresso
Permette features in-place modification di punti, linee e poligoni
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: any] |
Vettore in ingresso |
Distanza di offset (asse-x) |
|
[number Predefinito: 0.0 |
Spostamento da applicare sull’asse X |
Distanza di offset (asse-y) |
|
[number Predefinito: 0.0 |
Spostamento da applicare sull’asse Y |
Distanza di offset (asse-z) |
|
[number Predefinito: 0.0 |
Spostamento da applicare sull’asse Z |
Distanza di Offset (valori m) |
|
[number Predefinito: 0.0 |
Spostamento da applicare sull’asse M |
Traslato |
|
[same as input] Predefinito: |
Specificare il vettore in uscita. Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Traslato |
|
[same as input] |
Layer vettore in uscita |
Codice Python
ID Algoritmo: native:translategeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.81. Buffer larghezza variabile (valore M)
Crea buffer di larghezza variabile lungo le linee, usando il valore M delle geometrie delle linee come diametro del buffer ad ogni vertice.
Fig. 27.107 Esempio buffer variabile
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: line] |
Layer vettoriale lineare in ingresso |
Segmenti |
|
[number Predefinito: 16 |
Numero dei segmenti buffer per quarto di cerchio. Può essere un valore unico (stesso valore per tutte gli elementi), o può essere preso dai dati degli elementi (il valore può dipendere dagli attributi degli elementi). |
Bufferizzato |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (buffer). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Bufferizzato |
|
[vector: polygon] |
Buffer vettore poligonale variabile |
Codice Python
ID Algoritmo: native:bufferbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.
27.1.18.82. Poligoni di Voronoi
Prende un layer punto e genera un vettore poligonale contenente i poligoni di Voronoi (conosciuti anche come poligoni di Thiessen) corrispondenti a quei punti in ingresso.
Ogni posizione all’interno di un poligono di Voronoi è più vicino al punto associato che a qualsiasi altro punto.
Fig. 27.108 Poligoni di Voronoi
Menu predefinito:
Parametri
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Layer in ingresso |
|
[vector: point] |
Layer vettoriale di punti in ingresso |
Regione buffer (% dell’estensione) |
|
[number] Predefinito: 0.0 |
L’estensione del layer in uscita sarà così tanto più grande dell’estensione del layer in ingresso |
Poligoni di Voronoi |
|
[vector: polygon] Predefinito: |
Specificare il layer in uscita (con i poligoni di Voronoi). Uno di:
La codifica del file può anche essere cambiata qui. |
In uscita:
Etichetta |
Nome |
Tipo |
Descrizione |
|---|---|---|---|
Poligoni di Voronoi |
|
[vector: polygon] |
Poligoni di Voronoi del layer vettoriale puntuale in ingresso |
Codice Python
ID Algoritmo: qgis:voronoipolygons
import processing
processing.run("algorithm_id", {parameter_dictionary})
L” id algoritmo viene visualizzato quando si passa il mouse sull’algoritmo nella finestra degli strumenti di elaborazione. Il dizionario dei parametri fornisce i Nomi e i valori dei parametri. Vedi Usare gli algoritmi di Processing dalla console dei comandi per dettagli su come eseguire algoritmi di elaborazione dalla console Python.