implement advanced roof plane segmentation

Major improvements for detecting individual roof planes:

- Multi-layer DINOv2 feature extraction (layers 6,12,18,24)
- Edge detection with Sobel + Canny for boundary awareness
- Three segmentation algorithms: SLIC, Watershed, Felzenszwalb
- Feature-based segment merging with similarity threshold
- Bicubic upsampling of features to image resolution
- Edge visualization output
- Configurable segmentation parameters in UI

Technical changes:
- Switch from DINOv3-SAT to DINOv2-Large (better compatibility)
- Added scikit-image and scipy dependencies
- Feature pyramid approach with 128-dim PCA
- Watershed uses distance transform from edges
- Tighter polygon simplification (0.008 vs 0.015 epsilon)
- New UI with algorithm selection and edge preview

This enables detection of individual roof facets, peaks, valleys,
and different planes on pitched roofs.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -5,6 +5,11 @@ from PIL import Image
 from transformers import AutoImageProcessor, AutoModel
 from sklearn.cluster import KMeans
 from sklearn.decomposition import PCA
+from skimage.segmentation import slic, felzenszwalb, watershed
+from skimage.feature import canny
+from skimage.morphology import dilation, erosion, square
+from skimage.filters import sobel
+from scipy import ndimage
 import cv2
 import json
 import requests
@@ -19,11 +24,11 @@ warnings.filterwarnings("ignore")
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
 
 # DINOv3 Model - Satellite pretrained
-MODEL_NAME = "facebook/dinov3-vitl16-pretrain-sat493m"
+MODEL_NAME = "facebook/dinov2-large"  # Using DINOv2 for better compatibility
 print(f"Loading {MODEL_NAME}...")
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 processor = AutoImageProcessor.from_pretrained(MODEL_NAME)
-model = AutoModel.from_pretrained(MODEL_NAME).to(device)
+model = AutoModel.from_pretrained(MODEL_NAME, output_hidden_states=True).to(device)
 model.eval()
 print(f"Model loaded on {device}")
 
@@ -35,22 +40,22 @@ def geocode_address(address, api_key):
         "address": address,
         "key": api_key
     }
-    
+
     response = requests.get(url, params=params)
     data = response.json()
-    
+
     if data["status"] != "OK":
         raise ValueError(f"Geocoding failed: {data['status']}")
-    
+
     location = data["results"][0]["geometry"]["location"]
     formatted_address = data["results"][0]["formatted_address"]
-    
+
     return location["lat"], location["lng"], formatted_address
 
 
 def fetch_geotiff(lat, lng, api_key, radius_meters=50):
     """Fetch RGB GeoTIFF from Google Solar API Data Layers."""
-    
+
     layers_url = "https://solar.googleapis.com/v1/dataLayers:get"
     params = {
         "location.latitude": lat,
@@ -61,32 +66,32 @@ def fetch_geotiff(lat, lng, api_key, radius_meters=50):
         "pixelSizeMeters": 0.25,
         "key": api_key
     }
-    
+
     response = requests.get(layers_url, params=params)
-    
+
     if response.status_code != 200:
         params["requiredQuality"] = "MEDIUM"
         response = requests.get(layers_url, params=params)
-    
+
     if response.status_code != 200:
         raise ValueError(f"Data Layers API error: {response.status_code} - {response.text}")
-    
+
     layers = response.json()
-    
+
     rgb_url = layers.get("rgbUrl")
     if not rgb_url:
         raise ValueError("No RGB imagery available for this location")
-    
+
     rgb_response = requests.get(f"{rgb_url}&key={api_key}")
     if rgb_response.status_code != 200:
         raise ValueError(f"Failed to download GeoTIFF: {rgb_response.status_code}")
-    
+
     return rgb_response.content, layers
 
 
 def parse_geotiff(geotiff_bytes):
     """Parse GeoTIFF and extract image + bounds."""
-    
+
     with rasterio.open(io.BytesIO(geotiff_bytes)) as src:
         if src.count >= 3:
             r = src.read(1)
@@ -96,70 +101,259 @@ def parse_geotiff(geotiff_bytes):
         else:
             img_array = src.read(1)
             img_array = np.stack([img_array] * 3, axis=-1)
-        
+
         bounds = src.bounds
         crs = src.crs
-        
+
         if crs and crs != CRS.from_epsg(4326):
             from rasterio.warp import transform_bounds
             bounds = transform_bounds(crs, CRS.from_epsg(4326), *bounds)
-    
+
     image = Image.fromarray(img_array.astype(np.uint8))
     return image, bounds
 
 
-def extract_features(image):
-    """Extract dense patch features from DINOv3."""
-    inputs = processor(images=image, return_tensors="pt").to(device)
-    
+def extract_multiscale_features(image, target_size=518):
+    """Extract multi-layer DINOv3 features for better roof plane detection."""
+    # Resize to higher resolution for better detail
+    original_size = image.size
+    image_resized = image.resize((target_size, target_size), Image.Resampling.BICUBIC)
+
+    inputs = processor(images=image_resized, return_tensors="pt").to(device)
+
     with torch.inference_mode():
         outputs = model(**inputs)
-        # DINOv3: skip CLS + 4 register tokens
-        patch_features = outputs.last_hidden_state[:, 5:, :]
-    
-    return patch_features
+
+        # Extract features from multiple layers (early + late)
+        # DINOv2-large has 24 layers
+        hidden_states = outputs.hidden_states
+
+        # Use layers at different depths for multi-scale features
+        layer_indices = [6, 12, 18, 24]  # Early, mid, mid-late, final
+        features_list = []
+
+        for idx in layer_indices:
+            if idx <= len(hidden_states):
+                # Skip CLS token (first token)
+                layer_features = hidden_states[idx - 1][:, 1:, :]
+                features_list.append(layer_features)
+
+        # Concatenate multi-scale features
+        combined_features = torch.cat(features_list, dim=-1)
+
+    return combined_features, image_resized
+
+
+def detect_edges(image_array):
+    """Detect edges using multiple methods for robust boundary detection."""
+    # Convert to grayscale
+    gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+
+    # Sobel edge detection
+    sobel_edges = sobel(gray)
+
+    # Canny edge detection
+    canny_edges = canny(gray, sigma=1.5)
+
+    # Combine edges
+    combined_edges = (sobel_edges > 0.1) | canny_edges
+
+    # Dilate edges slightly to ensure they separate regions
+    combined_edges = dilation(combined_edges, square(2))
+
+    return combined_edges.astype(np.uint8)
+
+
+def segment_roof_planes(image, method="slic", n_segments=100, edge_weight=10.0):
+    """
+    Advanced segmentation to detect individual roof planes.
+
+    Args:
+        image: PIL Image
+        method: 'slic', 'felzenszwalb', or 'watershed'
+        n_segments: number of initial superpixels
+        edge_weight: importance of edges in segmentation
+    """
+    img_array = np.array(image)
+    original_size = image.size
+
+    # Extract multi-scale DINOv3 features
+    features, resized_image = extract_multiscale_features(image, target_size=518)
+
+    num_patches = features.shape[1]
+    h = w = int(np.sqrt(num_patches))
+
+    feat_np = features.squeeze(0).cpu().numpy()
+
+    # Reduce dimensionality but keep more components for detail
+    n_components = min(128, feat_np.shape[1] - 1)
+    pca = PCA(n_components=n_components, random_state=42)
+    feat_reduced = pca.fit_transform(feat_np)
+
+    # Reshape to spatial grid
+    feat_spatial = feat_reduced.reshape(h, w, -1)
+
+    # Upsample features to image resolution using bicubic interpolation
+    feat_upsampled = np.zeros((original_size[1], original_size[0], n_components))
+    for i in range(n_components):
+        feat_upsampled[:, :, i] = cv2.resize(
+            feat_spatial[:, :, i],
+            (original_size[0], original_size[1]),
+            interpolation=cv2.INTER_CUBIC
+        )
+
+    # Detect edges
+    edges = detect_edges(img_array)
+
+    # Create edge-weighted feature representation
+    # This makes the segmentation respect edge boundaries
+    edge_mask = edges > 0
+
+    if method == "slic":
+        # SLIC superpixels - good for uniform regions
+        segments = slic(
+            img_array,
+            n_segments=n_segments,
+            compactness=10.0,
+            sigma=1,
+            start_label=0,
+            channel_axis=-1
+        )
+
+    elif method == "felzenszwalb":
+        # Felzenszwalb - good for preserving boundaries
+        segments = felzenszwalb(
+            img_array,
+            scale=100,
+            sigma=0.5,
+            min_size=50
+        )
+
+    elif method == "watershed":
+        # Watershed from edges - best for roof planes with clear ridges
+        # Use distance transform from edges
+        distance = ndimage.distance_transform_edt(~edge_mask)
+
+        # Find local maxima as markers
+        from skimage.feature import peak_local_max
+        local_max = peak_local_max(
+            distance,
+            min_distance=20,
+            labels=~edge_mask
+        )
+        markers = np.zeros_like(distance, dtype=int)
+        markers[tuple(local_max.T)] = np.arange(1, len(local_max) + 1)
+
+        # Watershed segmentation
+        segments = watershed(-distance, markers, mask=~edge_mask)
+
+    else:
+        # Fallback to SLIC
+        segments = slic(img_array, n_segments=n_segments, compactness=10.0)
+
+    # Refine segments using features
+    # Merge similar adjacent segments based on DINOv3 features
+    segments_refined = refine_segments_with_features(
+        segments, feat_upsampled, similarity_threshold=0.85
+    )
+
+    return segments_refined, img_array, edges
+
+
+def refine_segments_with_features(segments, features, similarity_threshold=0.85):
+    """Merge similar adjacent segments based on feature similarity."""
+    from scipy.ndimage import generic_filter
+
+    unique_segments = np.unique(segments)
+
+    # Compute mean feature vector for each segment
+    segment_features = {}
+    for seg_id in unique_segments:
+        mask = segments == seg_id
+        if mask.sum() > 0:
+            mean_feat = features[mask].mean(axis=0)
+            # Normalize
+            mean_feat = mean_feat / (np.linalg.norm(mean_feat) + 1e-8)
+            segment_features[seg_id] = mean_feat
+
+    # Build adjacency and merge similar segments
+    merged_segments = segments.copy()
+    merge_map = {i: i for i in unique_segments}
+
+    # Find adjacent segments
+    from scipy.ndimage import find_objects
+    for seg_id in unique_segments:
+        if seg_id == 0:
+            continue
+
+        mask = segments == seg_id
+        dilated = dilation(mask, square(3))
+        neighbors = np.unique(segments[dilated & ~mask])
+
+        for neighbor_id in neighbors:
+            if neighbor_id == 0 or neighbor_id == seg_id:
+                continue
+
+            # Compare feature similarity
+            feat_a = segment_features.get(seg_id)
+            feat_b = segment_features.get(neighbor_id)
+
+            if feat_a is not None and feat_b is not None:
+                similarity = np.dot(feat_a, feat_b)
+
+                if similarity > similarity_threshold:
+                    # Merge segments
+                    merged_segments[merged_segments == neighbor_id] = seg_id
+
+    # Relabel sequentially
+    unique_merged = np.unique(merged_segments)
+    for new_id, old_id in enumerate(unique_merged):
+        merged_segments[merged_segments == old_id] = new_id
+
+    return merged_segments
 
 
 def pixel_to_geo(x, y, img_width, img_height, bounds):
     """Convert pixel coordinates to geographic coordinates."""
     west, south, east, north = bounds
-    
+
     x_norm = x / img_width
     y_norm = y / img_height
-    
+
     lng = west + (east - west) * x_norm
     lat = north - (north - south) * y_norm
-    
+
     return [lng, lat]
 
 
-def mask_to_polygons(mask, bounds, img_width, img_height):
+def mask_to_polygons(mask, bounds, img_width, img_height, min_area_sqft=50):
     """Convert binary mask to GeoJSON polygons."""
     features = []
-    
+
     contours, _ = cv2.findContours(
-        mask.astype(np.uint8), 
+        mask.astype(np.uint8),
         cv2.RETR_EXTERNAL,
         cv2.CHAIN_APPROX_SIMPLE
     )
-    
+
     for i, contour in enumerate(contours):
         area = cv2.contourArea(contour)
         if area < 100:
             continue
-        
-        epsilon = 0.015 * cv2.arcLength(contour, True)
+
+        # Simplify with tighter epsilon for roof planes
+        epsilon = 0.008 * cv2.arcLength(contour, True)
         simplified = cv2.approxPolyDP(contour, epsilon, True)
-        
+
         coords = []
         for point in simplified:
             px, py = point[0]
             geo_coord = pixel_to_geo(px, py, img_width, img_height, bounds)
             coords.append(geo_coord)
-        
+
         if coords and coords[0] != coords[-1]:
             coords.append(coords[0])
-        
+
         if len(coords) >= 4:
             west, south, east, north = bounds
             meters_per_lng = 111320 * np.cos(np.radians((north + south) / 2))
@@ -167,66 +361,42 @@ def mask_to_polygons(mask, bounds, img_width, img_height):
             pixel_width_m = (east - west) * meters_per_lng / img_width
             pixel_height_m = (north - south) * meters_per_lat / img_height
             area_sqm = area * pixel_width_m * pixel_height_m
-            
-            feature = {
-                "type": "Feature",
-                "properties": {
-                    "roof_id": i + 1,
-                    "area_sqm": round(area_sqm, 2),
-                    "area_sqft": round(area_sqm * 10.764, 2),
-                    "num_vertices": len(coords) - 1
-                },
-                "geometry": {
-                    "type": "Polygon",
-                    "coordinates": [coords]
+            area_sqft = area_sqm * 10.764
+
+            if area_sqft >= min_area_sqft:
+                feature = {
+                    "type": "Feature",
+                    "properties": {
+                        "roof_plane_id": i + 1,
+                        "area_sqm": round(area_sqm, 2),
+                        "area_sqft": round(area_sqft, 2),
+                        "num_vertices": len(coords) - 1
+                    },
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": [coords]
+                    }
                 }
-            }
-            features.append(feature)
-    
+                features.append(feature)
+
     return features
 
 
-def segment_image(image, num_segments):
-    """Run DINOv3 segmentation on image."""
-    original_size = image.size
-    
-    features = extract_features(image)
-    
-    num_patches = features.shape[1]
-    h = w = int(np.sqrt(num_patches))
-    
-    feat_np = features.squeeze(0).cpu().numpy()
-    
-    pca = PCA(n_components=64, random_state=42)
-    feat_reduced = pca.fit_transform(feat_np)
-    
-    kmeans = KMeans(n_clusters=num_segments, random_state=42, n_init=10)
-    cluster_labels = kmeans.fit_predict(feat_reduced)
-    
-    seg_map = cluster_labels.reshape(h, w)
-    seg_resized = np.array(
-        Image.fromarray(seg_map.astype(np.uint8)).resize(
-            original_size, resample=Image.NEAREST
-        )
-    )
-    
-    return seg_resized
-
+def process_address(address, segmentation_method, n_segments, selected_clusters,
+                   min_area, radius_meters, api_key_input):
+    """Main pipeline: address -> roof plane GeoJSON polygons."""
 
-def process_address(address, num_segments, selected_clusters, min_area, radius_meters, api_key_input):
-    """Main pipeline: address -> GeoJSON polygons."""
-    
     api_key = api_key_input.strip() if api_key_input.strip() else GOOGLE_API_KEY
-    
+
     if not api_key:
-        return None, None, None, None, "❌ No API key provided. Enter your Google Solar API key."
-    
+        return None, None, None, None, None, "❌ No API key provided. Enter your Google Solar API key."
+
     try:
         lat, lng, formatted_address = geocode_address(address, api_key)
         status = f"📍 **{formatted_address}**\n\nCoordinates: {lat:.6f}, {lng:.6f}\n\n"
     except Exception as e:
-        return None, None, None, None, f"❌ Geocoding failed: {str(e)}"
-    
+        return None, None, None, None, None, f"❌ Geocoding failed: {str(e)}"
+
     try:
         status += "Fetching satellite imagery...\n"
         geotiff_bytes, layers_info = fetch_geotiff(lat, lng, api_key, radius_meters)
@@ -234,52 +404,66 @@ def process_address(address, num_segments, selected_clusters, min_area, radius_m
         img_width, img_height = image.size
         status += f"Image size: {img_width}x{img_height}px\n\n"
     except Exception as e:
-        return None, None, None, None, f"❌ Failed to fetch imagery: {str(e)}"
-    
+        return None, None, None, None, None, f"❌ Failed to fetch imagery: {str(e)}"
+
     try:
-        seg_resized = segment_image(image, num_segments)
-        
+        status += f"Running {segmentation_method.upper()} segmentation...\n"
+
+        seg_resized, img_array, edges = segment_roof_planes(
+            image,
+            method=segmentation_method,
+            n_segments=int(n_segments)
+        )
+
+        # Visualize segmentation
         colors = np.array([
             [230, 25, 75], [60, 180, 75], [255, 225, 25], [0, 130, 200],
             [245, 130, 48], [145, 30, 180], [70, 240, 240], [240, 50, 230],
-            [210, 245, 60], [250, 190, 212], [128, 128, 0], [0, 128, 128]
+            [210, 245, 60], [250, 190, 212], [128, 128, 0], [0, 128, 128],
+            [170, 110, 40], [128, 0, 0], [0, 0, 128], [255, 178, 102]
         ])
-        
+
         colored_seg = colors[seg_resized % len(colors)]
-        
+
+        # Parse selected roof plane clusters
         try:
             roof_indices = [int(x.strip()) for x in selected_clusters.split(",") if x.strip()]
         except:
             roof_indices = [0]
-        
+
         roof_mask = np.isin(seg_resized, roof_indices).astype(np.uint8) * 255
-        
-        kernel = np.ones((5, 5), np.uint8)
+
+        # Morphological refinement
+        kernel = np.ones((3, 3), np.uint8)
         roof_mask = cv2.morphologyEx(roof_mask, cv2.MORPH_CLOSE, kernel)
         roof_mask = cv2.morphologyEx(roof_mask, cv2.MORPH_OPEN, kernel)
-        
-        polygon_features = mask_to_polygons(roof_mask, bounds, img_width, img_height)
-        polygon_features = [f for f in polygon_features if f["properties"]["area_sqft"] >= min_area]
-        
+
+        polygon_features = mask_to_polygons(roof_mask, bounds, img_width, img_height, min_area)
+
         geojson = {
             "type": "FeatureCollection",
             "properties": {
-                "source": "DINOv3 Roof Segmentation",
+                "source": "DINOv2 Multi-Scale Roof Plane Segmentation",
                 "address": formatted_address,
                 "center": {"lat": lat, "lng": lng},
                 "bounds": {
                     "north": bounds[3], "south": bounds[1],
                     "east": bounds[2], "west": bounds[0]
-                }
+                },
+                "segmentation_method": segmentation_method
             },
             "features": polygon_features
         }
-        
+
         geojson_str = json.dumps(geojson, indent=2)
-        
+
+        # Create visualizations
         orig_array = np.array(image).astype(np.float32)
-        overlay = orig_array * 0.4 + colored_seg.astype(np.float32) * 0.6
-        
+
+        # Segmentation overlay
+        overlay = orig_array * 0.5 + colored_seg.astype(np.float32) * 0.5
+
+        # Draw polygon boundaries
         for feature in polygon_features:
             coords = feature["geometry"]["coordinates"][0]
             pixel_coords = []
@@ -287,57 +471,66 @@ def process_address(address, num_segments, selected_clusters, min_area, radius_m
                 px = int((lnglat[0] - bounds[0]) / (bounds[2] - bounds[0]) * img_width)
                 py = int((bounds[3] - lnglat[1]) / (bounds[3] - bounds[1]) * img_height)
                 pixel_coords.append([px, py])
-            
+
             pts = np.array(pixel_coords, dtype=np.int32)
-            cv2.polylines(overlay, [pts], True, (255, 255, 0), 3)
-        
+            cv2.polylines(overlay, [pts], True, (255, 255, 0), 2)
+
+        # Highlight selected roof planes
         for idx in roof_indices:
             mask_highlight = seg_resized == idx
-            overlay[mask_highlight] = orig_array[mask_highlight] * 0.3 + np.array([255, 50, 50]) * 0.7
-        
+            overlay[mask_highlight] = orig_array[mask_highlight] * 0.4 + np.array([255, 100, 100]) * 0.6
+
+        # Edge visualization
+        edge_viz = orig_array.copy()
+        edge_viz[edges > 0] = [255, 0, 0]  # Red edges
+
         total_sqft = sum(f["properties"]["area_sqft"] for f in polygon_features)
-        status += f"**Found {len(polygon_features)} roof polygon(s)**\n"
+        status += f"\n**Found {len(polygon_features)} roof plane polygon(s)**\n"
         status += f"**Total roof area: {total_sqft:,.0f} sq ft**\n\n"
-        
+
         for f in polygon_features:
             props = f["properties"]
-            status += f"- Roof {props['roof_id']}: {props['area_sqft']:,.0f} sq ft\n"
-        
-        status += "\n**Cluster Distribution:**\n"
+            status += f"- Plane {props['roof_plane_id']}: {props['area_sqft']:,.0f} sq ft ({props['num_vertices']} vertices)\n"
+
+        status += f"\n**Segmentation Stats:**\n"
+        status += f"- Method: {segmentation_method.upper()}\n"
+        status += f"- Total segments: {len(np.unique(seg_resized))}\n"
         unique, counts = np.unique(seg_resized, return_counts=True)
         total = seg_resized.size
-        for u, c in sorted(zip(unique, counts), key=lambda x: -x[1]):
+        status += f"\n**Top 10 Segments by Area:**\n"
+        for u, c in sorted(zip(unique, counts), key=lambda x: -x[1])[:10]:
             pct = (c / total) * 100
-            marker = " ← ROOF" if u in roof_indices else ""
-            status += f"- Cluster {u}: {pct:.1f}%{marker}\n"
-        
-        return np.array(image), overlay.astype(np.uint8), roof_mask, geojson_str, status
-        
+            marker = " ← ROOF PLANE" if u in roof_indices else ""
+            status += f"- Segment {u}: {pct:.1f}%{marker}\n"
+
+        return (np.array(image), overlay.astype(np.uint8), edge_viz.astype(np.uint8),
+                roof_mask, geojson_str, status)
+
     except Exception as e:
         import traceback
-        return None, None, None, None, f"❌ Segmentation failed: {str(e)}\n\n{traceback.format_exc()}"
+        return None, None, None, None, None, f"❌ Segmentation failed: {str(e)}\n\n{traceback.format_exc()}"
 
 
 def save_geojson(geojson_str):
     """Save GeoJSON for download."""
     if not geojson_str:
         return None
-    filepath = "/tmp/roof_polygons.geojson"
+    filepath = "/tmp/roof_planes.geojson"
     with open(filepath, "w") as f:
         f.write(geojson_str)
     return filepath
 
 
 # Gradio Interface
-with gr.Blocks(title="Roof Segmentation - Address to GeoJSON", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Roof Plane Segmentation - DINOv2", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🏠 Address → Roof Polygons (GeoJSON)
-    
-    Enter an address, get roof segment polygons with real-world coordinates.
-    
-    **Pipeline:** Address → Google Solar API (GeoTIFF) → DINOv3 Segmentation → GeoJSON
+    # 🏠 Advanced Roof Plane Segmentation
+
+    **Detects individual roof planes** (peaks, valleys, facets) using multi-scale DINOv2 features + edge-aware segmentation.
+
+    **Pipeline:** Address → Google Solar API → Multi-Layer DINOv2 → Edge Detection → Superpixel/Watershed → GeoJSON
     """)
-    
+
     with gr.Row():
         with gr.Column(scale=1):
             address_input = gr.Textbox(
@@ -345,74 +538,104 @@ with gr.Blocks(title="Roof Segmentation - Address to GeoJSON", theme=gr.themes.S
                 placeholder="123 Main St, Sacramento, CA",
                 lines=2
             )
-            
+
             with gr.Accordion("🔑 API Key", open=False):
                 api_key_input = gr.Textbox(
                     label="Google Solar API Key",
                     placeholder="Enter API key (or set GOOGLE_API_KEY secret)",
                     type="password"
                 )
-            
-            with gr.Accordion("⚙️ Settings", open=True):
+
+            with gr.Accordion("⚙️ Segmentation Settings", open=True):
+                segmentation_method = gr.Radio(
+                    choices=["slic", "watershed", "felzenszwalb"],
+                    value="watershed",
+                    label="Segmentation Algorithm",
+                    info="Watershed best for roof ridges/valleys"
+                )
+
+                n_segments = gr.Slider(
+                    50, 200, value=100, step=10,
+                    label="Initial Segments",
+                    info="Higher = finer detail (try 100-150 for roofs)"
+                )
+
                 radius_meters = gr.Slider(
                     25, 100, value=50, step=5,
                     label="Image Radius (meters)",
                     info="Area around the address to capture"
                 )
-                num_segments = gr.Slider(3, 12, value=6, step=1, label="Segments")
+
                 selected_clusters = gr.Textbox(
-                    value="0", 
-                    label="Roof Cluster(s)",
-                    placeholder="0,2,5"
+                    value="0",
+                    label="Roof Plane Segment IDs",
+                    placeholder="e.g., 0,2,5,8 (see Top Segments list)",
+                    info="Comma-separated segment IDs to include as roof planes"
                 )
+
                 min_area = gr.Slider(
-                    50, 2000, value=200, step=50,
-                    label="Min Roof Area (sq ft)"
+                    10, 500, value=50, step=10,
+                    label="Min Roof Plane Area (sq ft)",
+                    info="Filter out small segments"
                 )
-            
-            process_btn = gr.Button("🔍 Extract Roof Polygons", variant="primary", size="lg")
-        
+
+            process_btn = gr.Button("🔍 Extract Roof Planes", variant="primary", size="lg")
+
         with gr.Column(scale=2):
             with gr.Row():
-                original_img = gr.Image(label="Satellite Image")
-                overlay_img = gr.Image(label="Segmentation + Polygons")
-            
+                original_img = gr.Image(label="Original Satellite Image")
+                overlay_img = gr.Image(label="Segmentation + Roof Polygons")
+
             with gr.Row():
-                mask_img = gr.Image(label="Roof Mask")
-                status_output = gr.Markdown()
-            
+                edge_img = gr.Image(label="Detected Edges (Red)")
+                mask_img = gr.Image(label="Selected Roof Planes Mask")
+
+            status_output = gr.Markdown()
+
             with gr.Accordion("📄 GeoJSON Output", open=True):
                 geojson_output = gr.Code(language="json", lines=12)
                 download_btn = gr.Button("⬇️ Download GeoJSON")
                 download_file = gr.File(label="Download")
-    
+
     process_btn.click(
         fn=process_address,
-        inputs=[address_input, num_segments, selected_clusters, min_area, radius_meters, api_key_input],
-        outputs=[original_img, overlay_img, mask_img, geojson_output, status_output]
+        inputs=[address_input, segmentation_method, n_segments, selected_clusters,
+                min_area, radius_meters, api_key_input],
+        outputs=[original_img, overlay_img, edge_img, mask_img, geojson_output, status_output]
     )
-    
+
     download_btn.click(
         fn=save_geojson,
         inputs=[geojson_output],
         outputs=[download_file]
     )
-    
+
     gr.Markdown("""
     ---
-    ### How to Use
-    1. Enter a US property address
-    2. Click **Extract Roof Polygons**
-    3. Review the segmentation - identify which cluster colors are roofs
-    4. Enter roof cluster numbers and re-run if needed
-    5. Download GeoJSON for your workflow
-    
-    ### Requirements
-    - Google Cloud project with **Solar API** and **Geocoding API** enabled
-    - API key with access to both APIs
-    
+    ### 🎯 How to Use for Roof Planes
+
+    1. **Enter address** and click Extract
+    2. **Review the segmentation** - each color is a potential roof plane
+    3. **Check "Top 10 Segments"** in the output to identify which segments are roof planes
+    4. **Enter those segment IDs** in "Roof Plane Segment IDs" (e.g., `0,2,5`)
+    5. **Re-run** to get precise polygons for each roof facet
+    6. **Download GeoJSON** with individual roof plane areas
+
+    ### 🔧 Algorithm Notes
+
+    - **SLIC**: Good for uniform roof planes, less sensitive to edges
+    - **Watershed**: Best for pitched roofs with clear ridges/valleys (RECOMMENDED)
+    - **Felzenszwalb**: Preserves fine boundaries, good for complex roofs
+
+    ### 🧠 Technical Details
+
+    - Multi-layer DINOv2 feature extraction (layers 6, 12, 18, 24)
+    - Edge detection via Sobel + Canny
+    - Feature-based segment merging
+    - High-resolution feature upsampling with bicubic interpolation
+
     ---
-    *Powered by DINOv3 (SAT-493M) + Google Solar API*
+    *Powered by DINOv2-Large + Edge-Aware Superpixel Segmentation*
     """)
 
-demo.launch()
+demo.launch()

requirements.txt

@@ -1,8 +1,10 @@
-transformers>=4.40.0
+transformers>=4.56.0
 gradio==3.50.2
 Pillow
 numpy
 scikit-learn
 opencv-python-headless
 requests
-rasterio
+rasterio
+scikit-image
+scipy