dc-l1-tokyo-ring-orientation

Rerun

import geopandas as gpd

def check_geometry(gdf):
    print(f"Total features: {len(gdf)}")
    print(f"Valid geometries: {gdf.geometry.is_valid.sum()}")
    print(f"Invalid geometries: {len(gdf) - gdf.geometry.is_valid.sum()}")
    
    # Check for common issues: self-intersections, wrong orientation
    # In GeoJSON, the exterior ring should be CCW and interior rings CW (or vice versa depending on spec, 
    # but usually standard viewers expect a specific orientation).
    # However, the "holes appear filled and exteriors render as empty space" 
    # strongly suggests the ring orientation is reversed.
    # Standard GeoJSON (RFC 7946) specifies:
    # Exterior ring: counter-clockwise (CCW)
    # Interior rings: clockwise (CW)
    # If they are swapped, viewers get confused.

if __name__ == "__main__":
    gdf = gpd.read_file("tokyo_buildings_legacy.geojson")
    check_geometry(gdf)

import geopandas as gpd
from shapely.geometry import Polygon

def fix_orientation(geom):
    """
    Ensure exterior ring is CCW and interior rings are CW.
    Shapely's orient() function can do this.
    """
    from shapely.geometry import Polygon
    from shapely import orient
    
    if geom.is_empty:
        return geom
    
    # orient(geom, sign=1.0) 
    # sign=1.0 makes the exterior ring counter-clockwise
    # sign=-1.0 makes the exterior ring clockwise
    # RFC 7946 says exterior ring CCW, interior rings CW.
    # In Shapely, orient(geom, sign=1.0) ensures exterior is CCW.
    return orient(geom, sign=1.0)

def main():
    gdf = gpd.read_file("tokyo_buildings_legacy.geojson")
    print(f"Loaded {len(gdf)} features.")
    
    # Check orientation of the first feature's exterior ring manually to verify
    first_geom = gdf.geometry.iloc[0]
    if isinstance(first_geom, Polygon):
        # Shoelace formula for orientation
        def is_ccw(coords):
            # coords is a list of (x, y) tuples
            area = 0
            for i in range(len(coords)):
                x1, y1 = coords[i]
                x2, y2 = coords[(i + 1) % len(coords)]
                area += (x2 - x1) * (y2 + y1)
            return area < 0 # If area < 0, it is CCW in most coordinate systems (y-up)

        # Note: In GeoJSON (y-up), CCW exterior:
        # Let's just use shapely's orient which is robust.
        pass

    print("Fixing orientations...")
    gdf.geometry = gdf.geometry.apply(fix_orientation)
    
    # Also, ensure validities (sometimes orientation fix can trigger issues if not careful)
    # but orient() should be safe.
    gdf.geometry = gdf.geometry.buffer(0) # A common trick to fix minor topology issues

    print(f"Final valid count: {gdf.geometry.is_valid.sum()}")
    gdf.to_file("tokyo_buildings_fixed.geojson", driver="GeoJSON")
    print("Saved to tokyo_buildings_fixed.geojson")

if __name__ == "__main__":
    main()

import geopandas as gpd
from shapely.geometry import Polygon
from shapely.ops import orient

def fix_orientation(geom):
    """
    Ensure exterior ring is CCW and interior rings are CW.
    """
    if geom.is_empty:
        return geom
    
    # orient(geom, sign=1.0) ensures the exterior ring is counter-clockwise
    return orient(geom, sign=1.0)

def main():
    gdf = gpd.read_file("tokyo_buildings_legacy.geojson")
    print(f"Loaded {len(gdf)} features.")
    
    print("Fixing orientations...")
    # Use a lambda to avoid issues with apply on GeoSeries if possible, 
    # but gdf.geometry.apply should work if we use the correct import.
    gdf.geometry = gdf.geometry.apply(fix_orientation)
    
    # Check if the fix worked by checking validity again
    print(f"Post-fix valid count: {gdf.geometry.is_valid.sum()}")
    
    # Ensure the file is saved with the correct driver and format
    gdf.to_file("tokyo_buildings_fixed.geojson", driver="GeoJSON")
    print("Saved to tokyo_buildings_fixed.geojson")

if __name__ == "__main__":
    main()

import geopandas as gpd
import json

def verify_geojson_structure(file_path):
    with open(file_path, 'r') as f:
        data = json.load(f)
    
    print(f"File: {file_path}")
    print(f"Type: {data.get('type')}")
    print(f"Number of features: {len(data.get('features', []))}")
    
    # Check a sample feature to see if it's a Polygon and has rings
    if len(data['features']) > 0:
        sample_feat = data['features'][0]
        geom = sample_feat['geometry']
        print(f"Sample geometry type: {geom['type']}")
        if geom['type'] == 'Polygon':
            num_rings = len(geom['coordinates'])
            print(f"Sample number of rings: {num_rings}")
            
            # Verify orientation of the first ring (exterior)
            # For CCW in a standard Cartesian system (y-up), the signed area should be positive
            # (Wait, Shapely's orient(sign=1.0) makes it CCW)
            # Let's check the signed area calculation
            coords = geom['coordinates'][0]
            area = 0
            for i in range(len(coords)):
                x1, y1 = coords[i]
                x2, y2 = coords[(i + 1) % len(coords)]
                area += (x1 * y2 - x2 * y1)
            # For CCW in GeoJSON (y-up), area should be positive
            print(f"Sample exterior ring signed area: {area}")
            if area > 0:
                print("Sample exterior ring is CCW (Correct)")
            else:
                print("Sample exterior ring is CW (Incorrect)")

if __name__ == "__main__":
    verify_geojson_structure("tokyo_buildings_fixed.geojson")

import geopandas as gpd
import json

def verify_geojson_structure(file_path):
    with open(file_path, 'r') as f:
        data = json.load(f)
    
    print(f"File: {file_path}")
    print(f"Type: {data.get('type')}")
    print(f"Number of features: {len(data.get('features', []))}")
    
    # Check if all features have the same attributes as the original
    with open("tokyo_buildings_legacy.geojson", 'r') as f:
        legacy_data = json.load(f)
    
    legacy_features = legacy_data['features']
    new_features = data['features']
    
    print(f"Legacy features count: {len(legacy_features)}")
    
    # Check attributes of the first feature
    if len(legacy_features) > 0 and len(new_features) > 0:
        legacy_props = legacy_features[0]['properties']
        new_props = new_features[0]['properties']
        print(f"Legacy properties: {legacy_props}")
        print(f"New properties: {new_props}")
        if legacy_props == new_props:
            print("Attributes match for the first feature.")
        else:
            print("Attributes DO NOT match for the first feature!")

    # Check if all feature_ids are preserved
    legacy_ids = [f['properties'].get('feature_id') for f in legacy_features]
    new_ids = [f['properties'].get('feature_id') for f in new_features]
    
    if sorted(legacy_ids) == sorted(new_ids):
        print("All feature_ids are preserved.")
    else:
        print("feature_ids are NOT all preserved!")

if __name__ == "__main__":
    verify_geojson_structure("tokyo_buildings_fixed.geojson")