Chapter 8: The SLEUTH Urban Growth Model

8.1 What is SLEUTH?

SLEUTH is the most widely used CA-based urban growth model, developed by Keith Clarke at UC Santa Barbara. The name is an acronym for its input data layers:

• Slope
• Land use
• Exclusion (protected areas, water bodies)
• Urban extent (historical urban maps)
• Transportation (road network)
• Hillshade (for visualisation)

SLEUTH simulates urban growth through five distinct growth rules, each controlled by a coefficient in the range $[0, 100]$. The model is calibrated by brute-force Monte Carlo search over the five-dimensional parameter space.

8.2 The Five Growth Rules

Rule 1: Spontaneous Growth

Random urbanisation of any non-excluded, non-urban cell. Models new development seeds unrelated to existing urban areas. Controlled by the dispersion coefficient$C_d$:

$$P_{\text{spont}}(i,j) = \frac{C_d}{100} \cdot \left(1 - \frac{\text{slope}(i,j)}{\text{slope}_{\max}}\right)^{C_s}$$

where $C_s$ is the slope resistance coefficient.

Rule 2: New Spreading Centre Growth

When two or more spontaneous growth cells occur near each other, they form a new urban cluster (“spreading centre”). Controlled by the breed coefficient$C_b$:

$$\text{If } |\{k \in \mathcal{N}_3(i,j) : s_k^{\text{new}} = 1\}| \geq 2 \text{ and } \text{rand} < C_b/100 \text{, spawn new centre}$$

Rule 3: Edge Growth (Organic Growth)

Existing urban edges expand outward. For each urban cell at the boundary, neighbouring non-urban cells may become developed. Controlled by the spread coefficient$C_p$:

$$P_{\text{edge}}(i,j) = \frac{C_p}{100} \cdot \frac{n_{\text{urban}}(i,j)}{|\mathcal{N}|} \cdot \left(1 - \frac{\text{slope}(i,j)}{\text{slope}_{\max}}\right)^{C_s}$$

Rule 4: Road-Influenced Growth

New development is attracted to transportation corridors. When a new urban cell forms, it may “walk” toward the nearest road and develop along it. Controlled by road gravity $C_g$:

$$d_{\text{walk}} = C_g / 100 \cdot d_{\max}, \qquad \text{develop along road within } d_{\text{walk}} \text{ cells}$$

Rule 5: Slope Resistance

All rules are modulated by slope. Steep terrain resists urbanisation:

$$R_{\text{slope}}(i,j) = \left(1 - \frac{\text{slope}(i,j)}{\text{slope}_{\max}}\right)^{C_s / 100 \cdot \text{MAX\_SLOPE\_RESISTANCE}}$$

8.3 Calibration: Brute-Force Monte Carlo

SLEUTH is calibrated by searching over the five-dimensional parameter space$(C_d, C_b, C_p, C_g, C_s) \in [0, 100]^5$. For each parameter combination, the model is run multiple times (Monte Carlo replicates) and the output is compared to historical data.

Figure of Merit: Jaccard Index

The primary calibration metric is the Figure of Merit (FoM), based on the Jaccard index between the simulated urban extent$A$ and the observed extent$B$:

$$\text{FoM} = J(A, B) = \frac{|A \cap B|}{|A \cup B|} = \frac{|A \cap B|}{|A| + |B| - |A \cap B|}$$

Properties:

• $\text{FoM} = 1$: perfect agreement
• $\text{FoM} = 0$: no overlap
• Penalises both omission errors (observed but not simulated) and commission errors (simulated but not observed)

Three-Phase Calibration

SLEUTH uses a hierarchical calibration strategy:

Coarse: step = 25, range [0, 100] (5 values per parameter = 3125 combinations)
Fine: step = 5, range around best coarse values
Final: step = 1, range around best fine values

8.4 Self-Modification Rules

A distinctive feature of SLEUTH is that its coefficients evolve during the simulation via self-modification rules. If growth is too fast or too slow compared to a target, the coefficients are adjusted:

$$\text{If growth rate} > \text{critical}_{\text{high}}: \quad C_d \leftarrow C_d \cdot \text{boom}, \quad C_b \leftarrow C_b \cdot \text{boom}$$

$$\text{If growth rate} < \text{critical}_{\text{low}}: \quad C_d \leftarrow C_d \cdot \text{bust}, \quad C_b \leftarrow C_b \cdot \text{bust}$$

where $\text{boom} > 1$ and$\text{bust} < 1$ are multipliers. This creates boom-bust cycles that mimic real urban growth dynamics.

8.5 Python: SLEUTH Growth Rules & Calibration

Implementation of the five SLEUTH growth rules with a simplified calibration loop.

SLEUTH: Growth Rules & Calibration Loop

Python

script.py152 lines

import numpy as np

np.random.seed(99)

# ── SLEUTH Growth Model (simplified) ──
N = 50  # grid size
n_years = 20

# Input layers
slope = np.random.uniform(0, 30, (N, N))  # degrees
slope_max = 40.0
exclusion = np.zeros((N, N))  # 1 = excluded
exclusion[:3, :] = 1  # water body at top
road = np.zeros((N, N))
road[N//2, :] = 1  # horizontal road
road[:, N//2] = 1  # vertical road (crossroads)

# Initial urban extent
urban = np.zeros((N, N), dtype=int)
center = N // 2
urban[center-2:center+3, center-2:center+3] = 1

# Observed final urban (for calibration comparison)
# Simulate a "truth" with known parameters
np.random.seed(77)
urban_truth = urban.copy()
for _ in range(n_years):
    u_new = urban_truth.copy()
    for i in range(1, N-1):
        for j in range(1, N-1):
            if urban_truth[i,j] == 1 or exclusion[i,j] == 1:
                continue
            n_urb = sum(urban_truth[i+di, j+dj] for di in [-1,0,1] for dj in [-1,0,1] if (di,dj)!=(0,0) and 0<=i+di<N and 0<=j+dj<N)
            if n_urb > 0 and np.random.random() < 0.15 * n_urb/8:
                u_new[i,j] = 1
    urban_truth = u_new
np.random.seed(99)

def slope_resist(i, j, Cs):
    return max(0, (1 - slope[i,j] / slope_max)) ** (Cs / 50.0)

def sleuth_step(urban, Cd, Cb, Cp, Cg, Cs):
    u_new = urban.copy()
    new_spont = []

# Rule 1: Spontaneous growth
    n_spont = max(1, int(Cd / 100.0 * 10))
    for _ in range(n_spont):
        ri, rj = np.random.randint(0, N), np.random.randint(0, N)
        if urban[ri, rj] == 0 and exclusion[ri, rj] == 0:
            if np.random.random() < slope_resist(ri, rj, Cs):
                u_new[ri, rj] = 1
                new_spont.append((ri, rj))

# Rule 2: New spreading centre (breed from spontaneous clusters)
    for (si, sj) in new_spont:
        nearby = sum(1 for di in [-1,0,1] for dj in [-1,0,1]
                     if (di,dj)!=(0,0) and 0<=si+di<N and 0<=sj+dj<N
                     and u_new[si+di, sj+dj] == 1)
        if nearby >= 2 and np.random.random() < Cb / 100.0:
            for di in [-1,0,1]:
                for dj in [-1,0,1]:
                    ni, nj = si+di, sj+dj
                    if 0<=ni<N and 0<=nj<N and u_new[ni,nj]==0 and exclusion[ni,nj]==0:
                        if np.random.random() < 0.3 * slope_resist(ni, nj, Cs):
                            u_new[ni, nj] = 1

# Rule 3: Edge growth
    for i in range(1, N-1):
        for j in range(1, N-1):
            if u_new[i,j] == 1 or exclusion[i,j] == 1:
                continue
            n_urb = sum(u_new[i+di, j+dj] for di in [-1,0,1] for dj in [-1,0,1]
                        if (di,dj)!=(0,0))
            if n_urb >= 1:
                p_edge = (Cp / 100.0) * (n_urb / 8.0) * slope_resist(i, j, Cs)
                if np.random.random() < p_edge:
                    u_new[i, j] = 1

# Rule 4: Road-influenced growth
    walk_dist = int(Cg / 100.0 * 5) + 1
    for i in range(N):
        for j in range(N):
            if u_new[i,j] == 1 and road[i,j] == 0:
                # Check for nearby road
                for d in range(1, walk_dist+1):
                    for di, dj in [(-d,0),(d,0),(0,-d),(0,d)]:
                        ni, nj = i+di, j+dj
                        if 0<=ni<N and 0<=nj<N and road[ni,nj] == 1 and u_new[ni,nj] == 0:
                            if exclusion[ni,nj] == 0 and np.random.random() < 0.2:
                                u_new[ni, nj] = 1

return u_new

def jaccard(A, B):
    intersection = np.sum((A == 1) & (B == 1))
    union = np.sum((A == 1) | (B == 1))
    return intersection / union if union > 0 else 0.0

# ── Calibration loop (coarse search) ──
print("=" * 68)
print("  SLEUTH Calibration: Brute-Force Parameter Search")
print("=" * 68)
print()

best_fom = 0
best_params = None
param_values = [10, 40, 70]  # coarse grid (3 values per param)
n_combos = len(param_values)**5
tested = 0

print(f"  Testing {n_combos} parameter combinations...")
print(f"  {'Cd':>5} {'Cb':>5} {'Cp':>5} {'Cg':>5} {'Cs':>5} {'FoM':>8}")
print("-" * 42)

for Cd in param_values:
    for Cb in param_values:
        for Cp in param_values:
            for Cg in param_values:
                for Cs in param_values:
                    tested += 1
                    # Run simulation
                    u = urban.copy()
                    for yr in range(n_years):
                        u = sleuth_step(u, Cd, Cb, Cp, Cg, Cs)
                    fom = jaccard(u, urban_truth)
                    if fom > best_fom:
                        best_fom = fom
                        best_params = (Cd, Cb, Cp, Cg, Cs)
                        print(f"  {Cd:5d} {Cb:5d} {Cp:5d} {Cg:5d} {Cs:5d} {fom:8.4f}  *NEW BEST*")

print()
print(f"  Best FoM (Jaccard): {best_fom:.4f}")
print(f"  Best parameters: Cd={best_params[0]}, Cb={best_params[1]}, "
      f"Cp={best_params[2]}, Cg={best_params[3]}, Cs={best_params[4]}")
print()

# Run best model and show FoM components
u_best = urban.copy()
for yr in range(n_years):
    u_best = sleuth_step(u_best, *best_params)

intersection = np.sum((u_best == 1) & (urban_truth == 1))
union = np.sum((u_best == 1) | (urban_truth == 1))
sim_only = np.sum((u_best == 1) & (urban_truth == 0))
obs_only = np.sum((u_best == 0) & (urban_truth == 1))

print(f"  |A intersect B| = {intersection}")
print(f"  |A union B|     = {union}")
print(f"  Commission err  = {sim_only} (simulated but not observed)")
print(f"  Omission err    = {obs_only} (observed but not simulated)")
print(f"  FoM = {intersection}/{union} = {best_fom:.4f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

8.6 Summary & Key Takeaways

• SLEUTH uses five growth rules: spontaneous, new spreading, edge, road-influenced, slope resistance
• Five coefficients $(C_d, C_b, C_p, C_g, C_s) \in [0, 100]$ control growth behaviour
• Calibration via brute-force Monte Carlo with three-phase refinement
• Figure of Merit = Jaccard index: $\text{FoM} = |A \cap B| / |A \cup B|$
• Self-modification rules create realistic boom-bust growth cycles
• Widely applied globally but computationally expensive to calibrate

← Stochastic CA Next: FLUS Model →