geoai-py 0.2.3__py2.py3-none-any.whl → 0.3.0__py2.py3-none-any.whl

geoai/{common.py → utils.py}

@@ -588,6 +588,8 @@ def view_vector(
 
 def view_vector_interactive(
     vector_data,
+    layer_name="Vector Layer",
+    tiles_args=None,
     **kwargs,
 ):
     """
@@ -599,6 +601,9 @@ def view_vector_interactive(
 
     Args:
         vector_data (geopandas.GeoDataFrame): The vector dataset to visualize.
+        layer_name (str, optional): The name of the layer. Defaults to "Vector Layer".
+        tiles_args (dict, optional): Additional arguments for the localtileserver client.
+            get_folium_tile_layer function. Defaults to None.
         **kwargs: Additional keyword arguments to pass to GeoDataFrame.explore() function.
         See https://geopandas.org/en/stable/docs/reference/api/geopandas.GeoDataFrame.explore.html
 
@@ -613,6 +618,59 @@ def view_vector_interactive(
         >>> roads = gpd.read_file("roads.shp")
         >>> view_vector_interactive(roads, figsize=(12, 8))
     """
+    import folium
+    import folium.plugins as plugins
+    from localtileserver import get_folium_tile_layer, TileClient
+    from leafmap import cog_tile
+
+    google_tiles = {
+        "Roadmap": {
+            "url": "https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}",
+            "attribution": "Google",
+            "name": "Google Maps",
+        },
+        "Satellite": {
+            "url": "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}",
+            "attribution": "Google",
+            "name": "Google Satellite",
+        },
+        "Terrain": {
+            "url": "https://mt1.google.com/vt/lyrs=p&x={x}&y={y}&z={z}",
+            "attribution": "Google",
+            "name": "Google Terrain",
+        },
+        "Hybrid": {
+            "url": "https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}",
+            "attribution": "Google",
+            "name": "Google Hybrid",
+        },
+    }
+
+    basemap_layer_name = None
+    raster_layer = None
+
+    if "tiles" in kwargs and isinstance(kwargs["tiles"], str):
+        if kwargs["tiles"].title() in google_tiles:
+            basemap_layer_name = google_tiles[kwargs["tiles"].title()]["name"]
+            kwargs["tiles"] = google_tiles[kwargs["tiles"].title()]["url"]
+            kwargs["attr"] = "Google"
+        elif kwargs["tiles"].lower().endswith(".tif"):
+            if tiles_args is None:
+                tiles_args = {}
+            if kwargs["tiles"].lower().startswith("http"):
+                basemap_layer_name = "Remote Raster"
+                kwargs["tiles"] = cog_tile(kwargs["tiles"], **tiles_args)
+                kwargs["attr"] = "TiTiler"
+            else:
+                basemap_layer_name = "Local Raster"
+                client = TileClient(kwargs["tiles"])
+                raster_layer = get_folium_tile_layer(client, **tiles_args)
+                kwargs["tiles"] = raster_layer.tiles
+                kwargs["attr"] = "localtileserver"
+
+    if "max_zoom" not in kwargs:
+        kwargs["max_zoom"] = 30
+
     if isinstance(vector_data, str):
         vector_data = gpd.read_file(vector_data)
 
@@ -620,4 +678,364 @@ def view_vector_interactive(
     if not isinstance(vector_data, gpd.GeoDataFrame):
         raise TypeError("Input data must be a GeoDataFrame")
 
-    return vector_data.explore(**kwargs)
+    layer_control = kwargs.pop("layer_control", True)
+    fullscreen_control = kwargs.pop("fullscreen_control", True)
+
+    m = vector_data.explore(**kwargs)
+
+    # Change the layer name
+    for layer in m._children.values():
+        if isinstance(layer, folium.GeoJson):
+            layer.layer_name = layer_name
+        if isinstance(layer, folium.TileLayer) and basemap_layer_name:
+            layer.layer_name = basemap_layer_name
+
+    if layer_control:
+        m.add_child(folium.LayerControl())
+
+    if fullscreen_control:
+        plugins.Fullscreen().add_to(m)
+
+    return m
+
+
+def regularization(
+    building_polygons,
+    angle_tolerance=10,
+    simplify_tolerance=0.5,
+    orthogonalize=True,
+    preserve_topology=True,
+):
+    """
+    Regularizes building footprint polygons with multiple techniques beyond minimum
+    rotated rectangles.
+
+    Args:
+        building_polygons: GeoDataFrame or list of shapely Polygons containing building footprints
+        angle_tolerance: Degrees within which angles will be regularized to 90/180 degrees
+        simplify_tolerance: Distance tolerance for Douglas-Peucker simplification
+        orthogonalize: Whether to enforce orthogonal angles in the final polygons
+        preserve_topology: Whether to preserve topology during simplification
+
+    Returns:
+        GeoDataFrame or list of shapely Polygons with regularized building footprints
+    """
+    from shapely.geometry import Polygon, shape
+    from shapely.affinity import rotate, translate
+    from shapely import wkt
+
+    regularized_buildings = []
+
+    # Check if we're dealing with a GeoDataFrame
+    if isinstance(building_polygons, gpd.GeoDataFrame):
+        geom_objects = building_polygons.geometry
+    else:
+        geom_objects = building_polygons
+
+    for building in geom_objects:
+        # Handle potential string representations of geometries
+        if isinstance(building, str):
+            try:
+                # Try to parse as WKT
+                building = wkt.loads(building)
+            except Exception:
+                print(f"Failed to parse geometry string: {building[:30]}...")
+                continue
+
+        # Ensure we have a valid geometry
+        if not hasattr(building, "simplify"):
+            print(f"Invalid geometry type: {type(building)}")
+            continue
+
+        # Step 1: Simplify to remove noise and small vertices
+        simplified = building.simplify(
+            simplify_tolerance, preserve_topology=preserve_topology
+        )
+
+        if orthogonalize:
+            # Make sure we have a valid polygon with an exterior
+            if not hasattr(simplified, "exterior") or simplified.exterior is None:
+                print(f"Simplified geometry has no exterior: {simplified}")
+                regularized_buildings.append(building)  # Use original instead
+                continue
+
+            # Step 2: Get the dominant angle to rotate building
+            coords = np.array(simplified.exterior.coords)
+
+            # Make sure we have enough coordinates for angle calculation
+            if len(coords) < 3:
+                print(f"Not enough coordinates for angle calculation: {len(coords)}")
+                regularized_buildings.append(building)  # Use original instead
+                continue
+
+            segments = np.diff(coords, axis=0)
+            angles = np.arctan2(segments[:, 1], segments[:, 0]) * 180 / np.pi
+
+            # Find most common angle classes (0, 90, 180, 270 degrees)
+            binned_angles = np.round(angles / 90) * 90
+            dominant_angle = np.bincount(binned_angles.astype(int) % 180).argmax()
+
+            # Step 3: Rotate to align with axes, regularize, then rotate back
+            rotated = rotate(simplified, -dominant_angle, origin="centroid")
+
+            # Step 4: Rectify coordinates to enforce right angles
+            ext_coords = np.array(rotated.exterior.coords)
+            rect_coords = []
+
+            # Regularize each vertex to create orthogonal corners
+            for i in range(len(ext_coords) - 1):
+                rect_coords.append(ext_coords[i])
+
+                # Check if we need to add a right-angle vertex
+                angle = (
+                    np.arctan2(
+                        ext_coords[(i + 1) % (len(ext_coords) - 1), 1]
+                        - ext_coords[i, 1],
+                        ext_coords[(i + 1) % (len(ext_coords) - 1), 0]
+                        - ext_coords[i, 0],
+                    )
+                    * 180
+                    / np.pi
+                )
+
+                if abs(angle % 90) > angle_tolerance and abs(angle % 90) < (
+                    90 - angle_tolerance
+                ):
+                    # Add intermediate point to create right angle
+                    rect_coords.append(
+                        [
+                            ext_coords[(i + 1) % (len(ext_coords) - 1), 0],
+                            ext_coords[i, 1],
+                        ]
+                    )
+
+            # Close the polygon by adding the first point again
+            rect_coords.append(rect_coords[0])
+
+            # Create regularized polygon and rotate back
+            regularized = Polygon(rect_coords)
+            final_building = rotate(regularized, dominant_angle, origin="centroid")
+        else:
+            final_building = simplified
+
+        regularized_buildings.append(final_building)
+
+    # If input was a GeoDataFrame, return a GeoDataFrame
+    if isinstance(building_polygons, gpd.GeoDataFrame):
+        return gpd.GeoDataFrame(
+            geometry=regularized_buildings, crs=building_polygons.crs
+        )
+    else:
+        return regularized_buildings
+
+
+def hybrid_regularization(building_polygons):
+    """
+    A comprehensive hybrid approach to building footprint regularization.
+
+    Applies different strategies based on building characteristics.
+
+    Args:
+        building_polygons: GeoDataFrame or list of shapely Polygons containing building footprints
+
+    Returns:
+        GeoDataFrame or list of shapely Polygons with regularized building footprints
+    """
+    from shapely.geometry import Polygon
+    from shapely.affinity import rotate
+
+    # Use minimum_rotated_rectangle instead of oriented_envelope
+    try:
+        from shapely.minimum_rotated_rectangle import minimum_rotated_rectangle
+    except ImportError:
+        # For older Shapely versions
+        def minimum_rotated_rectangle(geom):
+            """Calculate the minimum rotated rectangle for a geometry"""
+            # For older Shapely versions, implement a simple version
+            return geom.minimum_rotated_rectangle
+
+    # Determine input type for correct return
+    is_gdf = isinstance(building_polygons, gpd.GeoDataFrame)
+
+    # Extract geometries if GeoDataFrame
+    if is_gdf:
+        geom_objects = building_polygons.geometry
+    else:
+        geom_objects = building_polygons
+
+    results = []
+
+    for building in geom_objects:
+        # 1. Analyze building characteristics
+        if not hasattr(building, "exterior") or building.is_empty:
+            results.append(building)
+            continue
+
+        # Calculate shape complexity metrics
+        complexity = building.length / (4 * np.sqrt(building.area))
+
+        # Calculate dominant angle
+        coords = np.array(building.exterior.coords)[:-1]
+        segments = np.diff(np.vstack([coords, coords[0]]), axis=0)
+        segment_lengths = np.sqrt(segments[:, 0] ** 2 + segments[:, 1] ** 2)
+        segment_angles = np.arctan2(segments[:, 1], segments[:, 0]) * 180 / np.pi
+
+        # Weight angles by segment length
+        hist, bins = np.histogram(
+            segment_angles % 180, bins=36, range=(0, 180), weights=segment_lengths
+        )
+        bin_centers = (bins[:-1] + bins[1:]) / 2
+        dominant_angle = bin_centers[np.argmax(hist)]
+
+        # Check if building is close to orthogonal
+        is_orthogonal = min(dominant_angle % 45, 45 - (dominant_angle % 45)) < 5
+
+        # 2. Apply appropriate regularization strategy
+        if complexity > 1.5:
+            # Complex buildings: use minimum rotated rectangle
+            result = minimum_rotated_rectangle(building)
+        elif is_orthogonal:
+            # Near-orthogonal buildings: orthogonalize in place
+            rotated = rotate(building, -dominant_angle, origin="centroid")
+
+            # Create orthogonal hull in rotated space
+            bounds = rotated.bounds
+            ortho_hull = Polygon(
+                [
+                    (bounds[0], bounds[1]),
+                    (bounds[2], bounds[1]),
+                    (bounds[2], bounds[3]),
+                    (bounds[0], bounds[3]),
+                ]
+            )
+
+            result = rotate(ortho_hull, dominant_angle, origin="centroid")
+        else:
+            # Diagonal buildings: use custom approach for diagonal buildings
+            # Rotate to align with axes
+            rotated = rotate(building, -dominant_angle, origin="centroid")
+
+            # Simplify in rotated space
+            simplified = rotated.simplify(0.3, preserve_topology=True)
+
+            # Get the bounds in rotated space
+            bounds = simplified.bounds
+            min_x, min_y, max_x, max_y = bounds
+
+            # Create a rectangular hull in rotated space
+            rect_poly = Polygon(
+                [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+            )
+
+            # Rotate back to original orientation
+            result = rotate(rect_poly, dominant_angle, origin="centroid")
+
+        results.append(result)
+
+    # Return in same format as input
+    if is_gdf:
+        return gpd.GeoDataFrame(geometry=results, crs=building_polygons.crs)
+    else:
+        return results
+
+
+def adaptive_regularization(
+    building_polygons, simplify_tolerance=0.5, area_threshold=0.9, preserve_shape=True
+):
+    """
+    Adaptively regularizes building footprints based on their characteristics.
+
+    This approach determines the best regularization method for each building.
+
+    Args:
+        building_polygons: GeoDataFrame or list of shapely Polygons
+        simplify_tolerance: Distance tolerance for simplification
+        area_threshold: Minimum acceptable area ratio
+        preserve_shape: Whether to preserve overall shape for complex buildings
+
+    Returns:
+        GeoDataFrame or list of shapely Polygons with regularized building footprints
+    """
+    from shapely.geometry import Polygon
+    from shapely.affinity import rotate
+
+    # Analyze the overall dataset to set appropriate parameters
+    if is_gdf := isinstance(building_polygons, gpd.GeoDataFrame):
+        geom_objects = building_polygons.geometry
+    else:
+        geom_objects = building_polygons
+
+    results = []
+
+    for building in geom_objects:
+        # Skip invalid geometries
+        if not hasattr(building, "exterior") or building.is_empty:
+            results.append(building)
+            continue
+
+        # Measure building complexity
+        complexity = building.length / (4 * np.sqrt(building.area))
+
+        # Determine if the building has a clear principal direction
+        coords = np.array(building.exterior.coords)[:-1]
+        segments = np.diff(np.vstack([coords, coords[0]]), axis=0)
+        segment_lengths = np.sqrt(segments[:, 0] ** 2 + segments[:, 1] ** 2)
+        angles = np.arctan2(segments[:, 1], segments[:, 0]) * 180 / np.pi
+
+        # Normalize angles to 0-180 range and get histogram
+        norm_angles = angles % 180
+        hist, bins = np.histogram(
+            norm_angles, bins=18, range=(0, 180), weights=segment_lengths
+        )
+
+        # Calculate direction clarity (ratio of longest direction to total)
+        direction_clarity = np.max(hist) / np.sum(hist) if np.sum(hist) > 0 else 0
+
+        # Choose regularization method based on building characteristics
+        if complexity < 1.2 and direction_clarity > 0.5:
+            # Simple building with clear direction: use rotated rectangle
+            bin_max = np.argmax(hist)
+            bin_centers = (bins[:-1] + bins[1:]) / 2
+            dominant_angle = bin_centers[bin_max]
+
+            # Rotate to align with coordinate system
+            rotated = rotate(building, -dominant_angle, origin="centroid")
+
+            # Create bounding box in rotated space
+            bounds = rotated.bounds
+            rect = Polygon(
+                [
+                    (bounds[0], bounds[1]),
+                    (bounds[2], bounds[1]),
+                    (bounds[2], bounds[3]),
+                    (bounds[0], bounds[3]),
+                ]
+            )
+
+            # Rotate back
+            result = rotate(rect, dominant_angle, origin="centroid")
+
+            # Quality check
+            if (
+                result.area / building.area < area_threshold
+                or result.area / building.area > (1.0 / area_threshold)
+            ):
+                # Too much area change, use simplified original
+                result = building.simplify(simplify_tolerance, preserve_topology=True)
+
+        else:
+            # Complex building or no clear direction: preserve shape
+            if preserve_shape:
+                # Simplify with topology preservation
+                result = building.simplify(simplify_tolerance, preserve_topology=True)
+            else:
+                # Fall back to convex hull for very complex shapes
+                result = building.convex_hull
+
+        results.append(result)
+
+    # Return in same format as input
+    if is_gdf:
+        return gpd.GeoDataFrame(geometry=results, crs=building_polygons.crs)
+    else:
+        return results

{geoai_py-0.2.3.dist-info → geoai_py-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: geoai-py
-Version: 0.2.3
+Version: 0.3.0
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License

geoai_py-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+geoai/__init__.py,sha256=rJod2PDa1AiRHE8ugVp0Bfiky7ZWBhqbh2kZ45WiggA,923
+geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
+geoai/extract.py,sha256=9oLbrSg_aHcimpYxfk0jLOIHQWVULRsdiAGUsPLC-qk,71708
+geoai/geoai.py,sha256=wNwKIqwOT10tU4uiWTcNp5Gd598rRFMANIfJsGdOWKM,90
+geoai/preprocess.py,sha256=teV-W7ykXnoru0Y_d0V9ANdO6jMyETeGbqr1_8H-Yh0,118523
+geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
+geoai/utils.py,sha256=3vXFDdFqZeg4kgeNt6-Hp28RfNoQcDOH7BjrlJ6L0UE,37521
+geoai_py-0.3.0.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.3.0.dist-info/METADATA,sha256=L62RHKj0Yqno8LDYVrL50YyMfO1ybRYs2NI15WHiJMQ,5754
+geoai_py-0.3.0.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+geoai_py-0.3.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.3.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.3.0.dist-info/RECORD,,

geoai_py-0.2.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-geoai/__init__.py,sha256=TyhISsNnMOVPLx0wyM79k-Dgfak4s7QhfKPEIh0rBg8,923
-geoai/common.py,sha256=stnGB-OiTdpb9hTSaaVn5jKAGweFNM760NFKP6suiv0,21735
-geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
-geoai/extract.py,sha256=wjo5KyaUMsci3oclnOGFqwPe1VIV4vlkFcbJlPWDOzI,31572
-geoai/geoai.py,sha256=r9mFviDJrs7xvbK8kN3kIzZp-yswqTAleUejQvrZD4U,91
-geoai/preprocess.py,sha256=2O3gaGN5imIpmTdudQdTbvCtrBqdmOb0AGNEz81MW2M,109762
-geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
-geoai_py-0.2.3.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.2.3.dist-info/METADATA,sha256=T7lSXz-PE_AUSStKbnE5HUJi7-q5w04VIyiI7TZ4Xrw,5754
-geoai_py-0.2.3.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-geoai_py-0.2.3.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.2.3.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.2.3.dist-info/RECORD,,