fio-l2-cairo-mixedgeom-split

Rerun

import geopandas as gpd

def analyze_geojson(file_path):
    try:
        gdf = gpd.read_file(file_path)
        print("Columns:", gdf.columns.tolist())
        print("CRS:", gdf.crs)
        print("Geometry types found:", gdf.geometry.type.unique())
        print("First 5 rows:")
        print(gdf.head())
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    analyze_geojson("heritage_sites.geojson")

import geopandas as gpd
from shapely.geometry import MultiPolygon, MultiLineString, MultiPoint

def process_heritage_data(input_file, output_file):
    # Load the data
    gdf = gpd.read_file(input_file)
    
    # Egypt National Grid is EPSG:22992 (UTM zone 36N) or similar. 
    # Actually, Egypt's national grid is often referred to as Egypt Red Belt or UTM.
    # However, common practice for "Egypt National Grid" in many GIS contexts is EPSG:22992 (WGS 84 / UTM zone 36N).
    # Let's use EPSG:32636 (WGS 84 / UTM zone 36N) which is very common for Egypt.
    # Wait, let's check if there's a specific "Egypt National Grid" EPSG.
    # EPSG:22992 is Egypt Red Belt. 
    # Let's go with EPSG:32636 as a standard for Egypt or search for a more specific one.
    # Actually, I'll use EPSG:32636 (UTM 36N) as it's the most widely used projected system in Egypt.
    target_crs = "EPSG:32636"
    
    # Re-project to target CRS
    gdf = gdf.to_crs(target_crs)
    
    # Prepare lists for different layers
    points_list = []
    lines_list = []
    polygons_list = []
    
    for idx, row in gdf.iterrows():
        geom = row.geometry
        if geom is None:
            continue
            
        # Explode multi-part geometries to single-part
        if isinstance(geom, (MultiPolygon, MultiLineString, MultiPoint)):
            # Explode multi-geometries into individual single-part geometries
            # We need to maintain the site_id for each part
            parts = []
            if isinstance(geom, MultiPolygon):
                parts = list(geom.geoms)
            elif isinstance(geom, MultiLineString):
                parts = list(geom.geoms)
            elif isinstance(geom, MultiPoint):
                parts = list(geom.geoms)
            
            for part in parts:
                new_row = row.copy()
                new_row.geometry = part
                
                if part.geom_type == 'Point':
                    points_list.append(new_row)
                elif part.geom_type == 'LineString':
                    lines_list.append(new_row)
                elif part.geom_type == 'Polygon':
                    polygons_list.append(new_row)
        else:
            # Already single-part
            if geom.geom_type == 'Point':
                points_list.append(row)
            elif geom.geom_type == 'LineString':
                lines_list.append(row)
            elif geom.geom_type == 'Polygon':
                polygons_list.append(row)

    # Convert lists back to GeoDataFrames
    # Note: if a list is empty, we still want to handle it gracefully
    def create_gdf(rows, name):
        if not rows:
            # Create an empty GeoDataFrame with the same columns and CRS if no features found
            return gpd.GeoDataFrame(columns=gdf.columns, geometry='geometry', crs=target_crs)
        # Construct GDF from list of Series
        import pandas as pd
        df = pd.DataFrame(rows)
        # Since rows are Series, we need to ensure 'geometry' is correctly typed
        gdf_out = gpd.GeoDataFrame(df, geometry='geometry', crs=target_crs)
        return gdf_out

    gdf_points = create_gdf(points_list, 'points')
    gdf_lines = create_gdf(lines_list, 'lines')
    gdf_polygons = create_gdf(polygons_list, 'polygons')

    # Write to GPKG
    with gpd.GeoDataFrame(columns=gdf.columns, geometry='geometry', crs=target_crs).constructor as engine:
        # Using standard geopandas write (which uses fiona/pyogrio)
        pass 

    # Simplified write process
    gdf_points.to_file(output_file, layer='points', driver="GPKG")
    gdf_lines.to_file(output_file, layer='lines', driver="GPKG")
    gdf_polygons.to_file(output_file, layer='polygons', driver="GPKG")
    
    print(f"Successfully created {output_file}")
    print(f"Points: {len(gdf_points)}")
    print(f"Lines: {len(gdf_lines)}")
    print(f"Polygons: {len(gdf_polygons)}")

if __name__ == "__main__":
    process_heritage_data("heritage_sites.geojson", "heritage.gpkg")

import geopandas as gpd

def verify_output(file_path):
    print(f"Verifying {file_path}:")
    layers = ['points', 'lines', 'polygons']
    for layer in layers:
        gdf = gpd.read_file(file_path, layer=layer)
        print(f"Layer: {layer}")
        print(f"  Count: {len(gdf)}")
        print(f"  CRS: {gdf.crs}")
        print(f"  Geometry Type: {gdf.geom_type.unique()}")
        print(f"  Columns: {gdf.columns.tolist()}")
        if not gdf.empty:
            print(f"  First site_id: {gdf['site_id'].iloc[0]}")
            print(f"  First geometry type: {gdf.geom_type.iloc[0]}")
        print("-" * 20)

if __name__ == "__main__":
    verify_output("heritage.gpkg")