fio-l3-vienna-geofabrik-highways

Rerun

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from pyproj import CRS
import pandas as pd

class GürtelFilter(osmium.SimpleReader):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.highways = []
        self.pt_relations = []
        self.ways_cache = {}
        self.nodes_cache = {}

    def node(self, n):
        self.nodes_cache[n.id] = (n.location.lat, n.location.lon)

    def way(self, w):
        # We store way info to reconstruct later
        # However, OSM ways can be large, so let's be selective
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes_cache:
                lat, lon = self.nodes_cache[node_ref.ref]
                coords.append((lon, lat))
        
        if len(coords) >= 2:
            tags = {tag.k: tag.v for tag in w.tags}
            self.ways_cache[w.id] = {'coords': coords, 'tags': tags}
            
            # Check if it's a highway ending in Gürtel
            name = tags.get('name', '')
            if tags.get('highway') and name.endswith('Gürtel'):
                self.highways.append({
                    'id': w.id,
                    'geometry': LineString(coords),
                    'tags': tags
                })

    def relation(self, r):
        # For PT routes, we need to find the ways they contain
        # This is tricky in a single pass. 
        # Usually PT relations have members that are ways.
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        # Note: route type is often in 'route' tag.
        # We'll check for public transport presence.
        # In OSM, PT routes usually have a 'route' tag (bus, tram, etc.)
        route_type = tags.get('route')
        if route_type in pt_types:
            self.pt_relations.append({
                'id': r.id,
                'members': [m.ref for m in r.members if m.type == 'way'],
                'tags': tags
            })

# Because relations depend on ways, and ways depend on nodes, 
# and the file is large, we'll do this in a more robust way.
# 1. Extract all nodes (or enough to cover Vienna)
# 2. Extract all ways
# 3. Extract relations
# But wait, the file is ~1GB. A full pass to cache nodes is too much.

# Let's use a different approach.
# First, let's find the Gürtel ways by looking at their tags and names.
# Then calculate the buffer.
# Then find other highways and PT routes.

# Actually, I can use osmnx/osmium more effectively.
# Let's try to use osmium to get only the necessary parts.

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
import pandas as pd
import os

class GürtelExtractor(osmium.SimpleReader):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.guertel_ways = []
        self.all_ways = []
        self.pt_relations = []
        self.nodes = {}

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        name = tags.get('name', '')
        
        # Check if it's a highway and ends with 'Gürtel'
        if tags.get('highway') and name.endswith('Gürtel'):
            coords = []
            for node_ref in w.nodes:
                if node_ref.ref in self.nodes:
                    coords.append(self.nodes[node_ref.ref])
            if len(coords) >= 2:
                self.guertel_ways.append({
                    'id': w.id,
                    'geometry': LineString(coords),
                    'tags': tags
                })
        
        # For now, we'll keep track of all ways to build PT routes later
        # This is memory intensive. Let's optimize.
        # We only care about ways that might be part of PT routes or are highways.
        # But we don't know which ways are in PT routes until we see the relations.
        # However, most PT ways are also highways or at least have some tags.
        # To be safe, let's store all ways with a small footprint.
        
        # Let's store ONLY ways that are potentially relevant:
        # 1. All highways (for the highway layer)
        # 2. Ways that are part of PT relations (we'll find these later)
        
        # Optimization: Most PT routes are made of ways.
        # Let's just store all highway ways and all ways that could be part of PT.
        # Actually, let's store all ways but only their IDs and tags for now.
        # Wait, osmium's SimpleReader doesn't allow easy multi-pass without re-reading.
        pass

# Re-thinking:
# 1. Pass 1: Find all 'Gürtel' ways and their geometries.
# 2. Pass 2: Find all highways that intersect the buffer.
# 3. Pass 3: Find all PT relations and their way members, then their geometries.

# Since we can't easily do multiple passes in a single script without complexity, 
# let's use osmium to extract specific data.

def get_data():
    # Use osmium to extract ways and relations
    # For the buffer, we first need the Gürtel geometries.
    
    # Let's use a simpler approach: 
    # 1. Extract all ways that have a 'name' ending in 'Gürtel'.
    # 2. Calculate buffer.
    # 3. Extract all highways.
    # 4. Extract all PT relations.
    
    pass

if __name__ == "__main__":
    # This is a placeholder. I will rewrite the logic properly.
    pass

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
import pandas as pd
import os

class GürtelCollector(osmium.SimpleReader):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.guertel_geoms = []
        self.all_highways = []
        self.pt_relations_info = []
        self.nodes = {}
        self.ways_info = {} # id -> (coords, tags)
        self.way_ids = set()

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            self.ways_info[w.id] = (coords, tags)
            
            # Check if highway
            if tags.get('highway'):
                self.all_highways.append({
                    'id': w.id,
                    'geometry': LineString(coords),
                    'tags': tags
                })
                
                # Check if Gürtel
                name = tags.get('name', '')
                if name.endswith('Gürtel'):
                    self.guertel_geoms.append(LineString(coords))

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_info.append({
                'id': r.id,
                'tags': tags,
                'way_refs': [m.ref for m in r.members if m.type == 'way']
            })

# The memory issue is real. Let's try a more targeted approach.
# We can use osmium's handler to do it in a way that doesn't store everything.
# But we need nodes to build geometries.
# Let's use a two-pass approach with osmium.

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
import pandas as pd

def solve():
    osm_file = 'austria-latest.osm.pbf'

    # Pass 1: Find all Gürtel ways and their geometries.
    # To get geometries, we need nodes.
    # Since we only need Gürtel ways, we can use osmium to find them first.
    
    class GürtelFinder(osmium.SimpleReader):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.guertel_geoms = []
            self.nodes = {}

        def node(self, n):
            self.nodes[n.id] = (n.location.lon, n.location.lat)

        def way(self, w):
            tags = {tag.k: tag.v for tag in w.tags}
            name = tags.get('name', '')
            if tags.get('highway') and name.endswith('Gürtel'):
                coords = []
                for node_ref in w.nodes:
                    if node_ref.ref in self.nodes:
                        coords.append(self.nodes[node_ref.ref])
                if len(coords) >= 2:
                    self.guertel_geoms.append(LineString(coords))

    # Actually, we can't get all nodes in one pass easily if we don't know which ones we need.
    # BUT, we can read the whole file once to get all nodes. 
    # For 1GB PBF, it might take a while but it's the most reliable way.
    # However, we only need nodes that belong to ways.
    
    # Let's use osmium's capability to get geometries more directly.
    # Actually, let's use the 'osmium' command line to extract what we need if possible.
    # Or just use a more efficient Python script.

    # Efficient approach:
    # 1. One pass to collect all nodes and all Gürtel way IDs.
    # 2. One pass to collect all highways and all PT relations.
    
    # Wait, we can do it in ONE pass if we store everything we need in a compact way.
    # We need:
    # - All nodes (to build geometries of anything)
    # - All ways (to build highway layer and PT routes)
    # - All relations (to identify PT routes)
    
    # Let's try to be smart.
    # We'll first find the Gürtel geometries.
    
    # Since I don't know the exact size of 'nodes' in memory, let's assume it fits.
    # Austria OSM is ~1GB, nodes might be 10-20 million. 
    # 20M * 2 * 8 bytes (float64) = 320 MB. This should fit in RAM.
    
    print("Starting Pass 1: Collecting nodes and Gürtel ways...")
    
    class Pass1(osmium.SimpleReader):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.nodes = {}
            self.guertel_geoms = []
            self.guertel_way_ids = set()

        def node(self, n):
            self.nodes[n.id] = (n.location.lon, n.location.lat)

        def way(self, w):
            tags = {tag.k: tag.v for tag in w.tags}
            name = tags.get('name', '')
            if tags.get('highway') and name.endswith('Gürtel'):
                self.guertel_way_ids.add(w.id)
                # We can't build the geometry yet because we don't have all nodes?
                # Actually, osmium reads nodes before ways if they are in the same block, 
                # but not necessarily. In PBF, nodes are often in a separate block.
                # So a single pass might work if we read all nodes first.

    # Let's use the fact that PBF files have nodes first.
    # But osmium.SimpleReader reads sequentially.

    # Actually, the most robust way to get geometries is to use osmium's 
    # built-in geometry support if possible, or just load nodes first.
    
    # Let's use a two-pass approach.
    # Pass 1: Read all nodes.
    # Pass 2: Read ways and relations, build geometries using nodes from Pass 1.

    print("Starting Pass 1: Collecting all nodes...")
    nodes = {}
    with osmium.SimpleReader(osm_file) as reader:
        for node in reader.nodes():
            nodes[node.id] = (node.location.lon, node.location.lat)
    
    print(f"Collected {len(nodes)} nodes.")

    print("Starting Pass 2: Collecting Gürtel ways, highways and PT relations...")
    guertel_geoms = []
    highways = []
    pt_relations_info = []

    with osmium.SimpleReader(osm_file) as reader:
        for way in reader.ways():
            tags = {tag.k: tag.v for tag in way.tags}
            
            # Geometry construction
            coords = []
            for node_ref in way.nodes:
                if node_ref.ref in nodes:
                    coords.append(nodes[node_ref.ref])
            
            if len(coords) >= 2:
                geom = LineString(coords)
                
                # 1. Check if it's a highway
                if tags.get('highway'):
                    highways.append({
                        'id': way.id,
                        'geometry': geom,
                        'name': tags.get('name'),
                        'highway': tags.get('highway'),
                        'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'),
                        'surface': tags.get('surface'),
                        'oneway': tags.get('oneway')
                    })
                    
                    # 2. Check if it's Gürtel
                    name = tags.get('name', '')
                    if name.endswith('Gürtel'):
                        guertel_geoms.append(geom)
                        
        for rel in reader.relations():
            tags = {tag.k: tag.v for tag in rel.tags}
            pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
            if tags.get('route') in pt_types:
                pt_relations_info.append({
                    'id': rel.id,
                    'way_refs': [m.ref for m in rel.members if m.type == 'way'],
                    'name': tags.get('name'),
                    'ref': tags.get('ref'),
                    'operator': tags.get('operator'),
                    'route': tags.get('route')
                })

    if not guertel_geoms:
        print("No Gürtel ways found!")
        return

    # Create buffer
    print("Creating Gürtel buffer...")
    # Merge all Gürtel ways into a single geometry for the buffer
    from shapely.ops import unary_union
    guertel_union = unary_union(guertel_geoms)
    
    # We need to use a projected CRS for a 500m buffer.
    # Austria's standard: EPSG:31256 (MGI / Austria GK East) or similar.
    # Let's use EPSG:3857 for buffering (meters) then transform to EPSG:31256.
    # Or just use a local CRS like EPSG:31256 directly.
    
    # Let's use EPSG:3857 for the buffer calculation to be safe.
    # First, convert guertel_union to GeoSeries
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    
    # Convert buffer back to 4326 for intersection
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways and PT routes...")
    # 1. Highways
    highways_gdf = gpd.GeoDataFrame(highways, crs="EPSG:4326")
    # Filter by intersection with buffer
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]
    
    # 2. PT Routes
    # For PT routes, we need to build the geometry from the way_refs
    # We have 'ways_info' from Pass 2? No, I didn't store it to save memory.
    # I should have stored all ways that are part of PT relations.
    # Let's refine Pass 2.

    # Let's re-do Pass 2 more carefully.
    pass

solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

def solve():
    osm_file = 'austria-latest.osm.pbf'

    print("Starting Pass 1: Collecting all nodes...")
    nodes = {}
    with osmium.SimpleReader(osm_file) as reader:
        for node in reader.nodes():
            nodes[node.id] = (node.location.lon, node.location.lat)
    print(f"Collected {len(nodes)} nodes.")

    print("Starting Pass 2: Collecting all highway ways and PT relation info...")
    guertel_geoms = []
    highways_data = []
    pt_relations_data = []
    
    # To build PT routes, we need a way to quickly look up way geometries.
    # We'll store all ways that are highways OR part of PT relations.
    # But we don't know which ways are part of PT relations until we see the relations.
    # So let's store ALL ways' geometries for now? That's too much.
    # Let's store all highway ways and all ways that might be part of PT.
    # Actually, let's store all ways in a dictionary with (coords, tags).
    # If it's too big, we'll rethink.
    ways_registry = {} # way_id -> (geometry, tags)

    with osmium.SimpleReader(osm_file) as reader:
        for way in reader.ways():
            tags = {tag.k: tag.v for tag in way.tags}
            coords = []
            for node_ref in way.nodes:
                if node_ref.ref in nodes:
                    coords.append(nodes[node_ref.ref])
            
            if len(coords) >= 2:
                geom = LineString(coords)
                ways_registry[way.id] = (geom, tags)
                
                # Check if it's a highway
                if tags.get('highway'):
                    # Highway data for the layer
                    h_data = {
                        'id': way.id,
                        'geometry': geom,
                        'name': tags.get('name'),
                        'highway': tags.get('highway'),
                        'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'),
                        'surface': tags.get('surface'),
                        'oneway': tags.get('oneway')
                    }
                    highways_data.append(h_data)
                    
                    # Check if it's Gürtel
                    name = tags.get('name', '')
                    if name.endswith('Gürtel'):
                        guertel_geoms.append(geom)
        
        for rel in reader.relations():
            tags = {tag.k: tag.v for tag in rel.tags}
            pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
            if tags.get('route') in pt_types:
                pt_relations_data.append({
                    'id': rel.id,
                    'way_refs': [m.ref for m in rel.members if m.type == 'way'],
                    'name': tags.get('name'),
                    'ref': tags.get('ref'),
                    'operator': tags.get('operator'),
                    'route': tags.get('route')
                })

    if not guertel_geoms:
        print("No Gürtel ways found!")
        return

    print("Creating Gürtel buffer...")
    guertel_union = unary_union(guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    # Use EPSG:3857 for buffer in meters
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(highways_data, crs="EPSG:4326")
    # Keep full attributes (name, highway, maxspeed, lanes, surface, oneway)
    # Filter by intersection with buffer
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]
    # Ensure LineString as requested (though LineString is default for ways)
    # highways_gdf['geometry'] = highways_gdf['geometry'].apply(lambda x: LineString(x.coords) if x.geom_type == 'LineString' else x)

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in pt_relations_data:
        # Build MultiLineString from way geometries
        way_geoms = []
        for w_ref in rel['way_refs']:
            if w_ref in ways_registry:
                way_geoms.append(ways_registry[w_ref][0])
        
        if way_geoms:
            # Combine way geometries into a single MultiLineString for the route
            # Note: A single route might be multiple disconnected lines, so MultiLineString is correct.
            # However, we can use unary_union to merge them if they touch, but MultiLineString is safer.
            from shapely.geometry import MultiLineString
            combined_geom = MultiLineString(way_geoms)
            
            # Check if the route intersects the buffer
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")

    print("Saving to GeoPackage...")
    # Final projection: Austria standard (EPSG:31256)
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    # Writing to vienna_network.gpkg
    # highways layer
    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    # pt_routes layer
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")

    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} # way_id -> (geometry, tags)

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            
            # Highway check
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                
                # Gürtel check
                name = tags.get('name', '')
                if name.endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    
    # First, collect all nodes
    print("Collecting nodes...")
    collector = GürtelCollector(osm_file)
    # We need to read nodes first. osmium handler doesn't easily allow 
    # just reading nodes in one pass and then ways in another if using SimpleHandler.
    # But we can manually iterate through the reader.
    
    import osmium
    nodes = {}
    with osmium.Reader(osm_file) as reader:
        # osmium.Reader is lower level. Let's use SimpleReader if it's available or
        # just use the SimpleHandler and it will call node() for every node.
        pass

    # Let's try this:
    collector = GürtelCollector()
    collector.apply_file(osm_file)
    # This will call node(), way(), relation() in order.
    # BUT, for way() to work, node() must have been called for all its nodes.
    # In OSM PBF, nodes are typically in a separate block at the beginning.
    # So applying the file with SimpleHandler SHOULD work as nodes are processed first.

    print("Starting file processing (this may take a while)...")
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print("Creating Gürtel buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    # Use EPSG:3857 for buffer in meters
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = []
        for w_ref in rel['way_refs']:
            if w_ref in collector.ways_registry:
                way_geoms.append(collector.ways_registry[w_ref][0])
        
        if way_geoms:
            from shapely.geometry import MultiLineString
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")

    print("Saving to GeoPackage...")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")

    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} # way_id -> (geometry, tags)

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            
            # Highway check
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                
                # Gürtel check
                name = tags.get('name', '')
                if name.endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    
    collector = GürtelCollector()

    print("Starting file processing (this may take a while)...")
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways.")
    print("Creating Gürtel buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    # Use EPSG:3857 for buffer in meters
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    # Use intersects to filter highways that cross the buffer
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = []
        for w_ref in rel['way_refs']:
            if w_ref in collector.ways_registry:
                way_geoms.append(collector.ways_registry[w_ref][0])
        
        if way_geoms:
            from shapely.geometry import MultiLineString
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")

    print("Saving to GeoPackage...")
    target_crs = "EPSG:31256" # Austria standard projected
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    # Write layers to the same GPKG
    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")

    print("Done! Files saved to vienna_network.gpkg")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

# Since the full file is too large for a single pass in the limited time, 
# and we only care about Vienna's Gürtel, we'll try to extract the bounding box 
# of Vienna first or just focus on the Gürtel names.

# However, the instructions say "pull every highway... that intersects a 500m buffer around Vienna's Gürtel".
# This implies we must find the Gürtel first.

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} 

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                if tags.get('name', '').endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    collector = GürtelCollector()
    
    print("Processing OSM file (this might take a few minutes)...")
    # To avoid timeout, we'll use a more efficient way to read if possible, 
    # but for now, let's hope it finishes. 
    # I will add a print to track progress.
    
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways. Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = [collector.ways_registry[w_ref][0] for w_ref in rel['way_refs'] if w_ref in collector.ways_registry]
        if way_geoms:
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium

class BBoxFinder(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.min_lat = 90
        self.max_lat = -90
        self.min_lon = 180
        self.max_lon = -180
        self.found = False

    def node(self, n):
        pass # not useful for bbox of ways directly

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        if tags.get('name', '').endswith('Gürtel'):
            self.found = True
            for node_ref in w.nodes:
                # We don't have the node location here in way(), 
                # so we must rely on the nodes being processed.
                # Actually, in SimpleHandler, nodes are processed before ways.
                pass

# Instead of this, let's just use a known BBox for Vienna/Gürtel area.
# Vienna is roughly: 16.3, 48.1 to 16.4, 48.3.
# Gürtel is around 16.35, 48.2.
# Let's try a smaller area.

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} 

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                if tags.get('name', '').endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    
    # Use a bounding box to drastically reduce the data.
    # Vienna Gürtel area: ~16.3-16.4 Lon, 48.1-48.3 Lat.
    # To be safe, let's use 16.2-16.5, 48.0-48.4.
    # This is a subset of Austria.
    
    print("Extracting subset for Vienna...")
    # We use osmium command line to extract a bounding box.
    # It's much faster and handles the PBF structure.
    # bbox: min_lon, min_lat, max_lon, max_lat
    import subprocess
    bbox = "16.2,48.0,16.5,48.4"
    subprocess.run(['osmium', 'extract', '-b', bbox, osm_file, '-o', 'vienna.osm.pbf'], check=True)
    
    collector = GürtelCollector()
    print("Processing vienna.osm.pbf...")
    collector.apply_file('vienna.osm.pbf')
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found in the subset!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways. Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = [collector.ways_registry[w_ref][0] for w_ref in rel['way_refs'] if w_ref in collector.ways_registry]
        if way_geoms:
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} 

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                if tags.get('name', '').endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    
    collector = GürtelCollector()

    print("Starting file processing (this may take a while)...")
    # Instead of osmium cli, we'll use the osmium python library's handler.
    # Since we can't extract a subset via cli, we'll just run it and hope for the best.
    # Or we can use a more efficient way to read only nodes first.
    
    # Let's try to read nodes separately to be faster.
    # But SimpleHandler.apply_file does everything.
    # We'll use the apply_file and increase timeout if needed.
    # Wait, I cannot increase the timeout of the task.
    
    # Let's optimize the way we store things.
    # Only store ways that are highways or part of a PT relation.
    # To know which are part of PT, we need to see relations first.
    # But relations are at the end.
    
    # Let's do it in two passes in Python.
    # Pass 1: Find all Gürtel ways and collect all nodes.
    # Pass 2: Find all highways and PT relations.
    
    # Actually, osmium.SimpleHandler.apply_file is one pass.
    # Let's just run it.
    
    try:
        collector.apply_file(osm_file)
    except Exception as e:
        print(f"Error during processing: {e}")
        return
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways. Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    buffer_geom_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_geom_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = []
        for w_ref in rel['way_refs']:
            if w_ref in collector.ways_registry:
                way_geoms.append(collector.ways_registry[w_ref][0])
        if way_geoms:
            from shapely.geometry import MultiLineString
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_geom_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

# Since the full Austria file is too large for the 120s limit, 
# I will use a trick: search for Gürtel in the PBF file by reading it in chunks 
# or using osmium's ability to find specific elements.
# Actually, the best way is to find the Gürtel ways first by searching for names.

class GürtelFinder(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.guertel_way_ids = []
        self.guertel_geoms = []

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        if tags.get('name', '').endswith('Gürtel'):
            self.guertel_way_ids.append(w.id)

# But we still need geometries.
# Let's try to use a more lightweight approach. 
# We'll look for the Gürtel ways and then their bounding box.
# Then we'll only process that part of the file.

# Given the constraints, I'll write a script that uses a very small subset 
# of the data (e.g., by scanning the file for the name and then only processing those).
# Actually, I'll try to process the file in a way that's as fast as possible.

class FastCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} 

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        # To save time, we only build geometry if it's a highway or likely part of PT
        if tags.get('highway') or any(t in tags.get('route', '') for t in ['bus', 'tram', 'subway']):
            coords = []
            for node_ref in w.nodes:
                if node_ref.ref in self.nodes:
                    coords.append(self.nodes[node_ref.ref])
            if len(coords) >= 2:
                geom = LineString(coords)
                self.ways_registry[w.id] = (geom, tags)
                if tags.get('highway'):
                    self.highways_data.append({
                        'id': w.id, 'geometry': geom, 'name': tags.get('name'),
                        'highway': tags.get('highway'), 'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'), 'surface': tags.get('surface'), 'oneway': tags.get('oneway')
                    })
                    if tags.get('name', '').endswith('Gürtel'):
                        self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id, 'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'), 'ref': tags.get('ref'),
                'operator': tags.get('operator'), 'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    collector = FastCollector()
    print("Processing...")
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    buffer_geom = gs_guertel.to_crs(epsg=3857).buffer(500).iloc[0]
    buffer_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_4326)]

    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = [collector.ways_registry[w_ref][0] for w_ref in rel['way_refs'] if w_ref in collector.ways_registry]
        if way_geoms:
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_4326):
                pt_routes_list.append({
                    'id': rel['id'], 'geometry': combined_geom, 'name': rel['name'],
                    'ref': rel['ref'], 'operator': rel['operator'], 'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

# We need to solve this without a timeout.
# The main problem is that the Austria PBF is too large for a single pass in 120s.
# However, I can use 'osmium' if I can find it, but it was not found.
# Wait, the prompt says "The common GIS libraries (geopandas, shapely, pyproj, duckdb, ...) are already installed."
# It doesn't explicitly say 'osmium' command line is there, but 'osmium' python library is.

# Let's try a different strategy:
# 1. Use DuckDB to query the PBF? DuckDB can read Parquet/GeoPackage, but OSM PBF requires a plugin.
# 2. Let's try to use a more efficient way to filter.
# Since I cannot use osmium command line, I will use osmium python.
# To beat the timeout, I'll search for the Gürtel ways first by just reading the ways and tags, 
# and I will NOT store all nodes in a dict. Instead, I will use the osmium handler's ability 
# to handle geometries if possible, or just accept that I have to find the Gürtel first.

# Actually, I can use osmium to only extract the ways we need.
# But the handler's apply_file is the only way.

# Let's try to make the collector even lighter.
# Instead of storing all nodes, we'll only store nodes that are part of a highway or PT relation.
# But we don't know which ones those are until we see the way/relation.

# Let's use a two-pass approach with a very small footprint.
# Pass 1: Find Gürtel way IDs and their bounding box.
# Pass 2: Find all highways and PT routes within that bounding box.

class BBoxFinder(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.guertel_way_ids = []
        self.bbox = None # (min_lon, min_lat, max_lon, max_lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        if tags.get('name', '').endswith('Gürtel'):
            self.guertel_way_ids.append(w.id)

# I'll try to do everything in one pass but be extremely careful with memory and time.
# I'll only store ways and nodes that are necessary.

class OptimizedCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {} # node_id -> (lon, lat)
        self.guertel_geoms = []
        self.highways = []
        self.pt_relations = []
        self.ways_registry = {} # way_id -> (geometry, tags)

    def node(self, n):
        # To save time, only store nodes if they might be part of a highway or PT.
        # But we don't know. Let's just store all of them but check the count.
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        if tags.get('highway') or any(t in tags.get('route', '') for t in ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']):
            coords = []
            for node_ref in w.nodes:
                if node_ref.ref in self.nodes:
                    coords.append(self.nodes[node_ref.ref])
            
            if len(coords) >= 2:
                geom = LineString(coords)
                self.ways_registry[w.id] = (geom, tags)
                if tags.get('highway'):
                    self.highways.append({
                        'id': w.id, 'geometry': geom, 'name': tags.get('name'),
                        'highway': tags.get('highway'), 'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'), 'surface': tags.get('surface'), 'oneway': tags.get('oneway')
                    })
                    if tags.get('name', '').endswith('Gürtel'):
                        self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations.append({
                'id': r.id, 'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'), 'ref': tags.get('ref'),
                'operator': tags.get('operator'), 'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    collector = OptimizedCollector()
    
    print("Running single pass...")
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel found.")
        return

    print("Processing results...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    buffer_4326 = gs_guertel.to_crs(epsg=3857).buffer(500).to_crs(epsg=4326).iloc[0]

    # Highways
    highways_gdf = gpd.GeoDataFrame(collector.highways, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_4326)]

    # PT Routes
    pt_routes_list = []
    for rel in collector.pt_relations:
        way_geoms = [collector.ways_registry[wr][0] for wr in rel['way_refs'] if wr in collector.ways_registry]
        if way_geoms:
            combined = MultiLineString(way_geoms)
            if combined.intersects(buffer_4326):
                pt_routes_list.append({
                    'id': rel['id'], 'geometry': combined, 'name': rel['name'],
                    'ref': rel['ref'], 'operator': rel['operator'], 'route': rel['route']
                })
    
    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    
    # Export
    target_crs = "EPSG:31256"
    highways_gdf.to_crs(target_crs).to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_crs(target_crs).to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done.")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

class GürtelCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} 

    def node(self, n):
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        coords = []
        for node_ref in w.nodes:
            if node_ref.ref in self.nodes:
                coords.append(self.nodes[node_ref.ref])
        
        if len(coords) >= 2:
            geom = LineString(coords)
            self.ways_registry[w.id] = (geom, tags)
            
            # Highway check
            if tags.get('highway'):
                h_data = {
                    'id': w.id,
                    'geometry': geom,
                    'name': tags.get('name'),
                    'highway': tags.get('highway'),
                    'maxspeed': tags.get('maxspeed'),
                    'lanes': tags.get('lanes'),
                    'surface': tags.get('surface'),
                    'oneway': tags.get('oneway')
                }
                self.highways_data.append(h_data)
                
                # Gürtel check
                name = tags.get('name', '')
                if name.endswith('Gürtel'):
                    self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id,
                'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'),
                'ref': tags.get('ref'),
                'operator': tags.get('operator'),
                'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    
    # Since I cannot avoid the timeout with the full file, 
    # and I cannot use osmium cli, I'll try a very optimized 
    # single pass that only stores what is absolutely necessary.
    # To save time, I'll only store nodes, highways, and PT relations.
    # I will also only store ways that are highways or part of PT relations.
    
    collector = GürtelCollector()
    print("Starting processing (this is likely to time out if the file is huge, but let's try)...")
    try:
        collector.apply_file(osm_file)
    except Exception as e:
        print(f"Error: {e}")
        return
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways.")
    print("Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    # Use EPSG:3857 for buffer calculation in meters
    gs_guertel_proj = gs_guertel.to_crs(epsg=3857)
    buffer_geom = gs_guertel_proj.buffer(500).iloc[0]
    # Back to 4326 for intersection
    buffer_4326 = gpd.GeoSeries([buffer_geom], crs=3857).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = []
        for w_ref in rel['way_refs']:
            if w_ref in collector.ways_registry:
                way_geoms.append(collector.ways_registry[w_ref][0])
        
        if way_geoms:
            combined_geom = MultiLineString(way_geoms)
            if combined_geom.intersects(buffer_4326):
                pt_routes_list.append({
                    'id': rel['id'],
                    'geometry': combined_geom,
                    'name': rel['name'],
                    'ref': rel['ref'],
                    'operator': rel['operator'],
                    'route': rel['route']
                })

    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")

    print("Saving to GeoPackage...")
    target_crs = "EPSG:31256" # Austria standard projected
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

# Given the strict 120s timeout and the large size of the Austria PBF, 
# the only way to complete this task is to avoid a full scan if possible.
# However, we must find "every highway" and "every PT route" intersecting the buffer.
# Since I cannot use osmium-cli to extract a subset, I will optimize the Python script.

# Optimization:
# 1. We'll do it in one pass.
# 2. We will only store ways that are highways or part of PT relations.
# 3. We'll only store nodes that are part of those ways.

class OptimizedCollector(osmium.SimpleHandler):
    def __init__(self):
        super().__init__()
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {} # way_id -> (geometry, tags)
        self.potential_pt_way_ids = set()

    def node(self, n):
        # We can't know if a node is needed yet. We have to store all nodes 
        # OR do multiple passes. Multiple passes with osmium is slow too.
        # Let's hope nodes fit in memory.
        self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        tags = {tag.k: tag.v for tag in w.tags}
        # Optimization: only process relevant ways
        if tags.get('highway') or any(t in tags.get('route', '') for t in ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']):
            coords = []
            for node_ref in w.nodes:
                if node_ref.ref in self.nodes:
                    coords.append(self.nodes[node_ref.ref])
            
            if len(coords) >= 2:
                geom = LineString(coords)
                self.ways_registry[w.id] = (geom, tags)
                
                if tags.get('highway'):
                    self.highways_data.append({
                        'id': w.id, 'geometry': geom, 'name': tags.get('name'),
                        'highway': tags.get('highway'), 'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'), 'surface': tags.get('surface'), 'oneway': tags.get('oneway')
                    })
                    if tags.get('name', '').endswith('Gürtel'):
                        self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id, 'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'), 'ref': tags.get('ref'),
                'operator': tags.get('operator'), 'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    collector = OptimizedCollector()
    
    print("Starting processing...")
    # To minimize time, we use the handler.
    try:
        collector.apply_file(osm_file)
    except Exception as e:
        print(f"Error: {e}")
        return
    
    if not collector.guertel_geoms:
        print("No Gürtel ways found!")
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways. Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    buffer_4326 = gs_guertel.to_crs(epsg=3857).buffer(500).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = [collector.ways_registry[wr][0] for wr in rel['way_refs'] if wr in collector.ways_registry]
        if way_geoms:
            combined = MultiLineString(way_geoms)
            if combined.intersects(buffer_4326):
                pt_routes_list.append({
                    'id': rel['id'], 'geometry': combined, 'name': rel['name'],
                    'ref': rel['ref'], 'operator': rel['operator'], 'route': rel['route']
                })
    
    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    
    print("Saving to GeoPackage...")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    # Ensuring proper geometry types for GPKG
    highways_gdf['geometry'] = highways_gdf['geometry'].apply(lambda x: LineString(x.coords) if x.geom_type == 'LineString' else x)
    pt_routes_gdf['geometry'] = pt_routes_gdf['geometry'].apply(lambda x: MultiLineString(x.geoms) if x.geom_type == 'MultiLineString' else x)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()

import osmium
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
from shapely.ops import unary_union
import pandas as pd

# Bounding box for Vienna (approximate)
# This will significantly speed up processing if we only care about Vienna.
# However, we need to extract it from the PBF. 
# Since we can't use osmium-cli, let's use a handler that filters by bbox.

class BBoxFilterHandler(osmium.SimpleHandler):
    def __init__(self, bbox):
        super().__init__()
        self.bbox = bbox # (min_lon, min_lat, max_lon, max_lat)
        self.nodes = {}
        self.guertel_geoms = []
        self.highways_data = []
        self.pt_relations_data = []
        self.ways_registry = {}

    def node(self, n):
        if self.bbox[0] <= n.location.lon <= self.bbox[2] and \
           self.bbox[1] <= n.location.lat <= self.bbox[3]:
            self.nodes[n.id] = (n.location.lon, n.location.lat)

    def way(self, w):
        # Check if way is within or intersects bbox (approximate by nodes)
        # For simplicity, we check if at least one node is in bbox
        # Or just check if the way's bounding box intersects.
        # But osmium doesn't give way bbox easily without nodes.
        
        tags = {tag.k: tag.v for tag in w.tags}
        if tags.get('highway') or any(t in tags.get('route', '') for t in ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']):
            coords = []
            for node_ref in w.nodes:
                if node_ref.ref in self.nodes:
                    coords.append(self.nodes[node_ref.ref])
            
            if len(coords) >= 2:
                geom = LineString(coords)
                self.ways_registry[w.id] = (geom, tags)
                
                if tags.get('highway'):
                    self.highways_data.append({
                        'id': w.id, 'geometry': geom, 'name': tags.get('name'),
                        'highway': tags.get('highway'), 'maxspeed': tags.get('maxspeed'),
                        'lanes': tags.get('lanes'), 'surface': tags.get('surface'), 'oneway': tags.get('oneway')
                    })
                    if tags.get('name', '').endswith('Gürtel'):
                        self.guertel_geoms.append(geom)

    def relation(self, r):
        tags = {tag.k: tag.v for tag in r.tags}
        pt_types = ['bus', 'tram', 'subway', 'train', 'trolleybus', 'light_rail']
        if tags.get('route') in pt_types:
            self.pt_relations_data.append({
                'id': r.id, 'way_refs': [m.ref for m in r.members if m.type == 'way'],
                'name': tags.get('name'), 'ref': tags.get('ref'),
                'operator': tags.get('operator'), 'route': tags.get('route')
            })

def solve():
    osm_file = 'austria-latest.osm.pbf'
    # Vienna BBox (with margin)
    vienna_bbox = (16.2, 48.1, 16.5, 48.3)
    
    collector = BBoxFilterHandler(vienna_bbox)
    print("Processing Vienna area...")
    collector.apply_file(osm_file)
    
    if not collector.guertel_geoms:
        print("No Gürtel found in the bbox. Trying a larger one...")
        # If fails, we might need to search the whole file, but let's hope this works.
        return

    print(f"Found {len(collector.guertel_geoms)} Gürtel ways. Creating buffer...")
    guertel_union = unary_union(collector.guertel_geoms)
    gs_guertel = gpd.GeoSeries([guertel_union], crs="EPSG:4326")
    buffer_4326 = gs_guertel.to_crs(epsg=3857).buffer(500).to_crs(epsg=4326).iloc[0]

    print("Filtering highways...")
    highways_gdf = gpd.GeoDataFrame(collector.highways_data, crs="EPSG:4326")
    highways_gdf = highways_gdf[highways_gdf.intersects(buffer_4326)]

    print("Filtering PT routes...")
    pt_routes_list = []
    for rel in collector.pt_relations_data:
        way_geoms = [collector.ways_registry[wr][0] for wr in rel['way_refs'] if wr in collector.ways_registry]
        if way_geoms:
            combined = MultiLineString(way_geoms)
            if combined.intersects(buffer_4326):
                pt_routes_list.append({
                    'id': rel['id'], 'geometry': combined, 'name': rel['name'],
                    'ref': rel['ref'], 'operator': rel['operator'], 'route': rel['route']
                })
    
    pt_routes_gdf = gpd.GeoDataFrame(pt_routes_list, crs="EPSG:4326")
    
    print("Saving to GeoPackage...")
    target_crs = "EPSG:31256"
    highways_gdf = highways_gdf.to_crs(target_crs)
    pt_routes_gdf = pt_routes_gdf.to_crs(target_crs)

    highways_gdf.to_file("vienna_network.gpkg", layer="highways", driver="GPKG")
    pt_routes_gdf.to_file("vienna_network.gpkg", layer="pt_routes", driver="GPKG")
    print("Done!")

if __name__ == "__main__":
    solve()