voxcity 0.6.10__tar.gz → 0.6.12__tar.gz

{voxcity-0.6.10 → voxcity-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: voxcity
-Version: 0.6.10
+Version: 0.6.12
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 License: MIT
 Author: Kunihiko Fujiwara

{voxcity-0.6.10 → voxcity-0.6.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.10"
+version = "0.6.12"
 description = "voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data"
 readme = "README.md"
 license = "MIT"

{voxcity-0.6.10 → voxcity-0.6.12}/src/voxcity/downloader/citygml.py

@@ -398,6 +398,43 @@ def extract_vegetation_info(file_path, namespaces):
     try:
         tree = ET.parse(file_path)
         root = tree.getroot()
+
+        # Build namespaces dynamically from the file and merge with provided ones
+        nsmap = root.nsmap or {}
+        # Fallbacks in case discovery fails
+        fallback_ns = {
+            'core': 'http://www.opengis.net/citygml/2.0',
+            'bldg': 'http://www.opengis.net/citygml/building/2.0',
+            'gml': 'http://www.opengis.net/gml',
+            'uro': 'https://www.geospatial.jp/iur/uro/3.0',
+            'dem': 'http://www.opengis.net/citygml/relief/2.0',
+            'veg': 'http://www.opengis.net/citygml/vegetation/2.0'
+        }
+
+        def pick_ns(prefix, keyword=None, fallback_key=None):
+            # Prefer provided namespaces if valid
+            if isinstance(namespaces, dict) and prefix in namespaces and namespaces[prefix]:
+                return namespaces[prefix]
+            # Then try from document nsmap
+            uri = nsmap.get(prefix)
+            if uri:
+                return uri
+            # Then try keyword search
+            if keyword:
+                for v in nsmap.values():
+                    if isinstance(v, str) and keyword in v:
+                        return v
+            # Finally fallback
+            return fallback_ns[fallback_key or prefix]
+
+        ns = {
+            'core': pick_ns('core', keyword='citygml', fallback_key='core'),
+            'bldg': pick_ns('bldg', keyword='building', fallback_key='bldg'),
+            'gml': pick_ns('gml', keyword='gml', fallback_key='gml'),
+            'uro': pick_ns('uro', keyword='iur/uro', fallback_key='uro'),
+            'dem': pick_ns('dem', keyword='relief', fallback_key='dem'),
+            'veg': pick_ns('veg', keyword='vegetation', fallback_key='veg')
+        }
     except Exception as e:
         print(f"Error parsing CityGML file {Path(file_path).name}: {e}")
         return vegetation_elements
@@ -405,8 +442,8 @@ def extract_vegetation_info(file_path, namespaces):
     # Helper: parse polygons in <gml:MultiSurface> or <veg:lodXMultiSurface>
     def parse_lod_multisurface(lod_elem):
         polygons = []
-        for poly_node in lod_elem.findall('.//gml:Polygon', namespaces):
-            ring_node = poly_node.find('.//gml:exterior//gml:LinearRing//gml:posList', namespaces)
+        for poly_node in lod_elem.findall('.//gml:Polygon', ns):
+            ring_node = poly_node.find('.//gml:exterior//gml:LinearRing//gml:posList', ns)
             if ring_node is None or ring_node.text is None:
                 continue
             coords_text = ring_node.text.strip().split()
@@ -442,25 +479,68 @@ def extract_vegetation_info(file_path, namespaces):
             "lod0MultiSurface", "lod1MultiSurface", "lod2MultiSurface", "lod3MultiSurface", "lod4MultiSurface"
         ]
         for lod_tag in geometry_lods:
-            lod_elem = veg_elem.find(f'.//veg:{lod_tag}', namespaces)
+            lod_elem = veg_elem.find(f'.//veg:{lod_tag}', ns)
             if lod_elem is not None:
                 geom = parse_lod_multisurface(lod_elem)
                 if geom is not None:
                     return geom
         return None
 
+    def compute_lod_height(veg_elem):
+        """
+        Fallback: compute vegetation height from Z values in any gml:posList
+        under the available LOD geometry elements. Returns (max_z - min_z)
+        if any Z values are found; otherwise None.
+        """
+        z_values = []
+        geometry_lods = [
+            "lod0Geometry", "lod1Geometry", "lod2Geometry", "lod3Geometry", "lod4Geometry",
+            "lod0MultiSurface", "lod1MultiSurface", "lod2MultiSurface", "lod3MultiSurface", "lod4MultiSurface"
+        ]
+        try:
+            for lod_tag in geometry_lods:
+                lod_elem = veg_elem.find(f'.//veg:{lod_tag}', ns)
+                if lod_elem is None:
+                    continue
+                for pos_list in lod_elem.findall('.//gml:posList', ns):
+                    if pos_list.text is None:
+                        continue
+                    coords_text = pos_list.text.strip().split()
+                    # Expect triplets (x,y,z) or (lat,lon,z). Z should be each 3rd value
+                    for i in range(2, len(coords_text), 3):
+                        try:
+                            z = float(coords_text[i])
+                            if not np.isinf(z) and not np.isnan(z):
+                                z_values.append(z)
+                        except Exception:
+                            continue
+            if z_values:
+                return float(max(z_values) - min(z_values))
+        except Exception:
+            pass
+        return None
+
     # 1) PlantCover
-    for plant_cover in root.findall('.//veg:PlantCover', namespaces):
+    for plant_cover in root.findall('.//veg:PlantCover', ns):
         cover_id = plant_cover.get('{http://www.opengis.net/gml}id')
-        avg_height_elem = plant_cover.find('.//veg:averageHeight', namespaces)
+        avg_height_elem = plant_cover.find('.//veg:averageHeight', ns)
         if avg_height_elem is not None and avg_height_elem.text:
             try:
                 vegetation_height = float(avg_height_elem.text)
+                # Treat sentinel values like -9999 as missing
+                if vegetation_height <= -9998:
+                    vegetation_height = None
             except:
                 vegetation_height = None
         else:
             vegetation_height = None
 
+        # Fallback to geometry-derived height if needed
+        if vegetation_height is None:
+            derived_h = compute_lod_height(plant_cover)
+            if derived_h is not None:
+                vegetation_height = derived_h
+
         geometry = get_veg_geometry(plant_cover)
         if geometry is not None and not geometry.is_empty:
             vegetation_elements.append({
@@ -472,17 +552,26 @@ def extract_vegetation_info(file_path, namespaces):
             })
 
     # 2) SolitaryVegetationObject
-    for solitary in root.findall('.//veg:SolitaryVegetationObject', namespaces):
+    for solitary in root.findall('.//veg:SolitaryVegetationObject', ns):
         veg_id = solitary.get('{http://www.opengis.net/gml}id')
-        height_elem = solitary.find('.//veg:height', namespaces)
+        height_elem = solitary.find('.//veg:height', ns)
         if height_elem is not None and height_elem.text:
             try:
                 veg_height = float(height_elem.text)
+                # Treat sentinel values like -9999 as missing
+                if veg_height <= -9998:
+                    veg_height = None
             except:
                 veg_height = None
         else:
             veg_height = None
 
+        # Fallback to geometry-derived height if attribute is missing/unparseable
+        if veg_height is None:
+            derived_h = compute_lod_height(solitary)
+            if derived_h is not None:
+                veg_height = derived_h
+
         geometry = get_veg_geometry(solitary)
         if geometry is not None and not geometry.is_empty:
             vegetation_elements.append({
@@ -577,7 +666,8 @@ def process_citygml_file(file_path):
     terrain_elements = []
     vegetation_elements = []
 
-    namespaces = {
+    # Default/fallback namespaces (used if not present in the file)
+    fallback_namespaces = {
         'core': 'http://www.opengis.net/citygml/2.0',
         'bldg': 'http://www.opengis.net/citygml/building/2.0',
         'gml': 'http://www.opengis.net/gml',
@@ -590,6 +680,32 @@ def process_citygml_file(file_path):
         tree = ET.parse(file_path)
         root = tree.getroot()
 
+        # Build namespaces dynamically from the file, falling back to defaults.
+        nsmap = root.nsmap or {}
+
+        def pick_ns(prefix, keyword=None, fallback_key=None):
+            # Try explicit prefix first
+            uri = nsmap.get(prefix)
+            if uri:
+                return uri
+            # Try to discover by keyword in URI (e.g., 'vegetation', 'building', 'relief')
+            if keyword:
+                for v in nsmap.values():
+                    if isinstance(v, str) and keyword in v:
+                        return v
+            # Fallback to defaults
+            return fallback_namespaces[fallback_key or prefix]
+
+        namespaces = {
+            'core': pick_ns('core', keyword='citygml', fallback_key='core'),
+            'bldg': pick_ns('bldg', keyword='building', fallback_key='bldg'),
+            'gml': pick_ns('gml', keyword='gml', fallback_key='gml'),
+            'uro': pick_ns('uro', keyword='iur/uro', fallback_key='uro'),
+            'dem': pick_ns('dem', keyword='relief', fallback_key='dem'),
+            # Accept CityGML 2.0 or 3.0 vegetation namespaces
+            'veg': pick_ns('veg', keyword='vegetation', fallback_key='veg')
+        }
+
         # Extract Buildings
         for building in root.findall('.//bldg:Building', namespaces):
             building_id = building.get('{http://www.opengis.net/gml}id')

{voxcity-0.6.10 → voxcity-0.6.12}/src/voxcity/downloader/osm.py

@@ -398,7 +398,12 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
     max_lat = max(v[1] for v in rectangle_vertices)
     
     # Enhanced Overpass API query with recursive member extraction
-    overpass_url = "http://overpass-api.de/api/interpreter"
+    # Try multiple Overpass endpoints to improve resiliency against rate limits or outages
+    overpass_endpoints = [
+        "https://overpass-api.de/api/interpreter",
+        "https://overpass.kumi.systems/api/interpreter",
+        "https://overpass.openstreetmap.ru/api/interpreter",
+    ]
     overpass_query = f"""
     [out:json];
     (
@@ -412,9 +417,40 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
     out geom;
     """
     
-    # Send the request to the Overpass API
-    response = requests.get(overpass_url, params={'data': overpass_query})
-    data = response.json()
+    # Send the request to the Overpass API with fallbacks and robust JSON handling
+    headers = {"User-Agent": "voxcity/ci (https://github.com/voxcity)"}
+    data = None
+    last_error = None
+    for overpass_url in overpass_endpoints:
+        try:
+            response = requests.get(overpass_url, params={"data": overpass_query}, headers=headers, timeout=30)
+            # Ensure HTTP OK
+            if response.status_code != 200:
+                last_error = Exception(f"HTTP {response.status_code} from {overpass_url}")
+                continue
+            # Some servers return HTML/plain text on rate-limit; guard JSON parsing
+            content_type = response.headers.get("Content-Type", "")
+            if "json" not in content_type.lower():
+                # Attempt JSON anyway; if fails, try next endpoint
+                try:
+                    data = response.json()
+                except Exception as e:
+                    last_error = e
+                    continue
+            else:
+                data = response.json()
+            # Validate structure
+            if not isinstance(data, dict) or "elements" not in data:
+                last_error = Exception(f"Malformed Overpass response from {overpass_url}")
+                data = None
+                continue
+            # Success
+            break
+        except Exception as e:
+            last_error = e
+            continue
+    if data is None:
+        raise RuntimeError(f"Failed to fetch OSM data from Overpass endpoints. Last error: {last_error}")
     
     # Build a mapping from (type, id) to element
     id_map = {}
@@ -932,14 +968,43 @@ def load_land_cover_gdf_from_osm(rectangle_vertices_ori):
         "out skel qt;"
     )
 
-    # Overpass API endpoint
-    overpass_url = "http://overpass-api.de/api/interpreter"
+    # Overpass API endpoints (fallbacks)
+    overpass_endpoints = [
+        "https://overpass-api.de/api/interpreter",
+        "https://overpass.kumi.systems/api/interpreter",
+        "https://overpass.openstreetmap.ru/api/interpreter",
+    ]
 
-    # Fetch data from Overpass API
+    # Fetch data from Overpass API with fallbacks and robust JSON handling
     print("Fetching data from Overpass API...")
-    response = requests.get(overpass_url, params={'data': query})
-    response.raise_for_status()
-    data = response.json()
+    headers = {"User-Agent": "voxcity/ci (https://github.com/voxcity)"}
+    data = None
+    last_error = None
+    for overpass_url in overpass_endpoints:
+        try:
+            response = requests.get(overpass_url, params={'data': query}, headers=headers, timeout=30)
+            if response.status_code != 200:
+                last_error = Exception(f"HTTP {response.status_code} from {overpass_url}")
+                continue
+            content_type = response.headers.get("Content-Type", "")
+            if "json" not in content_type.lower():
+                try:
+                    data = response.json()
+                except Exception as e:
+                    last_error = e
+                    continue
+            else:
+                data = response.json()
+            if not isinstance(data, dict) or 'elements' not in data:
+                last_error = Exception(f"Malformed Overpass response from {overpass_url}")
+                data = None
+                continue
+            break
+        except Exception as e:
+            last_error = e
+            continue
+    if data is None:
+        raise RuntimeError(f"Failed to fetch OSM data from Overpass endpoints. Last error: {last_error}")
 
     # Convert OSM data to GeoJSON format using our custom converter instead of json2geojson
     print("Converting data to GeoJSON format...")