""" Map Handler for Geographic Drawing Supports drawing custom shapes on interactive maps """ import folium from folium.plugins import Draw import streamlit as st from streamlit_folium import st_folium from typing import List, Tuple, Dict, Any, Optional import json import numpy as np from shapely.geometry import Polygon, shape from shapely.ops import transform import pyproj from functools import partial class MapDrawingHandler: """Handle map-based shape drawing and coordinate conversion""" # Default center (Delhi, India for Indian Building Regulations context) DEFAULT_CENTER = [28.6139, 77.2090] DEFAULT_ZOOM = 15 def __init__(self, center: List[float] = None, zoom: int = None): self.center = center or self.DEFAULT_CENTER self.zoom = zoom or self.DEFAULT_ZOOM self.drawn_shapes = [] def create_drawing_map(self, existing_shape: List[Tuple[float, float]] = None, height: int = 500) -> folium.Map: """Create a Folium map with drawing controls""" m = folium.Map( location=self.center, zoom_start=self.zoom, tiles='OpenStreetMap' ) # Add alternative tile layers folium.TileLayer('cartodbpositron', name='Light Map').add_to(m) folium.TileLayer('cartodbdark_matter', name='Dark Map').add_to(m) # Add satellite imagery option folium.TileLayer( tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', attr='Esri', name='Satellite' ).add_to(m) # Add draw control draw = Draw( export=True, position='topleft', draw_options={ 'polyline': False, 'rectangle': True, 'polygon': True, 'circle': False, 'marker': False, 'circlemarker': False }, edit_options={ 'edit': True, 'remove': True } ) draw.add_to(m) # Add existing shape if provided if existing_shape: # Convert to lat/lng for display geo_coords = self.meters_to_latlng(existing_shape) folium.Polygon( locations=geo_coords, color='blue', fill=True, fill_opacity=0.3, popup='Existing Site Boundary' ).add_to(m) # Add layer control folium.LayerControl().add_to(m) return m def extract_drawn_shape(self, map_data: Dict) -> Optional[List[Tuple[float, float]]]: """Extract drawn shape from map data and convert to meters""" if not map_data or 'all_drawings' not in map_data: return None drawings = map_data.get('all_drawings', []) if not drawings: return None # Get the last drawn polygon for drawing in reversed(drawings): geom = drawing.get('geometry', {}) if geom.get('type') in ['Polygon', 'Rectangle']: coords = geom.get('coordinates', [[]])[0] if coords: # Convert from [lng, lat] to [lat, lng] then to meters latlng_coords = [(c[1], c[0]) for c in coords] return self.latlng_to_meters(latlng_coords) return None def latlng_to_meters(self, coords: List[Tuple[float, float]], reference: Tuple[float, float] = None) -> List[Tuple[float, float]]: """ Convert lat/lng coordinates to local meter coordinates Uses UTM projection centered on the shape """ if not coords: return [] # Get reference point (centroid of shape) if reference is None: lats = [c[0] for c in coords] lngs = [c[1] for c in coords] reference = (sum(lats) / len(lats), sum(lngs) / len(lngs)) # Determine UTM zone utm_zone = int((reference[1] + 180) / 6) + 1 is_northern = reference[0] >= 0 # Create projection proj_string = f"+proj=utm +zone={utm_zone} +{'north' if is_northern else 'south'} +ellps=WGS84 +datum=WGS84 +units=m +no_defs" try: wgs84 = pyproj.CRS('EPSG:4326') utm = pyproj.CRS(proj_string) transformer = pyproj.Transformer.from_crs(wgs84, utm, always_xy=True) # Transform coordinates meter_coords = [] for lat, lng in coords: x, y = transformer.transform(lng, lat) meter_coords.append((x, y)) # Normalize to origin xs = [c[0] for c in meter_coords] ys = [c[1] for c in meter_coords] min_x, min_y = min(xs), min(ys) normalized = [(x - min_x, y - min_y) for x, y in meter_coords] return normalized except Exception as e: print(f"Projection error: {e}") # Fallback: simple equirectangular approximation lat_scale = 111320 # meters per degree latitude lng_scale = lat_scale * np.cos(np.radians(reference[0])) meter_coords = [] ref_lat, ref_lng = reference for lat, lng in coords: x = (lng - ref_lng) * lng_scale y = (lat - ref_lat) * lat_scale meter_coords.append((x, y)) # Normalize to origin xs = [c[0] for c in meter_coords] ys = [c[1] for c in meter_coords] min_x, min_y = min(xs), min(ys) return [(x - min_x, y - min_y) for x, y in meter_coords] def meters_to_latlng(self, coords: List[Tuple[float, float]], reference: Tuple[float, float] = None) -> List[Tuple[float, float]]: """Convert meter coordinates back to lat/lng (approximate)""" if reference is None: reference = self.center lat_scale = 111320 lng_scale = lat_scale * np.cos(np.radians(reference[0])) latlng_coords = [] for x, y in coords: lat = reference[0] + y / lat_scale lng = reference[1] + x / lng_scale latlng_coords.append((lat, lng)) return latlng_coords def validate_shape(self, coords: List[Tuple[float, float]]) -> Tuple[bool, str]: """Validate drawn shape""" if not coords or len(coords) < 3: return False, "Shape must have at least 3 points" try: polygon = Polygon(coords) if not polygon.is_valid: polygon = polygon.buffer(0) if not polygon.is_valid: return False, "Invalid polygon shape" area = polygon.area if area < 1000: # Less than 1000 sq meters return False, f"Shape too small ({area:.0f} sq.m). Minimum 1000 sq.m required." if area > 10000000: # More than 10 sq km return False, f"Shape too large ({area/1000000:.2f} sq.km). Maximum 10 sq.km allowed." return True, f"Valid shape: {area:.0f} sq.m" except Exception as e: return False, f"Validation error: {str(e)}" class ShapePreviewRenderer: """Render shape previews for UI""" @staticmethod def render_shape_svg(coords: List[Tuple[float, float]], width: int = 200, height: int = 150) -> str: """Generate SVG preview of shape""" if not coords: return "" # Normalize coordinates to fit SVG viewport xs = [c[0] for c in coords] ys = [c[1] for c in coords] min_x, max_x = min(xs), max(xs) min_y, max_y = min(ys), max(ys) shape_width = max_x - min_x shape_height = max_y - min_y if shape_width == 0 or shape_height == 0: return "" # Scale and translate padding = 10 scale_x = (width - 2 * padding) / shape_width scale_y = (height - 2 * padding) / shape_height scale = min(scale_x, scale_y) offset_x = padding + (width - 2 * padding - shape_width * scale) / 2 offset_y = padding + (height - 2 * padding - shape_height * scale) / 2 # Generate path path_points = [] for x, y in coords: sx = offset_x + (x - min_x) * scale sy = height - (offset_y + (y - min_y) * scale) # Flip Y path_points.append(f"{sx:.1f},{sy:.1f}") path_d = "M " + " L ".join(path_points) + " Z" svg = f""" """ return svg