Add aggressive polygon simplification + Google roof segment visualization

## Key Changes for Solar Panel Layout Tool

### 1. Increased Geometric Merge Tolerance
- Slope tolerance: 5° → 8° (more aggressive merging)
- Aspect tolerance: 20° → 30° (wider angle tolerance)
- Fixes shadow-split roof planes more effectively

### 2. Douglas-Peucker Polygon Simplification
- Epsilon increased: 0.5% → 2% of perimeter (4x more aggressive)
- Creates **straight edges** suitable for solar panel placement
- Eliminates "splotchy" boundaries shown in user feedback
- Output: Clean polygons with straight lines

### 3. Google Roof Segment Visualization (NEW)
- Added `visualize_google_roof_segments()` function
- Displays Google's pre-computed roof planes with:
- Color-coded segments
- Pitch and azimuth labels (e.g., "G0: 18° @ 279°")
- Replaced "Roof Planes Mask" output with "Google's Roof Segments (API)"
- Users can now compare custom segmentation vs Google's baseline

## User Requirements Addressed
- "Need better merge" → Increased geometric tolerance
- "Ramer-Douglas-Peucker to straighten splotches" → 2% epsilon
- "Clearly defined lines" → Straight polygon edges
- "Series of lat/lng coordinates" → Already in GeoJSON output
- "Visualize Google roof segments" → New visualization panel
- "Solar layout tool for panel placement" → Clean zones with straight edges

Expected result: 4-6 clean roof plane polygons with straight edges matching solar panel installation requirements.

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

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

app.py

@@ -895,12 +895,14 @@ def refine_segments_with_features(segments, features, similarity_threshold=0.85,
     return merged_segments
 
 
-def merge_by_geometry(segments, dsm_array, slope_tolerance=5.0, aspect_tolerance=20.0):
+def merge_by_geometry(segments, dsm_array, slope_tolerance=8.0, aspect_tolerance=30.0):
     """
     Second merge pass: combine segments with same geometric orientation.
 
     This fixes the issue where shadows split roof planes - segments on the SAME
     geometric plane will merge even if they look different in RGB.
+
+    Increased tolerances: slope ±8° (was 5°), aspect ±30° (was 20°)
     """
     # Compute slope/aspect for the DSM
     slope, aspect, _, _, _ = compute_slope_aspect(dsm_array, pixel_size_meters=0.1)
@@ -996,6 +998,62 @@ def is_rectangle_matching_bounds(contour, img_width, img_height, tolerance=5):
     return matches_left and matches_top and matches_right and matches_bottom
 
 
+def visualize_google_roof_segments(google_segments, image_shape, bounds):
+    """
+    Visualize Google's pre-computed roof segments as colored overlay.
+
+    Returns visualization image showing Google's detected roof planes.
+    """
+    if not google_segments:
+        return None
+
+    # Create blank canvas
+    h, w = image_shape[:2]
+    viz = np.zeros((h, w, 3), dtype=np.uint8)
+
+    colors = [
+        [230, 25, 75], [60, 180, 75], [255, 225, 25], [0, 130, 200],
+        [245, 130, 48], [145, 30, 180], [70, 240, 240], [240, 50, 230]
+    ]
+
+    west, south, east, north = bounds
+
+    for idx, segment in enumerate(google_segments):
+        bbox = segment.get('bounding_box', {})
+        if not bbox:
+            continue
+
+        # Convert lat/lng bounding box to pixel coordinates
+        sw_lat = bbox.get('southwest', {}).get('latitude')
+        sw_lng = bbox.get('southwest', {}).get('longitude')
+        ne_lat = bbox.get('northeast', {}).get('latitude')
+        ne_lng = bbox.get('northeast', {}).get('longitude')
+
+        if not all([sw_lat, sw_lng, ne_lat, ne_lng]):
+            continue
+
+        # Convert to pixel coords
+        x1 = int((sw_lng - west) / (east - west) * w)
+        x2 = int((ne_lng - west) / (east - west) * w)
+        y1 = int((north - ne_lat) / (north - south) * h)  # Flip Y
+        y2 = int((north - sw_lat) / (north - south) * h)
+
+        # Clamp to image bounds
+        x1, x2 = max(0, min(x1, x2)), min(w, max(x1, x2))
+        y1, y2 = max(0, min(y1, y2)), min(h, max(y1, y2))
+
+        # Draw filled rectangle
+        color = colors[idx % len(colors)]
+        cv2.rectangle(viz, (x1, y1), (x2, y2), color, -1)
+
+        # Add text label
+        label = f"G{idx}: {segment['pitch_degrees']:.0f}° @ {segment['azimuth_degrees']:.0f}°"
+        cv2.putText(viz, label, (x1 + 5, y1 + 20), cv2.FONT_HERSHEY_SIMPLEX,
+                    0.4, (255, 255, 255), 1, cv2.LINE_AA)
+
+    return viz
+
+
 def mask_to_polygons(mask, bounds, img_width, img_height, min_area_sqft=50):
     """Convert binary mask to GeoJSON polygons with simplified approach."""
     features = []
@@ -1015,10 +1073,10 @@ def mask_to_polygons(mask, bounds, img_width, img_height, min_area_sqft=50):
         if is_rectangle_matching_bounds(contour, img_width, img_height):
             continue  # Skip this contour (it's the building boundary, not a roof plane)
 
-        # Simplified approach: Just Douglas-Peucker simplification
-        # Use conservative epsilon for cleaner but not over-simplified edges
+        # Douglas-Peucker simplification for STRAIGHT EDGES
+        # Increased epsilon for cleaner polygons (straight lines for solar panels)
         perimeter = cv2.arcLength(contour, True)
-        epsilon = 0.005 * perimeter  # 0.5% of perimeter - less aggressive
+        epsilon = 0.02 * perimeter  # 2% of perimeter - more aggressive for straight edges
         simplified = cv2.approxPolyDP(contour, epsilon, True)
 
         coords = []
@@ -1290,6 +1348,22 @@ def process_address(address, segmentation_method, n_segments, selected_clusters,
         edge_viz = orig_array.copy()
         edge_viz[edges > 0] = [255, 0, 0]  # Red edges
 
+        # Google roof segments visualization
+        google_viz = None
+        if google_roof_segments:
+            google_viz = visualize_google_roof_segments(
+                google_roof_segments,
+                orig_array.shape,
+                bounds
+            )
+            if google_viz is not None:
+                # Blend with original image
+                google_viz = (orig_array * 0.4 + google_viz * 0.6).astype(np.uint8)
+            else:
+                google_viz = np.zeros_like(orig_array, dtype=np.uint8)
+        else:
+            google_viz = np.zeros_like(orig_array, dtype=np.uint8)
+
         total_sqft = sum(f["properties"]["area_sqft"] for f in polygon_features)
         status += f"\n**Found {len(polygon_features)} roof plane polygon(s)**\n"
         status += f"**Total roof area: {total_sqft:,.0f} sq ft**\n\n"
@@ -1310,7 +1384,7 @@ def process_address(address, segmentation_method, n_segments, selected_clusters,
             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)
+                google_viz, geojson_str, status)
 
     except Exception as e:
         import traceback
@@ -1426,7 +1500,7 @@ with gr.Blocks(title="Roof Plane Segmentation - DINOv3", theme=gr.themes.Soft())
 
             with gr.Row():
                 edge_img = gr.Image(label="Detected Edges (Red)")
-                mask_img = gr.Image(label="Selected Roof Planes Mask")
+                google_img = gr.Image(label="Google's Roof Segments (API)")
 
             status_output = gr.Markdown()
 
@@ -1440,7 +1514,7 @@ with gr.Blocks(title="Roof Plane Segmentation - DINOv3", theme=gr.themes.Soft())
         inputs=[address_input, segmentation_method, n_segments, selected_clusters,
                 min_area, radius_meters, api_key_input,
                 hough_threshold, min_line_length, dsm_threshold, merge_threshold],
-        outputs=[original_img, overlay_img, edge_img, mask_img, geojson_output, status_output]
+        outputs=[original_img, overlay_img, edge_img, google_img, geojson_output, status_output]
     )
 
     download_btn.click(