Come bufferizzare i pixel raster in base ai loro valori?

I pixel a sinistra rappresentano le posizioni dell'albero e i raggi della corona associati (ovvero i valori dei pixel vanno da 2 a 5). Vorrei bufferizzare questi pixel raster per il loro valore del raggio della corona. L'immagine a destra è ciò che spero di ottenere utilizzando solo metodi di elaborazione raster .

Inizialmente penserei di utilizzare una somma focale circolare in ArcGIS, sebbene l'impostazione del vicinato sia un valore fisso, che non prenderebbe in considerazione il raggio della corona di dimensioni variabili.

Qual è un buon metodo per "bufferizzare" i pixel in base ai loro valori?

Ecco una soluzione raster pura Python 2.7nell'uso numpye scipy:

import numpy as np
from scipy import ndimage
import matplotlib.pyplot as plt

#create tree location matrix with values indicating crown radius
A = np.zeros((120,320))
A[60,40] = 1
A[60,80] = 2
A[60,120] = 3
A[60,160] = 4
A[60,200] = 5
A[60,240] = 6
A[60,280] = 7

#plot tree locations
fig = plt.figure()
plt.imshow(A, interpolation='none')
plt.colorbar()

#find unique values
unique_vals = np.unique(A)
unique_vals = unique_vals[unique_vals > 0]

# create circular kernel
def createKernel(radius):
    kernel = np.zeros((2*radius+1, 2*radius+1))
    y,x = np.ogrid[-radius:radius+1, -radius:radius+1]
    mask = x**2 + y**2 <= radius**2
    kernel[mask] = 1
    return kernel

#apply binary dilation sequentially to each unique crown radius value 
C = np.zeros(A.shape).astype(bool)   
for k, radius in enumerate(unique_vals):  
    B = ndimage.morphology.binary_dilation(A == unique_vals[k], structure=createKernel(radius))
    C = C | B #combine masks

#plot resulting mask   
fig = plt.figure()
plt.imshow(C, interpolation='none')
plt.show()

Ingresso:

Produzione:

Approccio basato su vettori

Questa attività può essere eseguita in tre passaggi:

• Raster To Point;
• Buffer(utilizzando il VALUEcampo come campo buffer );
• Feature To Raster.

Nota: l'utilizzo del campo buffer evita il calcolo di un buffer per ciascun valore del raggio della corona.

Approccio basato su raster

Evitando la soluzione basata su vettori, questo problema suggerisce di utilizzare una specie di automi cellulari basati sui vicini più vicini. Supponendo che tutti i pixel neri siano zeri, i pixel siano quadrati e la loro dimensione sia uguale a 1 (o, in alternativa, siano opportunamente ridimensionati), le regole da adottare sono molto semplici:

1. Se il valore del pixel ( VALUE) è maggiore di 1, il suo valore diventa VALUE-1e quindi considera i pixel circostanti. Se i loro valori sono inferiori a VALUE-1, questi pixel nascono o crescono e il loro valore diventa VALUE-1. Altrimenti, questi pixel sopravvivono e rimangono invariati.
2. Se VALUE<=1non fai nulla (il pixel è morto!).

Queste regole devono essere applicate fino a quando tutti i pixel non sono morti, ovvero i loro valori sono uguali a 0 o 1. Quindi N-1, volte, dov'è Nil valore massimo che hai nell'input raster. Questo approccio può essere facilmente implementato con un po 'di Python e numpy.

Un'altra opzione sarebbe quella di creare raster separati per ciascun valore di pixel, in questo caso 4 raster, con una condizione. Quindi espandere i raster di un numero di pixel corrispondente al valore del raster (eventualmente ripetendo un elenco di valori). Infine, unisciti ai raster (algebrici o spazialmente), per creare un raster binario per le corone degli alberi.

È una domanda difficile farlo in raster perché non hai l'opportunità di usare il valore del pixel per definire la dimensione del buffer. Pertanto, è necessario fare il filtro focale per ciascun valore, come già detto.

Ecco una possibile risposta per farlo con solo 3 filtri (non riuscivo a trovarne di meno), ma non perfettamente come menzionato da Whuber: i tuoi buffer verranno troncati quando gli alberi si avvicinano.

1) EDIT: allocazione euclidea (questo non risolve completamente il problema, poiché taglia i buffer in prossimità di alberi più piccoli, ma è meglio dei manufatti della mia prima soluzione).

2) distanza euclidea attorno a ciascun pixel

3) calcolatrice raster (mappa algebra) con una dichiarazione condizionale

Con("allocation_result" > ("distance_result" / pixel_size) , 1 , 0)

Si noti che è possibile regolare la condizione in base alle proprie esigenze in termini di raggio (con o senza pixel centrale)

Ti chiedi perché non usi lo strumento di espansione di ArcGIS ?

import arcpy
from arcpy.sa import *

raster_in  = r'c:\test.tif'
raster_out = r'c:\test_out.tif'

outExpand1 = Expand(raster_in, 2, 2)
outExpand2 = Expand(outExpand1, 3, 3)
outExpand3 = Expand(outExpand3, 4, 4)
outExpand4 = Expand(outExpand4, 5, 5)

outExpand4.save(raster_out)

In caso di sovrapposizione: l'ultimo expandcomando coprirà quelli precedenti.

Se hai la posizione dei pixel, il raggio e l' algoritmo del cerchio del punto medio (una variante di Bresenham Alg.) Ti danno un indizio. IMO è facile creare un poligono da questo approccio e penso che sia facile implementarlo in Python. Un'unione di questo set di poligoni ti dà l'area di copertura.