dc-l1-tokyo-ring-orientation

Status: done
Score: 1.000
Duration: 0:50
Cost: 0.46¢
Model: deepseek/deepseek-v4-flash

Map (reference ← swipe → agent)

0:00
tokyo_buildings_legacy.geojson is a footprint export from an old in-house tool. When we load it into web-based GeoJSON viewers, building interiors are shaded incorrectly: holes appear filled and exteriors render as empty space. Our tile-server import script also rejects every feature with geometry warnings. Fix the geometries so that standard GeoJSON web viewers render them correctly. Attributes must be untouched. Output to tokyo_buildings_fixed.geojson. Every feature must remain a Polygon with interior rings and holes preserved exactly as they are; do not flatten them. feature_id is the join key.
0:00
System info 
{
  "adapter": "openrouter",
  "model": "deepseek/deepseek-v4-flash",
  "base_url": "https://openrouter.ai/api/v1"
}
0:02 
Let me start by reading the input file to understand its structure and geometry issues.
0:02
Read /work/tokyo_buildings_legacy.geojson 
     1	{
     2	  "type": "FeatureCollection",
     3	  "name": "tokyo_buildings_legacy",
     4	  "crs": {
     5	    "type": "name",
     6	    "properties": {
     7	      "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
     8	    }
     9	  },
    10	  "features": [
    11	    {
    12	      "type": "Feature",
    13	      "geometry": {
    14	        "type": "Polygon",
    15	        "coordinates": [
    16	          [
    17	            [
    18	              139.7029081,
    19	              35.6592372
    20	            ],
    21	            [
    22	              139.7027971,
    23	              35.659202
    24	            ],
    25	            [
    26	              139.7027755,
    27	              35.6592471
    28	            ],
    29	            [
    30	              139.7028864,
    31	              35.6592823
    32	            ],
    33	            [
    34	              139.7029081,
    35	              35.6592372
    36	            ]
    37	          ]
    38	        ]
    39	      },
    40	      "properties": {
    41	        "feature_id": 1,
    42	        "overture_id": "01302ced-3141-4b64-b630-98019352a9fd",
    43	        "name_primary": "渋谷協和ビル",
    44	        "building_class": "",
    45	        "height": null
    46	      }
    47	    },
    48	    {
    49	      "type": "Feature",
    50	      "geometry": {
    51	        "type": "Polygon",
    52	        "coordinates": [
    53	          [
    54	            [
    55	              139.7010896,
    56	              35.6601981
    57	            ],
    58	            [
    59	              139.7010851,
    60	              35.660084
    61	            ],
    62	            [
    63	              139.7010559,
    64	              35.660088
    65	            ],
    66	            [
    67	              139.7010511,
    68	              35.6600707
    69	            ],
    70	            [
    71	              139.7009769,
    72	              35.6600834
    73	            ],
    74	            [
    75	              139.7009923,
    76	              35.6601243
    77	            ],
    78	            [
    79	              139.7009007,
    80	              35.6601417
<system-reminder>Showed lines 1-80 of 4430. Re-call Read with offset=81 to continue, or raise limit.</system-reminder>
0:02
Bash wc -l /work/tokyo_buildings_legacy.geojson 
4430 /work/tokyo_buildings_legacy.geojson
0:02
Bash head -c 2000 /work/tokyo_buildings_legacy.geojson 
{
  "type": "FeatureCollection",
  "name": "tokyo_buildings_legacy",
  "crs": {
    "type": "name",
    "properties": {
      "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
    }
  },
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [
              139.7029081,
              35.6592372
            ],
            [
              139.7027971,
              35.659202
            ],
            [
              139.7027755,
              35.6592471
            ],
            [
              139.7028864,
              35.6592823
            ],
            [
              139.7029081,
              35.6592372
            ]
          ]
        ]
      },
      "properties": {
        "feature_id": 1,
        "overture_id": "01302ced-3141-4b64-b630-98019352a9fd",
        "name_primary": "渋谷協和ビル",
        "building_class": "",
        "height": null
      }
    },
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [
              139.7010896,
              35.6601981
            ],
            [
              139.7010851,
              35.660084
            ],
            [
              139.7010559,
              35.660088
            ],
            [
              139.7010511,
              35.6600707
            ],
            [
              139.7009769,
              35.6600834
            ],
            [
              139.7009923,
              35.6601243
            ],
            [
              139.7009007,
              35.6601417
            ],
            [
              139.7009195,
              35.6602237
            ],
            [
              139.7010896,
              35.6601981
            ]
          ]
        ]
      },
      "properties": {
        "feature_id": 2,
        "overture_id": "046ab130-a9a2-4a0e-9142-b7ea36374fdb",
        "name_primary": "丸大ビル",
        "bui
0:06 
Let me read more of the file to see if there are features with holes (multiple rings in a polygon).
0:06
Bash cd /work && python3 -c " 
cd /work && python3 -c "
import json
with open('tokyo_buildings_legacy.geojson') as f:
    data = json.load(f)
print('Number of features:', len(data['features']))

hole_count = 0
multi_count = 0
single_count = 0
for feat in data['features']:
    geom = feat['geometry']
    if geom['type'] == 'Polygon':
        rings = geom['coordinates']
        if len(rings) > 1:
            hole_count += 1
        elif len(rings) == 1:
            single_count += 1
    elif geom['type'] == 'MultiPolygon':
        multi_count += 1
        for poly in geom['coordinates']:
            if len(poly) > 1:
                hole_count += 1

print(f'Single-ring polygons: {single_count}')
print(f'Polygons with holes (interior rings): {hole_count}')
print(f'MultiPolygons: {multi_count}')

# Check orientation of polygons
from shapely.geometry import shape
from shapely.validation import explain_validity
import warnings
valid_count = 0
invalid_count = 0
for feat in data['features']:
    geom = shape(feat['geometry'])
    if geom.is_valid:
        valid_count += 1
    else:
        invalid_count += 1
        if invalid_count <= 5:
            print(f'Invalid feature {feat[\"properties\"][\"feature_id\"]}: {explain_validity(geom)}')
print(f'Valid: {valid_count}, Invalid: {invalid_count}')
"
Number of features: 100
Single-ring polygons: 95
Polygons with holes (interior rings): 5
MultiPolygons: 0
Valid: 100, Invalid: 0
0:13 
Interesting - the geometries are all valid according to Shapely. But the user reports that web-based GeoJSON viewers show interiors as filled and exteriors as empty. This classic symptom is caused by **incorrect ring orientation** in GeoJSON.

The GeoJSON specification (RFC 7946) requires:
- **Exterior rings** (the outer boundary) must be **counter-clockwise** (right-hand rule when looking from above)
- **Interior rings** (holes) must be **clockwise**

However, many older tools produce polygons where the exterior ring is clockwise and holes are counter-clockwise (the "left-hand rule" or opposite orientation). Some web viewers (like Mapbox GL, Leaflet, etc.) strictly follow the GeoJSON spec and will render such polygons incorrectly - filling what should be holes.

Let me check the orientations.
0:13
Bash cd /work && python3 -c " 
cd /work && python3 -c "
import json
from shapely.geometry import Polygon
from shapely.validation import explain_validity

with open('tokyo_buildings_legacy.geojson') as f:
    data = json.load(f)

def ring_orientation(coords):
    \"\"\"Return 'CW' if ring is clockwise, 'CCW' if counter-clockwise.\"\"\"
    # Shoelace formula - positive area means CCW in typical math convention,
    # but for GeoJSON (y=lat, x=lon) with [lon, lat] convention...
    # Actually GeoJSON uses [lon, lat] so the area sign:
    # Positive area = CCW (exterior should be CCW per RFC 7946)
    area = 0.0
    n = len(coords)
    for i in range(n - 1):
        x1, y1 = coords[i]
        x2, y2 = coords[i+1]
        area += (x2 - x1) * (y2 + y1)
    return 'CCW' if area > 0 else 'CW'

# Check polygon orientations
for feat in data['features']:
    geom = feat['geometry']
    props = feat['properties']
    fid = props['feature_id']
    if geom['type'] == 'Polygon':
        rings = geom['coordinates']
        ext_orient = ring_orientation(rings[0])
        orientations = [ext_orient]
        for ring in rings[1:]:
            orientations.append(ring_orientation(ring))
        
        # Per RFC 7946: exterior CCW, interior CW
        is_correct = (orientations[0] == 'CCW') and all(o == 'CW' for o in orientations[1:])
        
        if not is_correct:
            print(f'Feature {fid}: ext={orientations[0]}, holes={orientations[1:]}')
" 2>&1 | head -40
(no output)
0:21 
All polygons already have valid orientations according to RFC 7946 (exterior CCW, interior CW) and all are valid Shapely geometries. Let me dig deeper into the actual issue.

The user says "holes appear filled and exteriors render as empty space" and "tile-server import script also rejects every feature with geometry warnings."

Let me check with a stricter GeoJSON validation tool or check the winding order more carefully. Also let me look at the GeoJSON structure more closely - perhaps there's an issue with the coordinate ordering, or perhaps the issue is that some polygons' exterior rings are actually CW instead of CCW.

Wait - let me re-check the ring orientation function. The shoelace formula I used might be wrong for the GeoJSON coordinate convention (longitude, latitude).
0:21
Bash cd /work && python3 -c " 
cd /work && python3 -c "
import json
from shapely.geometry import shape
from shapely.validation import explain_validity

with open('tokyo_buildings_legacy.geojson') as f:
    data = json.load(f)

def ring_orientation(coords):
    \"\"\"Determine if ring is clockwise or counter-clockwise using shoelace.
    GeoJSON uses [lon, lat] which is (x, y). For lat/lon coordinates,
    positive signed area = CCW in the mathematical sense (counter-clockwise).
    RFC 7946: exterior=CCW, interior=CW
    \"\"\"
    area = 0.0
    n = len(coords)
    for i in range(n - 1):
        x1, y1 = coords[i]
        x2, y2 = coords[i+1]
        area += (x1 * y2 - x2 * y1)
    area /= 2.0
    return 'CCW' if area > 0 else 'CW'

bad_features = []
for feat in data['features']:
    geom = feat['geometry']
    props = feat['properties']
    fid = props['feature_id']
    if geom['type'] == 'Polygon':
        rings = geom['coordinates']
        ext_orient = ring_orientation(rings[0])
        hole_orients = [ring_orientation(r) for r in rings[1:]]
        
        correct = (ext_orient == 'CCW') and all(o == 'CW' for o in hole_orients)
        if not correct:
            bad_features.append((fid, ext_orient, hole_orients))

print(f'Features with wrong orientation: {len(bad_features)}')
for fid, ext_orient, hole_orients in bad_features:
    print(f'  Feature {fid}: exterior={ext_orient}, holes={hole_orients}')

# Also check all features more carefully with shapely's actual winding
print()
print('Checking with shapely.geometry.polygon.orient...')
from shapely.geometry.polygon import orient
for feat in data['features']:
    geom = feat['geometry']
    props = feat['properties']
    fid = props['feature_id']
    if geom['type'] == 'Polygon':
        rings = geom['coordinates']
        # Check if the polygon as-is has correct orientation
        p = shape(geom)
        oriented_p = orient(p, sign=1.0)  # CCW exterior
        # If orientation changed, it was wrong
        orig_ext = rings[0]
        new_ext = list(oriented_p.exterior.coords)
        if orig_ext != new_ext and len(orig_ext) == len(new_ext):
            print(f'Feature {fid}: exterior orientation was WRONG (CW instead of CCW)')
        # Check holes
        for i, hole in enumerate(p.interiors):
            orig_hole = rings[i+1]
            new_hole_coords = list(hole.coords)
            if orig_hole != new_hole_coords and len(orig_hole) == len(new_hole_coords):
                print(f'Feature {fid}: hole {i} orientation was WRONG')
" 2>&1
Features with wrong orientation: 100
  Feature 1: exterior=CW, holes=[]
  Feature 2: exterior=CW, holes=[]
  Feature 3: exterior=CW, holes=[]
  Feature 4: exterior=CW, holes=[]
  Feature 5: exterior=CW, holes=[]
  Feature 6: exterior=CW, holes=['CCW']
  Feature 7: exterior=CW, holes=[]
  Feature 8: exterior=CW, holes=[]
  Feature 9: exterior=CW, holes=[]
  Feature 10: exterior=CW, holes=[]
  Feature 11: exterior=CW, holes=[]
  Feature 12: exterior=CW, holes=[]
  Feature 13: exterior=CW, holes=[]
  Feature 14: exterior=CW, holes=[]
  Feature 15: exterior=CW, holes=[]
  Feature 16: exterior=CW, holes=[]
  Feature 17: exterior=CW, holes=[]
  Feature 18: exterior=CW, holes=['CCW']
  Feature 19: exterior=CW, holes=[]
  Feature 20: exterior=CW, holes=[]
  Feature 21: exterior=CW, holes=[]
  Feature 22: exterior=CW, holes=[]
  Feature 23: exterior=CW, holes=[]
  Feature 24: exterior=CW, holes=[]
  Feature 25: exterior=CW, holes=[]
  Feature 26: exterior=CW, holes=[]
  Feature 27: exterior=CW, holes=[]
  Feature 28: exterior=CW, holes=[]
  Feature 29: exterior=CW, holes=[]
  Feature 30: exterior=CW, holes=[]
  Feature 31: exterior=CW, holes=[]
  Feature 32: exterior=CW, holes=['CCW']
  Feature 33: exterior=CW, holes=[]
  Feature 34: exterior=CW, holes=[]
  Feature 35: exterior=CW, holes=[]
  Feature 36: exterior=CW, holes=[]
  Feature 37: exterior=CW, holes=[]
  Feature 38: exterior=CW, holes=[]
  Feature 39: exterior=CW, holes=[]
  Feature 40: exterior=CW, holes=[]
  Feature 41: exterior=CW, holes=[]
  Feature 42: exterior=CW, holes=[]
  Feature 43: exterior=CW, holes=[]
  Feature 44: exterior=CW, holes=[]
  Feature 45: exterior=CW, holes=[]
  Feature 46: exterior=CW, holes=[]
  Feature 47: exterior=CW, holes=[]
  Feature 48: exterior=CW, holes=[]
  Feature 49: exterior=CW, holes=[]
  Feature 50: exterior=CW, holes=['CCW']
  Feature 51: exterior=CW, holes=[]
  Feature 52: exterior=CW, holes=[]
  Feature 53: exterior=CW, holes=[]
  Feature 54: exterior=CW, holes=[]
  Feature 55: exterior=CW, holes=[]
  Feature 56: exterior=CW, holes=[]
  Feature 57: exterior=CW, holes=[]
  Feature 58: exterior=CW, holes=[]
  Feature 59: exterior=CW, holes=[]
  Feature 60: exterior=CW, holes=[]
  Feature 61: exterior=CW, holes=[]
  Feature 62: exterior=CW, holes=[]
  Feature 63: exterior=CW, holes=[]
  Feature 64: exterior=CW, holes=[]
  Feature 65: exterior=CW, holes=[]
  Feature 66: exterior=CW, holes=[]
  Feature 67: exterior=CW, holes=[]
  Feature 68: exterior=CW, holes=[]
  Feature 69: exterior=CW, holes=[]
  Feature 70: exterior=CW, holes=[]
  Feature 71: exterior=CW, holes=[]
  Feature 72: exterior=CW, holes=[]
  Feature 73: exterior=CW, holes=[]
  Feature 74: exterior=CW, holes=['CCW']
  Feature 75: exterior=CW, holes=[]
  Feature 76: exterior=CW, holes=[]
  Feature 77: exterior=CW, holes=[]
  Feature 78: exterior=CW, holes=[]
  Feature 79: exterior=CW, holes=[]
  Feature 80: exterior=CW, holes=[]
  Feature 81: exterior=CW, holes=[]
  Feature 82: exterior=CW, holes=[]
  Feature 83: exterior=CW, holes=[]
  Feature 84: exterior=CW, holes=[]
  Feature 85: exterior=CW, holes=[]
  Feature 86: exterior=CW, holes=[]
  Feature 87: exterior=CW, holes=[]
  Feature 88: exterior=CW, holes=[]
  Feature 89: exterior=CW, holes=[]
  Feature 90: exterior=CW, holes=[]
  Feature 91: exterior=CW, holes=[]
  Feature 92: exterior=CW, holes=[]
  Feature 93: exterior=CW, holes=[]
  Feature 94: exterior=CW, holes=[]
  Feature 95: exterior=CW, holes=[]
  Feature 96: exterior=CW, holes=[]
  Feature 97: exterior=CW, holes=[]
  Feature 98: exterior=CW, holes=[]
  Feature 99: exterior=CW, holes=[]
  Feature 100: exterior=CW, holes=[]

Checking with shapely.geometry.polygon.orient...
Feature 1: exterior orientation was WRONG (CW instead of CCW)
Feature 2: exterior orientation was WRONG (CW instead of CCW)
Feature 3: exterior orientation was WRONG (CW instead of CCW)
Feature 4: exterior orientation was WRONG (CW instead of CCW)
Feature 5: exterior orientation was WRONG (CW instead of CCW)
Feature 6: exterior orientation was WRONG (CW instead of CCW)
Feature 6: hole 0 orientation was WRONG
Feature 7: exterior orientation was WRONG (CW instead of CCW)
Feature 8: exterior orientation was WRONG (CW instead of CCW)
Feature 9: exterior orientation was WRONG (CW instead of CCW)
Feature 10: exterior orientation was WRONG (CW instead of CCW)
Feature 11: exterior orientation was WRONG (CW instead of CCW)
Feature 12: exterior orientation was WRONG (CW instead of CCW)
Feature 13: exterior orientation was WRONG (CW instead of CCW)
Feature 14: exterior orientation was WRONG (CW instead of CCW)
Feature 15: exterior orientation was WRONG (CW instead of CCW)
Feature 16: exterior orientation was WRONG (CW instead of CCW)
Feature 17: exterior orientation was WRONG (CW instead of CCW)
Feature 18: exterior orientation was WRONG (CW instead of CCW)
Feature 18: hole 0 orientation was WRONG
Feature 19: exterior orientation was WRONG (CW instead of CCW)
Feature 20: exterior orientation was WRONG (CW instead of CCW)
Feature 21: exterior orientation was WRONG (CW instead of CCW)
Feature 22: exterior orientation was WRONG (CW instead of CCW)
Feature 23: exterior orientation was WRONG (CW instead of CCW)
Feature 24: exterior orientation was WRONG (CW instead of CCW)
Feature 25: exterior orientation was WRONG (CW instead of CCW)
Feature 26: exterior orientation was WRONG (CW instead of CCW)
Feature 27: exterior orientation was WRONG (CW instead of CCW)
Feature 28: exterior orientation was WRONG (CW instead of CCW)
Feature 29: exterior orientation was WRONG (CW instead of CCW)
Feature 30: exterior orientation was WRONG (CW instead of CCW)
Feature 31: exterior orientation was WRONG (CW instead of CCW)
Feature 32: exterior orientation was WRONG (CW instead of CCW)
Feature 32: hole 0 orientation was WRONG
Feature 33: exterior orientation was WRONG (CW instead of CCW)
Feature 34: exterior orientation was WRONG (CW instead of CCW)
Feature 35: exterior orientation was WRONG (CW instead of CCW)
Feature 36: exterior orientation was WRONG (CW instead of CCW)
Feature 37: exterior orientation was WRONG (CW instead of CCW)
Feature 38: exterior orientation was WRONG (CW instead of CCW)
Feature 39: exterior orientation was WRONG (CW instead of CCW)
Feature 40: exterior orientation was WRONG (CW instead of CCW)
Feature 41: exterior orientation was WRONG (CW instead of CCW)
Feature 42: exterior orientation was WRONG (CW instead of CCW)
Feature 43: exterior orientation was WRONG (CW instead of CCW)
Feature 44: exterior orientation was WRONG (CW instead of CCW)
Feature 45: exterior orientation was WRONG (CW instead of CCW)
Feature 46: exterior orientation was WRONG (CW instead of CCW)
Feature 47: exterior orientation was WRONG (CW instead of CCW)
Feature 48: exterior orientation was WRONG (CW instead of CCW)
Feature 49: exterior orientation was WRONG (CW instead of CCW)
Feature 50: exterior orientation was WRONG (CW instead of CCW)
Feature 50: hole 0 orientation was WRONG
Feature 51: exterior orientation was WRONG (CW instead of CCW)
Feature 52: exterior orientation was WRONG (CW instead of CCW)
Feature 53: exterior orientation was WRONG (CW instead of CCW)
Feature 54: exterior orientation was WRONG (CW instead of CCW)
Feature 55: exterior orientation was WRONG (CW instead of CCW)
Feature 56: exterior orientation was WRONG (CW instead of CCW)
Feature 57: exterior orientation was WRONG (CW instead of CCW)
Feature 58: exterior orientation was WRONG (CW instead of CCW)
Feature 59: exterior orientation was WRONG (CW instead of CCW)
Feature 60: exterior orientation was WRONG (CW instead of CCW)
Feature 61: exterior orientation was WRONG (CW instead of CCW)
Feature 62: exterior orientation was WRONG (CW instead of CCW)
Feature 63: exterior orientation was WRONG (CW instead of CCW)
Feature 64: exterior orientation was WRONG (CW instead of CCW)
Feature 65: exterior orientation was WRONG (CW instead of CCW)
Feature 66: exterior orientation was WRONG (CW instead of CCW)
Feature 67: exterior orientation was WRONG (CW instead of CCW)
Feature 68: exterior orientation was WRONG (CW instead of CCW)
Feature 69: exterior orientation was WRONG (CW instead of CCW)
Feature 70: exterior orientation was WRONG (CW instead of CCW)
Feature 71: exterior orientation was WRONG (CW instead of CCW)
Feature 72: exterior orientation was WRONG (CW instead of CCW)
Feature 73: exterior orientation was WRONG (CW instead of CCW)
Feature 74: exterior orientation was WRONG (CW instead of CCW)
Feature 74: hole 0 orientation was WRONG
Feature 75: exterior orientation was WRONG (CW instead of CCW)
Feature 76: exterior orientation was WRONG (CW instead of CCW)
Feature 77: exterior orientation was WRONG (CW instead of CCW)
Feature 78: exterior orientation was WRONG (CW instead of CCW)
Feature 79: exterior orientation was WRONG (CW instead of CCW)
Feature 80: exterior orientation was WRONG (CW instead of CCW)
Feature 81: exterior orientation was WRONG (CW instead of CCW)
Feature 82: exterior orientation was WRONG (CW instead of CCW)
Feature 83: exterior orientation was WRONG (CW instead of CCW)
Feature 84: exterior orientation was WRONG (CW instead of CCW)
Feature 85: exterior orientation was WRONG (CW instead of CCW)
Feature 86: exterior orientation was WRONG (CW instead of CCW)
Feature 87: exterior orientation was WRONG (CW instead of CCW)
Feature 88: exterior orientation was WRONG (CW instead of CCW)
Feature 89: exterior orientation was WRONG (CW instead of CCW)
Feature 90: exterior orientation was WRONG (CW instead of CCW)
Feature 91: exterior orientation was WRONG (CW instead of CCW)
Feature 92: exterior orientation was WRONG (CW instead of CCW)
Feature 93: exterior orientation was WRONG (CW instead of CCW)
Feature 94: exterior orientation was WRONG (CW instead of CCW)
Feature 95: exterior orientation was WRONG (CW instead of CCW)
Feature 96: exterior orientation was WRONG (CW instead of CCW)
Feature 97: exterior orientation was WRONG (CW instead of CCW)
Feature 98: exterior orientation was WRONG (CW instead of CCW)
Feature 99: exterior orientation was WRONG (CW instead of CCW)
Feature 100: exterior orientation was WRONG (CW instead of CCW)
0:30 
Now I understand the problem. All 100 features have their exterior rings oriented clockwise (CW) instead of counter-clockwise (CCW), and the 5 features with holes have their interior rings oriented CCW instead of CW. This violates the GeoJSON RFC 7946 specification which requires:

- Exterior rings: counter-clockwise (CCW)
- Interior rings (holes): clockwise (CW)

The "old in-house tool" likely used the opposite convention (or no convention), which causes GeoJSON viewers to render the interiors as filled (they interpret the CW exterior as a hole and the CCW holes as exteriors).

The fix is simple: reverse the ring orientation so that exteriors become CCW and interiors become CW. I'll use `shapely.geometry.polygon.orient` to do this correctly, or manually reverse coordinates.

Let me write the fix script.
0:30
0:30
Write /work/solve.py
content · 108 lines · py 
#!/usr/bin/env python3
"""
Fix polygon ring orientation in tokyo_buildings_legacy.geojson.

GeoJSON RFC 7946 requires:
  - Exterior rings: counter-clockwise (CCW)
  - Interior rings (holes): clockwise (CW)

The legacy file has all rings reversed. We reverse each ring individually
without flattening holes — every Polygon retains its exact ring count.
"""

import json

INPUT = "/work/tokyo_buildings_legacy.geojson"
OUTPUT = "/work/tokyo_buildings_fixed.geojson"

with open(INPUT, "r", encoding="utf-8") as f:
    data = json.load(f)


def signed_area(coords):
    """Shoelace signed area (positive = CCW, negative = CW) for [lon, lat]."""
    area = 0.0
    n = len(coords)
    for i in range(n - 1):
        x1, y1 = coords[i]
        x2, y2 = coords[i + 1]
        area += (x1 * y2 - x2 * y1)
    return area / 2.0


def fix_ring_orientation(ring, want_ccw=True):
    """Reverse the ring if its orientation is opposite to what is wanted."""
    area = signed_area(ring)
    is_ccw = area > 0
    if want_ccw != is_ccw:
        return list(reversed(ring))
    return ring


fixes_applied = 0
for feat in data["features"]:
    geom = feat["geometry"]
    if geom["type"] != "Polygon":
        continue  # skip any non-Polygon geometries (there are none in this file)

    rings = geom["coordinates"]
    # Exterior ring (index 0) must be CCW
    fixed_ext = fix_ring_orientation(rings[0], want_ccw=True)
    fixed_holes = []
    for hole in rings[1:]:
        # Interior rings (holes) must be CW
        fixed_holes.append(fix_ring_orientation(hole, want_ccw=False))

    new_rings = [fixed_ext] + fixed_holes
    if new_rings != rings:
        fixes_applied += 1
        geom["coordinates"] = new_rings

# Write output (compact but readable JSON, same style as input)
with open(OUTPUT, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

print(f"Fixed {fixes_applied} features with incorrect ring orientation.")
print(f"Output written to {OUTPUT}")

# --- Verification ---
with open(OUTPUT, "r") as f:
    verified = json.load(f)

hole_count = 0
for feat in verified["features"]:
    rings = feat["geometry"]["coordinates"]
    if len(rings) > 1:
        hole_count += 1

errors = []
for feat in verified["features"]:
    geom = feat["geometry"]
    rings = geom["coordinates"]
    if geom["type"] == "Polygon":
        ext_ccw = signed_area(rings[0]) > 0
        if not ext_ccw:
            errors.append(f"  Feature {feat['properties']['feature_id']}: exterior still CW")
        for i, hole in enumerate(rings[1:]):
            hole_cw = signed_area(hole) < 0
            if not hole_cw:
                errors.append(f"  Feature {feat['properties']['feature_id']}: hole {i} still CCW")

if errors:
    print("VERIFICATION FAILED — remaining orientation errors:")
    for e in errors:
        print(e)
else:
    print("VERIFICATION PASSED — all exteriors are CCW, all holes are CW.")

# Confirm feature count and ring structure preserved
orig_ids = [f["properties"]["feature_id"] for f in data["features"]]
out_ids = [f["properties"]["feature_id"] for f in verified["features"]]
assert orig_ids == out_ids, "Feature order or IDs changed!"

# Check no keys removed
for orig, out in zip(data["features"], verified["features"]):
    assert orig["properties"] == out["properties"], (
        f"Properties changed for feature {orig['properties']['feature_id']}"
    )
print("VERIFICATION PASSED — attributes untouched, all features preserved.")
Wrote /work/solve.py (3476 chars).
0:32 
Let me run the script now.
0:32
Bash cd /work && python solve.py 
Fixed 100 features with incorrect ring orientation.
Output written to /work/tokyo_buildings_fixed.geojson
VERIFICATION PASSED — all exteriors are CCW, all holes are CW.
VERIFICATION PASSED — attributes untouched, all features preserved.
0:38 
All 100 features were fixed. Let me do a final sanity check on the output - verify that holes are preserved and the file looks correct.
0:38
Bash cd /work && python3 -c " 
cd /work && python3 -c "
import json

with open('tokyo_buildings_fixed.geojson') as f:
    data = json.load(f)

print('Feature count:', len(data['features']))
print('Type:', data['type'])
print()

# Count features with holes
hole_count = 0
for feat in data['features']:
    rings = feat['geometry']['coordinates']
    if len(rings) > 1:
        hole_count += 1
        fid = feat['properties']['feature_id']
        print(f'  Feature {fid}: {len(rings)} rings ({len(rings)-1} hole(s))')

print(f'Total features with holes: {hole_count}')

# Verify geometries are valid per shapely
from shapely.geometry import shape
from shapely.validation import explain_validity
invalid = []
for feat in data['features']:
    g = shape(feat['geometry'])
    if not g.is_valid:
        invalid.append((feat['properties']['feature_id'], explain_validity(g)))
if invalid:
    print('INVALID geometries:', invalid)
else:
    print('All 100 geometries are valid.')

# Check first feature geometry orientation
print()
print('First feature exterior ring (first 3 points):')
print(data['features'][0]['geometry']['coordinates'][0][:3])
print('Last point:', data['features'][0]['geometry']['coordinates'][0][-1])
"
Feature count: 100
Type: FeatureCollection

  Feature 6: 2 rings (1 hole(s))
  Feature 18: 2 rings (1 hole(s))
  Feature 32: 2 rings (1 hole(s))
  Feature 50: 2 rings (1 hole(s))
  Feature 74: 2 rings (1 hole(s))
Total features with holes: 5
All 100 geometries are valid.

First feature exterior ring (first 3 points):
[[139.7029081, 35.6592372], [139.7028864, 35.6592823], [139.7027755, 35.6592471]]
Last point: [139.7029081, 35.6592372]
0:38
Bash wc -l /work/tokyo_buildings_fixed.geojson 
4429 /work/tokyo_buildings_fixed.geojson
0:42 
Everything checks out. Let me also do a quick visual sanity check comparing the old vs new ring order for the first feature.
0:42
0:42
Bash cd /work && python3 -c " 
cd /work && python3 -c "
import json

with open('tokyo_buildings_legacy.geojson') as f:
    old = json.load(f)
with open('tokyo_buildings_fixed.geojson') as f:
    new = json.load(f)

# Compare feature 6 (first one with a hole)
f_old = old['features'][5]  # feature_id=6
f_new = new['features'][5]

print('Feature 6 old rings:', len(f_old['geometry']['coordinates']))
print('Feature 6 new rings:', len(f_new['geometry']['coordinates']))

# Old exterior ring was CW, new should be reversed = CCW
old_ext = f_old['geometry']['coordinates'][0]
new_ext = f_new['geometry']['coordinates'][0]
print('Old ext (first 3 pts):', old_ext[:3])
print('New ext (first 3 pts):', new_ext[:3])
print('Old ext reversed equals new ext?', list(reversed(old_ext)) == new_ext)

# Old hole ring was CCW, new should be reversed = CW  
old_hole = f_old['geometry']['coordinates'][1]
new_hole = f_new['geometry']['coordinates'][1]
print('Old hole reversed equals new hole?', list(reversed(old_hole)) == new_hole)

# Verify attributes identical
for old_feat, new_feat in zip(old['features'], new['features']):
    assert old_feat['properties'] == new_feat['properties'], f'Mismatch at {old_feat[\"properties\"][\"feature_id\"]}'
print('All properties match exactly.')
"
Feature 6 old rings: 2
Feature 6 new rings: 2
Old ext (first 3 pts): [[139.7025726, 35.661211], [139.7025732, 35.6612697], [139.7027844, 35.6612685]]
New ext (first 3 pts): [[139.7025726, 35.661211], [139.7024485, 35.6612117], [139.7024481, 35.6611726]]
Old ext reversed equals new ext? True
Old hole reversed equals new hole? True
All properties match exactly.
0:44 
Everything checks out:

1. All 100 features had their ring orientation fixed (exteriors now CCW, holes now CW).
2. All 5 features with holes preserved their interior rings (no flattening).
3. All geometries are valid.
4. All attributes (properties) are untouched.
5. Feature IDs preserved.

Let me verify the output file exists.
0:44
0:44
Bash ls -la /work/tokyo_buildings_fixed.geojson 
-rw-r--r-- 1 agent agent 91049 Jun 16 05:30 /work/tokyo_buildings_fixed.geojson
0:49 
Everything looks good. Let me summarize what was done.
0:49