H3 Use Cases

1
# Step 1: Index all riders and drivers at resolution 7 (~1km hexagons)
2
rider_cells = {}
3
for rider in active_riders:
4
    h3_index = h3.geo_to_h3(rider.lat, rider.lng, 7)
5
    rider_cells[h3_index] = rider_cells.get(h3_index, 0) + 1
6

7
driver_cells = {}
8
for driver in available_drivers:
9
    h3_index = h3.geo_to_h3(driver.lat, driver.lng, 7)
10
    driver_cells[h3_index] = driver_cells.get(h3_index, 0) + 1
11

12
# Step 2: Calculate demand score for each cell
13
surge_zones = {}
14
all_cells = set(rider_cells.keys()) | set(driver_cells.keys())
15

16
for cell in all_cells:
17
    riders = rider_cells.get(cell, 0)
18
    drivers = driver_cells.get(cell, 0)
19

20
    if drivers == 0:
21
        surge_zones[cell] = MAX_SURGE  # No supply!
22
    else:
23
        demand_ratio = riders / drivers
24
        surge_zones[cell] = calculate_multiplier(demand_ratio)
25

26
# Step 3: Smooth boundaries using k-ring neighbors
27
smoothed_surge = {}
28
for cell, multiplier in surge_zones.items():
29
    neighbors = h3.k_ring(cell, 1)  # cell + 6 neighbors
30
    avg_surge = sum(surge_zones.get(n, 1.0) for n in neighbors) / len(neighbors)
31
    smoothed_surge[cell] = avg_surge

1
# Offline: Precompute delivery zones for each restaurant
2
def index_restaurant_coverage(restaurant):
3
    # Define delivery zone (e.g., 3km radius circle)
4
    delivery_circle = create_circle(restaurant.lat, restaurant.lng, 3000)
5

6
    # Convert to H3 hexagons at resolution 9 (~0.1km² cells)
7
    delivery_hexagons = h3.polyfill(delivery_circle, 9)
8

9
    # Store in database
10
    db.execute("""
11
        INSERT INTO restaurant_coverage (restaurant_id, h3_index)
12
        VALUES (%s, %s)
13
    """, [(restaurant.id, hex) for hex in delivery_hexagons])
14

15
# Online: Fast restaurant filtering
16
def find_available_restaurants(customer_lat, customer_lng):
17
    # Convert customer location to H3
18
    customer_h3 = h3.geo_to_h3(customer_lat, customer_lng, 9)
19

20
    # Fast database query
21
    restaurants = db.execute("""
22
        SELECT DISTINCT restaurant_id, name, cuisine
23
        FROM restaurant_coverage
24
        WHERE h3_index = %s
25
    """, [customer_h3])
26

27
    return restaurants

1
# Privacy-preserving case aggregation
2
def aggregate_cases(case_locations):
3
    # Convert exact locations to H3 resolution 7 (~5km² cells)
4
    case_counts = {}
5
    for case in case_locations:
6
        h3_index = h3.geo_to_h3(case.lat, case.lng, 7)
7
        case_counts[h3_index] = case_counts.get(h3_index, 0) + 1
8

9
    # Only publish cells with minimum threshold (prevent re-identification)
10
    MIN_CASES = 5
11
    public_counts = {cell: count for cell, count in case_counts.items()
12
                     if count >= MIN_CASES}
13

14
    return public_counts
15

16
# Hotspot identification
17
def find_hotspots(case_counts, threshold=20):
18
    hotspots = []
19
    for cell, count in case_counts.items():
20
        if count > threshold:
21
            # Drill down to finer resolution for targeted response
22
            children = h3.h3_to_children(cell, 9)
23
            hotspots.append({
24
                'region': cell,
25
                'detail_cells': children,
26
                'case_count': count
27
            })
28
    return hotspots
29

30
# Identify at-risk neighboring areas
31
def find_at_risk_areas(hotspot_cells):
32
    at_risk = set()
33
    for cell in hotspot_cells:
34
        # Add 1-ring and 2-ring neighbors
35
        at_risk.update(h3.k_ring(cell, 2))
36
    return at_risk - set(hotspot_cells)  # Exclude hotspots themselves

1
# Model each store's market area
2
def create_market_model(store_location, sales_data):
3
    # Customer locations from sales data
4
    customer_hexagons = {}
5
    for sale in sales_data:
6
        h3_index = h3.geo_to_h3(sale.customer_lat, sale.customer_lng, 8)
7
        customer_hexagons[h3_index] = customer_hexagons.get(h3_index, 0) + sale.revenue
8

9
    return customer_hexagons
10

11
# Analyze cannibalization for proposed new store
12
def analyze_cannibalization(proposed_location, existing_stores):
13
    # Proposed store's potential market (3km radius)
14
    proposed_area = create_circle_polygon(proposed_location, 3000)
15
    proposed_hexagons = set(h3.polyfill(proposed_area, 8))
16

17
    cannibalization = {}
18
    for store in existing_stores:
19
        # Existing store's market area
20
        existing_market = create_market_model(store.location, store.sales_history)
21
        existing_hexagons = set(existing_market.keys())
22

23
        # Calculate overlap
24
        overlap = proposed_hexagons & existing_hexagons
25
        overlap_revenue = sum(existing_market[h] for h in overlap)
26

27
        cannibalization[store.id] = {
28
            'overlap_cells': len(overlap),
29
            'at_risk_revenue': overlap_revenue,
30
            'percentage': overlap_revenue / store.total_revenue * 100
31
        }
32

33
    return cannibalization
34

35
# Optimize new store location
36
def find_optimal_location(candidates, existing_stores):
37
    best_location = None
38
    min_cannibalization = float('inf')
39

40
    for candidate in candidates:
41
        cannib = analyze_cannibalization(candidate, existing_stores)
42
        total_cannib = sum(c['at_risk_revenue'] for c in cannib.values())
43

44
        if total_cannib < min_cannibalization:
45
            min_cannibalization = total_cannib
46
            best_location = candidate
47

48
    return best_location, min_cannibalization

1
SELECT * FROM drivers
2
WHERE haversine_distance(lat, lng, 37.7749, -122.4194) < 2000;

1
import geohash
2

3
# Encode location
4
gh = geohash.encode(37.7749, -122.4194, precision=7)
5
# Returns: '9q8yyzr'
6

7
# Nearby points have similar prefixes
8
nearby_gh = geohash.encode(37.7750, -122.4195, precision=7)
9
# Returns: '9q8yyzr' (same!)

1
-- Create spatial index
2
CREATE INDEX idx_locations_geom ON locations USING GIST (geom);
3

4
-- Spatial query
5
SELECT * FROM locations
6
WHERE ST_DWithin(geom, ST_SetSRID(ST_MakePoint(-122.4194, 37.7749), 4326), 2000);