Estrazione delle aree della corona dell'albero dai dati di telerilevamento (immagini visive e LiDAR)

Sto cercando un metodo per elaborare un'immagine di telerilevamento ed estrarre dall'immagine le aree della corona dei singoli alberi.

Ho sia immagini di lunghezza d'onda visiva sia dati lidar dell'area. La posizione in questione è un'area desertica, quindi la copertura dell'albero non è fitta come una foresta. La risoluzione delle immagini aeree è di 0,5 piedi per 0,5 piedi. La risoluzione del lidar è di circa 1 x 1 piedi. Sia i dati visivi che il lidar provengono da un set di dati di Pima County, in Arizona. Un esempio del tipo di immagini aeree che ho è alla fine di questo post.

Questa domanda Rilevamento albero singolo in ArcMap? sembra essere lo stesso problema, ma non sembra esserci una buona risposta lì.

Posso ottenere una classificazione ragionevole dei tipi di vegetazione (e informazioni sulla copertura percentuale complessiva) nell'area usando la classificazione Iso Cluster in Arcmap, ma ciò fornisce poche informazioni sui singoli alberi. Il più vicino a ciò che voglio sono i risultati del passaggio dell'output della classificazione isocluster attraverso la funzione Raster a Polygon in Arcmap. Il problema è che questo metodo si fonde vicino agli alberi in un singolo poligono.

Modifica: probabilmente avrei dovuto includere qualche dettaglio in più su ciò che ho. I set di dati grezzi che ho sono:

• Dati las completi e un tiff raster generato da esso.
• Immagini visive (come l'immagine di esempio mostrata, ma che copre un'area molto più ampia)
• Misurazioni dirette manuali di un sottoinsieme di alberi nell'area.

Da questi ho generato:

1. Le classificazioni terreno / vegetazione.
2. I raster DEM / DSM.

Esiste una notevole mole di letteratura sul rilevamento di singole corone nei dati spettrali e lidar. Metodi saggi, forse iniziano con:

Falkowski, MJ, AMS Smith, PE Gessler, AT Hudak, LA Vierling e JS Evans. (2008). L'influenza della copertura del baldacchino della foresta di conifere sull'accuratezza di due singoli algoritmi di misurazione dell'albero utilizzando i dati lidar. Canadian Journal of Remote Sensing 34 (2): 338-350.

Smith AMS, EK Strand, CM Steele, DB Hann, SR Garrity, MJ Falkowski, JS Evans (2008) Produzione di mappe della struttura spaziale della vegetazione mediante analisi per oggetto di invasione di ginepro in fotografie aeree multi-temporali. Canadian Journal Remote Sensing 34 (2): 268-285

Se sei interessato al metodo Wavelet (Smith et al., 2008), l'ho codificato in Python ma è molto lento. Se hai esperienza con Matlab, è qui che viene implementato in modalità di produzione. Abbiamo due articoli in cui abbiamo identificato ~ 6 milioni di acri di invasione di ginepro nell'Oregon orientale usando il metodo wavelet con immagini NAIP RGB-NIR, quindi è ben provato.

Baruch-Mordo, S., JS Evans, J. Severson, JD Naugle, J. Kiesecker, J. Maestas e MJ Falkowski (2013) Salvataggio di salvia dagli alberi: una soluzione proattiva per ridurre una minaccia chiave per un candidato specie Conservazione biologica 167: 233-241

Poznanovic, AJ, MJ Falkowski, AL Maclean e JS Evans (2014) Una valutazione di precisione degli algoritmi di rilevamento degli alberi nei boschi di Juniper. Ingegneria fotogrammetrica e telerilevamento 80 (5): 627–637

Ci sono alcuni approcci interessanti, in generale la decomposizione degli oggetti, dalla letteratura spaziale sulla matematica dello stato di stato applicata che utilizza processi gaussiani multirisoluzione per scomporre le caratteristiche dell'oggetto su scala. Uso questi tipi di modelli per descrivere il processo su più scale nei modelli ecologici, ma potrebbe essere adattato per scomporre le caratteristiche degli oggetti immagine. Divertente, ma un po 'esoterico.

Gramacy, RB e HKH Lee (2008) modelli di processo gaussiani a tre punte bayesiani con un'applicazione alla modellazione al computer. Journal of American Statistical Association, 103 (483): 1119-1130

Kim, HM, BK Mallick e CC Holmes (2005) Analisi dei dati spaziali non stazionari usando processi gaussiani a tratti. Journal of American Statistical Association, 100 (470): 653–668

Per creare un DHM sottrarre il DEM dal DEM, questo può essere fatto in Esri Raster Calculator o GDAL_CALC . Questo metterà tutte le tue elevazioni su una "parità di condizioni".

Sintassi (sostituisci percorsi completi per DEM, DSM e DHM):

GDAL_CALC.py -A DSM -B DEM --outfile=DHM --CALC "A-B"

Il DHM sarà principalmente 0 (o abbastanza vicino), il che rendi il tuo valore di nodata. Con Raster Calculator o GDAL_CALC è possibile estrarre valori più di un valore arbitrario in base alla quantità di rumore osservata nel DHM. Lo scopo è ridurre il rumore ed evidenziare solo le corone della vegetazione - nel caso in cui due "alberi" siano adiacenti, questo dovrebbe essere diviso in due chiazze distinte.

Sintassi (sostituisci percorsi completi per binario e DHM e valore osservato per valore):

GDAL_CALC.py -A DHM --outfile=Binary --calc "A*(A>Value)"

Ora con GDAL_CALC o Esri IsNull creare un raster binario, che può essere poligonizzato con GDAL_Polygonize o Esri Raster in poligono .

Per perfezionare i poligoni rimuovere poligoni eccessivamente piccoli e quindi confrontarli con le bande RGB in cerca di firme, in Esri lo strumento Zonal Statistics aiuterà. Quindi puoi scartare i poligoni che chiaramente non hanno le statistiche giuste (in base alla sperimentazione e ai tuoi dati, non posso darti i valori).

Ciò dovrebbe garantire una precisione dell'80% circa nella stampa di singole corone.

eCognition è il miglior software per questo, l'ho fatto usando altri software ma eCognition è meglio. Ecco il riferimento alla letteratura sull'argomento:

Karlson, M., Reese, H., & Ostwald, M. (2014). Mappatura delle corone degli alberi nei boschi gestiti (parchi) dell'Africa occidentale semi-arida usando le immagini WorldView-2 e l'analisi delle immagini basata su oggetti geografici. Sensori, 14 (12), 22643-22669.

ad es. http://www.mdpi.com/1424-8220/14/12/22643

Inoltre:

Zagalikis, G., Cameron, AD e Miller, DR (2005). L'applicazione della fotogrammetria digitale e delle tecniche di analisi delle immagini per derivare le caratteristiche dell'albero e degli stand. Rivista canadese di ricerca forestale, 35 (5), 1224-1237.

ad es. http://www.nrcresearchpress.com/doi/abs/10.1139/x05-030#.VJmMb14gAA

Ho avuto lo stesso problema un paio d'anni fa. Ho una soluzione che non richiede dati LAS filtrati o altri dati accessori. Se hai accesso ai dati LiDAR e puoi generare DEM / DSM / DHM (di seguito DEM, non sto discutendo la semantica della nomenclatura del modello di superficie) da diversi ritorni, il seguente script può essere utile.

Lo script arcpy ingerisce 3 DEM e sputa un poligono della foresta e gli shapefile dei punti degli alberi. I 3 DEM dovrebbero avere la stessa risoluzione spaziale (ovvero 1 metro) ed estensioni e rappresentare i primi ritorni, gli ultimi ritorni e la terra nuda. Avevo parametri molto specifici per l'estrazione di verdure, ma i parametri possono essere modificati per soddisfare altre esigenze. Sono sicuro che il processo può essere migliorato, poiché questo è stato il mio primo serio tentativo di scripting Python.

# Name:         Veg_Extractor.py
# Date:         2013-07-16
# Usage:        ArcMap 10.0; Spatial Analyst
# Input:        1 meter DEMs for first returns (DEM1), last returns (DEM2), and bare earth (BE)
# Output:       forest polygon (veg with height > 4m) shapefile with holes > 500m removed;
#               tree point (veg with height > 4m, crown radius of 9 cells) shapefile
# Notes:        Raises error if input raster cell sizes differ

import arcpy, os
from arcpy import env
from arcpy.sa import *

# Check out any necessary licenses
arcpy.CheckOutExtension("spatial")

# Script arguments
dem1 = arcpy.GetParameterAsText(0) #input Raster Layer, First Return DEM
dem2 = arcpy.GetParameterAsText(1) #input Raster Layer, Last Return DEM
bare_earth = arcpy.GetParameterAsText(2) #input Raster Layer, Bare Earth DEM
outForest = arcpy.GetParameterAsText(3) #shapefile
outTree = arcpy.GetParameterAsText(4) #shapefile

# Make sure cell size of input rasters are same
arcpy.AddMessage("Checking cell sizes...")
dem1Xresult = arcpy.GetRasterProperties_management(dem1, "CELLSIZEX")
dem1Yresult = arcpy.GetRasterProperties_management(dem1, "CELLSIZEY")
dem2Xresult = arcpy.GetRasterProperties_management(dem2, "CELLSIZEX")
dem2Yresult = arcpy.GetRasterProperties_management(dem2, "CELLSIZEY")
beXresult = arcpy.GetRasterProperties_management(bare_earth, "CELLSIZEX")
beYresult = arcpy.GetRasterProperties_management(bare_earth, "CELLSIZEY")
dem1X = round(float(dem1Xresult.getOutput(0)),4)
dem1Y = round(float(dem1Yresult.getOutput(0)),4)
dem2X = round(float(dem2Xresult.getOutput(0)),4)
dem2Y = round(float(dem2Yresult.getOutput(0)),4)
beX = round(float(beXresult.getOutput(0)),4)
beY = round(float(beYresult.getOutput(0)),4)
if (dem1X == dem1Y == dem2X == dem2Y == beX == beY) == True:
    arcpy.AddMessage("Cell sizes match.")
else:
    arcpy.AddMessage("Input Raster Cell Sizes:")
    arcpy.AddMessage("DEM1: (" + str(dem1X) + "," + str(dem1Y) + ")")
    arcpy.AddMessage("DEM2: (" + str(dem2X) + "," + str(dem2Y) + ")")
    arcpy.AddMessage("  BE: (" + str(beX) + "," + str(beY) + ")")
    raise Exception("Cell sizes do not match.")

# Check map units
dem1_spatial_ref = arcpy.Describe(dem1).spatialReference
dem1_units = dem1_spatial_ref.linearUnitName
dem2_spatial_ref = arcpy.Describe(dem2).spatialReference
dem2_units = dem2_spatial_ref.linearUnitName
bare_earth_spatial_ref = arcpy.Describe(bare_earth).spatialReference
bare_earth_units = bare_earth_spatial_ref.linearUnitName
if (dem1_units == dem2_units == bare_earth_units) == True:
    if dem1_units == "Meter":
        area = "500 SquareMeters" #Area variable for meter
        unit = 1 #meter
    elif (dem1_units == "Foot_US") or (dem1_units == "Foot"):
        area = "5382 SquareFeet" #Area variable for feet
        unit = 3.28084 #feet in meter
    else:
        raise Exception("Units are not 'Meter', 'Foot_US', or 'Foot'.")
else:
    raise Exception("Linear units do not match.  Check spatial reference.")

# Local variables:
(workspace, filename) = os.path.split(outForest)
arcpy.env.workspace = workspace
arcpy.env.overwriteOutput = True
dem1 = Raster(dem1)
dem2 = Raster(dem2)
bare_earth = Raster(bare_earth)
nbr1 = NbrRectangle(3, 3, "CELL")
nbr2 = NbrRectangle(5, 5, "CELL")
nbr3 = NbrCircle(5, "CELL")

# Give units and multiplier
arcpy.AddMessage("Linear units are " + dem1_units + ". Using multiplier of " + str(unit) + "...")

arcpy.AddMessage("Processing DEMs...")
# Process: Raster Calculator (DEM1 - BE)
ndsm_dem1 = dem1 - bare_earth

# Process: Raster Calculator (DEM1 - DEM2)
d1_d2 = dem1 - dem2

# Process: Raster Calculator
threshold_d1d2 = (d1_d2 > (0.1 * unit))  &  (ndsm_dem1 >= (4.0 * unit))

# Process: Focal Statistics (max 3x3)
focal_max1 = FocalStatistics(threshold_d1d2, nbr1, "MAXIMUM", "DATA")

# Process: Focal Statistics (majority 5x5)
focal_majority = FocalStatistics(focal_max1, nbr2, "MAJORITY", "DATA")

# Process: Con
con_ndsm_dem1 = Con(ndsm_dem1 >= (4.0 * unit), focal_majority, focal_max1)
focal_majority = None
focal_max1 = None

# Process: Focal Statistics (min 3x3)
focal_min1 = FocalStatistics(con_ndsm_dem1, nbr1, "MINIMUM", "DATA")
con_ndsm_dem1 = None

# Process: Focal Statistics (min 3x3)
veg_mask = FocalStatistics(focal_min1, nbr1, "MINIMUM", "DATA")

# Process: Focal Statistics (max R5)
focal_max2 = FocalStatistics(ndsm_dem1, nbr3, "MAXIMUM", "DATA")

arcpy.AddMessage("Calculating tree points...")
# Process: Raster Calculator
tree_points = (veg_mask == 1) & (ndsm_dem1 == focal_max2) & (ndsm_dem1 >= (4.0 * unit))
ndsm_dem1 = None
focal_max2 = None

# Process: Raster Calculator
tree_pick = Pick(tree_points == 1, 1)
tree_points = None

# Process: Raster to Polygon
arcpy.RasterToPolygon_conversion(tree_pick, workspace + "\\tree_poly.shp", "SIMPLIFY", "Value")
tree_pick = None

# Process: Feature To Point
arcpy.AddMessage("Writing tree points...")
arcpy.env.workspace = workspace #reset workspace
arcpy.env.overwriteOutput = True #reset overwrite permission
arcpy.FeatureToPoint_management(workspace + "\\tree_poly.shp", outTree, "CENTROID")

arcpy.AddMessage("Calculating forest polygons...")
# Process: Focal Statistics (max 3x3)
forests = FocalStatistics(veg_mask, nbr1, "MAXIMUM", "DATA")
veg_mask = None

# Process: Raster Calculator
forest_pick = Pick(forests == 1, 1)

# Process: Raster to Polygon
arcpy.RasterToPolygon_conversion(forest_pick, workspace + "\\forest_poly.shp", "SIMPLIFY", "Value")

# Process: Eliminate Holes > 500 sq m (5382 sq ft)
arcpy.AddMessage("Writing forest polygons...")
arcpy.EliminatePolygonPart_management(workspace + "\\forest_poly.shp", outForest, "AREA", area, "0", "CONTAINED_ONLY")

# Clean up
arcpy.AddMessage("Cleaing up...")
arcpy.Delete_management(workspace + "\\tree_poly.shp")
arcpy.Delete_management(workspace + "\\forest_poly.shp")

Sto pubblicando questo come risposta a causa del limite di lunghezza nel commento, nessuna speranza per i crediti :). Pennello molto ampio, a condizione che tu abbia DEM.

1. Estrai DEM per singolo poligono in dem.
2. Definisci gli estremi di elevazione del dem
3. Imposta zCur + = - zStep. Passaggio da ricercare preventivamente nelle iterazioni, ad es. Calo ragionevole tra l'elevazione della "cella superiore dell'albero" e i vicini
4. Below = Con (dem => zCur, int (1))
5. Raggruppa le regioni di sotto. Conta abbastanza grande, cioè "alberi". Definizione richiesta qui da ispezione visiva, ricerca preliminare?
6. Andare al passaggio 3 se zCur> zMin, passaggio 1 altrimenti.

Numero massimo di gruppi nel processo = conteggio degli alberi all'interno del singolo poligono. Criteri aggiuntivi, ad esempio la distanza tra 'alberi' all'interno di poligoni, potrebbero aiutare ... Il livellamento DEM usando anche il kernel è un'opzione.