Urban tree catalogs

Format: geo-referenced list of trees

Urban tree catalogs

Pros

• Often comes with valuable attributes (e.g., dimensions, species, age…)

Urban tree catalogs

Cons

• Costly: manual surveys
• Often restricted to public space

Canopy height models

Format: raster of tree height values

Canopy height models

Pros

• Can be automatically derived from raw LIDAR data, i.e., classified cloud of points

Canopy height models

Cons

• LIDAR data is expensive
• Building canopy height models requires raw LIDAR data (surface and terrain models are not enough)
• Few open raw LIDAR datasets

Idea in a nutshell

• Input: high resolution aerial imagery
• Output: binary raster of tree/non-tree pixels

Idea in a nutshell

Idea in a nutshell

Supervised learning

The training set S = {(x_i, y_i), i = {1, …, M}} is a sample of M pixels, each represented by a:

• 27-component feature vector: x_i ∈ ℝ²⁷, with information of color, texture and entropy
• binary response: y_i ∈ {0, 1}, with y_i = 1 if pixel i actually corresponds to a tree, y_i = 0 otherwise

The idea is NOT mine

• Approach proposed by Yang et al. [1] in 2009
• Others have implemented as well: Mapping All of the Trees with Machine Learning

However

To my knowledge, DetecTree is the first open source tool to perform such a task

Step 0: Split image into tiles

Input: aerial imagery raster for the area of interest

• The dataset might already come as a mosaic of tiles
• Otherwise, you might use DetecTree’s split_into_tiles function

Step 1: Train/test split

We might use random sampling to select, e.g., 1% of the tiles as training data, however …

… the training tiles should be as representative as possible of the overall dataset

Step 1: Train/test split

How do we optimize the representativity of the training set?

1. For each tile, compute a GIST descriptor [2], i.e., a vector describing key semantics of the tile’s scene
2. Apply k-means to the GIST descriptors to get k clusters of tiles, with k= size of the training set
3. For each cluster, select the tile that is closest to the cluster’s centroid for training

Step 1: Train/test split

split_df = dtr.TrainingSelector(
    img_dir='path/to/tiles').train_test_split(
        method='cluster-I')
split_df.head()

Step 1: Train/test split

split_df[split_df['train']]

Step 3: Get the training ground-truth tree/non-tree mask

• For each tile of the training set, we need to provide the ground-truth tree/non-tree masks to get the pixel-level responses  y_i , ∀i ∈ {1, …, M}
• We might use GIMP, Adobe Photoshop or LIDAR data (see the detectree-example repository)

Step 4: Train a binary pixel-level classifier

Step 4: Train a binary pixel-level classifier

clf = dtr.ClassifierTrainer().train_classifier(
    split_df=split_df, response_img_dir=response_dir)

• response_dir is where the response tiles are located
• clf is the training classifier, i.e., scikit-learn’s AdaBoostClassifier

Step 5: Pixel-level classification

Given the trained classifier clf, we might use the classify_img method as follows:

y = dtr.Classifier().classify_img(
    'path/to/some/tile.tif', clf)

Step 5: Pixel-level classification

Which will give us something like:

Step 5: Pixel-level classification

• Note: the pixel-level classification predicts each pixel independently, which might yield noisy results, e.g., sparse points on grass fields labeled as trees
• Following the approach of Yang et al. [1], DetecTree refines the pixel-level classification to ensure consistency between adjacent pixels using the graph cuts algorithm of Boykov and Kolmogorov [3].

Step 5: Pixel-level classification

Original tile (left), pixel-level classification (middle), refined classification (right)

Step 5: Pixel-level classification

We can use the classify_imgs method directly on the train/test split dataframe split_df to classify all the tiles at scale with Dask:

dtr.Classifier().classify_imgs(
    split_df, 'path/to/output/dir, clf=clf)

Pros of DetecTree

• Many available datasets of HRO, e.g., NAIP open dataset: Continental USA at the 0.6 to 1m resolution
• Modest memory requirements compared to LIDAR, e.g., Geneva:
• LIDAR (25 pt/m²): 310 GB
• SWISSIMAGE (1m): 1 GB

Cons of DetecTree

• Only provides binary pixel-level classification
• If tree species/dimensions are important, DetecTree is not the best

Scope of DetecTree

• When we are only interested in 2D aspects of trees, e.g., proportion of land cover/spatial distribution
• LIDAR is not available
• LIDAR is available but it is too expensive
• LIDAR is available but you don’t want to process 300GB of data

Objective

Given a land cover map (10m), predict the spatial distribution of air temperature

Approach: InVEST Urban cooling model

• For each pixel:

   T_air ∼ f ( ET , shade , albedo )

• However: pixels of the same land cover, e.g., road, can have very different levels of tree cover (which influences the ET, shade, albedo…)

Enter DetecTree

• Refine each land cover class into subclasses depending on the level of tree cover
• For example, pixels of “road” land cover are further divided into
• “road with high tree cover”
• “road with intermediate tree cover”
• “road with low tree cover”

Enter DetecTree

We go from 25 to 100 land use classes …

Results of the study coming soon