Como buffer pixels de varredura por seus valores?

Os pixels à esquerda representam os locais das árvores e seus raios de coroa associados (ou seja, valores de pixels que variam de 2 a 5). Gostaria de armazenar em buffer esses pixels de varredura pelo valor do raio da coroa. A imagem à direita é o que espero obter usando apenas métodos de processamento de varredura .

Inicialmente, eu pensaria em usar uma soma focal circular no ArcGIS, embora a configuração da vizinhança seja um valor fixo, o que não levaria em consideração o raio da coroa de tamanho variável.

Qual é um bom método para "buffer" de pixels por seus valores?

Aqui está uma solução pura de varredura no Python 2.7uso 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()

Entrada:

Saída:

Abordagem baseada em vetor

Esta tarefa pode ser realizada em três etapas:

• Raster To Point;
• Buffer(usando o VALUEcampo como campo de buffer );
• Feature To Raster.

Nota: o uso do campo buffer evita o cálculo de um buffer para cada valor do raio da coroa.

Abordagem baseada em varredura

Evitando a solução baseada em vetores, esse problema sugere o uso de um tipo de autômato celular baseado nos vizinhos mais próximos. Supondo que todos os pixels pretos sejam zeros, os pixels são quadrados e seu tamanho é igual a 1 (ou, como alternativa, são dimensionados oportunamente), as regras a serem adotadas são muito simples:

1. Se o valor do pixel ( VALUE) for maior que 1, seu valor se tornará VALUE-1e, em seguida, considere os pixels adjacentes. Se seus valores forem menores que VALUE-1, esses pixels nascem ou crescem e seu valor se torna VALUE-1. Caso contrário, esses pixels sobreviverão e permanecerão inalterados.
2. Se VALUE<=1não fizer nada (o pixel está morto!).

Essas regras devem ser aplicadas até que todos os pixels estejam mortos, ou seja, seus valores são iguais a 0 ou 1. Então N-1, vezes, onde Né o valor máximo que você tem na varredura de entrada. Essa abordagem pode ser facilmente implementada com um pouco de Python e numpy.

Outra opção seria criar separadores separados para cada valor de pixel, neste caso 4 separadores, com uma condição. Em seguida, expanda os rasters por uma contagem de pixels correspondente ao valor da varredura (possivelmente repetindo uma lista de valores). Por fim, junte os rasters (algébricos ou espaciais), para criar uma varredura binária para as copas das árvores.

É uma pergunta desafiadora fazer isso em varredura, porque você não tem a oportunidade de usar o valor do pixel para definir o tamanho do buffer. Portanto, você precisaria fazer o filtro focal para cada valor, como você já disse.

Aqui está uma resposta possível para fazer isso com apenas 3 filtros (não consegui encontrar menos), mas não perfeitamente como mencionado por Whuber: seus buffers serão truncados quando as árvores estiverem próximas umas das outras.

1) EDIT: Alocação euclidiana (isso não resolve completamente o problema, pois corta os buffers nas proximidades de árvores menores, mas é melhor que os artefatos da minha primeira solução).

2) distância euclidiana em torno de cada pixel

3) calculadora raster (álgebra de mapa) com uma declaração condicional

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

Observe que você pode ajustar a condição dependendo das suas necessidades em termos de raio (com ou sem o pixel central)

Pergunto por que você não usa a ferramenta de expansão do 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)

Em caso de sobreposição: o último expandcomando cobrirá os anteriores.

Se você tiver a posição do pixel, o raio e o algoritmo do círculo do ponto médio (uma variante do algoritmo Bresenham) fornecem uma pista. Na IMO, é fácil criar um polígono a partir dessa abordagem e acho fácil implementá-lo no Python. A união desse conjunto de polígonos fornece a área de cobertura.