voxcity 0.6.16__tar.gz → 0.6.17__tar.gz

{voxcity-0.6.16 → voxcity-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: voxcity
-Version: 0.6.16
+Version: 0.6.17
 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.16 → voxcity-0.6.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.16"
+version = "0.6.17"
 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.16 → voxcity-0.6.17}/src/voxcity/downloader/osm.py

@@ -370,7 +370,7 @@ def create_rings_from_ways(way_ids, ways, nodes):
     
     return rings
 
-def load_gdf_from_openstreetmap(rectangle_vertices):
+def load_gdf_from_openstreetmap(rectangle_vertices, floor_height=3.0):
     """Download and process building footprint data from OpenStreetMap.
     
     This function:
@@ -471,7 +471,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         """
         return [coord for coord in geometry]  # Keep original order since already (lon, lat)
     
-    def get_height_from_properties(properties):
+    def get_height_from_properties(properties, floor_height=3.0):
         """Helper function to extract height from properties.
         
         Args:
@@ -487,9 +487,25 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
             except ValueError:
                 pass
         
+        # Infer from floors when available
+        floors_candidates = [
+            properties.get('building:levels'),
+            properties.get('levels'),
+            properties.get('num_floors')
+        ]
+        for floors in floors_candidates:
+            if floors is None:
+                continue
+            try:
+                floors_val = float(floors)
+                if floors_val > 0:
+                    return float(floor_height) * floors_val
+            except ValueError:
+                continue
+        
         return 0  # Default height if no valid height found
     
-    def extract_properties(element):
+    def extract_properties(element, floor_height=3.0):
         """Helper function to extract and process properties from an element.
         
         Args:
@@ -501,7 +517,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         properties = element.get('tags', {})
         
         # Get height (now using the helper function)
-        height = get_height_from_properties(properties)
+        height = get_height_from_properties(properties, floor_height=floor_height)
             
         # Get min_height and min_level
         min_height = properties.get('min_height', '0')
@@ -526,7 +542,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
             "is_inner": False,
             "levels": levels,
             "height_source": "explicit" if properties.get('height') or properties.get('building:height') 
-                               else "levels" if levels is not None 
+                               else "levels" if (levels is not None) or (properties.get('num_floors') is not None)
                                else "default",
             "min_level": min_level if min_level != '0' else None,
             "building": properties.get('building', 'no'),
@@ -584,13 +600,13 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         if element['type'] == 'way':
             if 'geometry' in element:
                 coords = [(node['lon'], node['lat']) for node in element['geometry']]
-                properties = extract_properties(element)
+                properties = extract_properties(element, floor_height=floor_height)
                 feature = create_polygon_feature(coords, properties)
                 if feature:
                     features.append(feature)
                     
         elif element['type'] == 'relation':
-            properties = extract_properties(element)
+            properties = extract_properties(element, floor_height=floor_height)
             
             # Process each member of the relation
             for member in element['members']:

{voxcity-0.6.16 → voxcity-0.6.17}/src/voxcity/downloader/overture.py

@@ -254,7 +254,7 @@ def join_gdfs_vertically(gdf1, gdf2):
     
     return combined_gdf
 
-def load_gdf_from_overture(rectangle_vertices):
+def load_gdf_from_overture(rectangle_vertices, floor_height=3.0):
     """
     Download and process building footprint data from Overture Maps.
     
@@ -287,6 +287,31 @@ def load_gdf_from_overture(rectangle_vertices):
     # Combine both datasets into a single comprehensive building dataset
     joined_building_gdf = join_gdfs_vertically(building_gdf, building_part_gdf)
 
+    # Ensure numeric height and infer from floors when missing
+    try:
+        joined_building_gdf['height'] = pd.to_numeric(joined_building_gdf.get('height', None), errors='coerce')
+    except Exception:
+        # Create height column if missing
+        joined_building_gdf['height'] = None
+        joined_building_gdf['height'] = pd.to_numeric(joined_building_gdf['height'], errors='coerce')
+
+    # Combine possible floors columns (first non-null among candidates)
+    floors_candidates = []
+    for col in ['building:levels', 'levels', 'num_floors', 'floors']:
+        if col in joined_building_gdf.columns:
+            floors_candidates.append(pd.to_numeric(joined_building_gdf[col], errors='coerce'))
+    if floors_candidates:
+        floors_series = floors_candidates[0]
+        for s in floors_candidates[1:]:
+            floors_series = floors_series.combine_first(s)
+        # Infer height where height is NaN/<=0 and floors > 0
+        mask_missing_height = (~joined_building_gdf['height'].notna()) | (joined_building_gdf['height'] <= 0)
+        if isinstance(floor_height, (int, float)):
+            inferred = floors_series * float(floor_height)
+        else:
+            inferred = floors_series * 3.0
+        joined_building_gdf.loc[mask_missing_height & (floors_series > 0), 'height'] = inferred
+
     # Assign sequential IDs based on the final dataset index
     joined_building_gdf['id'] = joined_building_gdf.index
 

{voxcity-0.6.16 → voxcity-0.6.17}/src/voxcity/generator.py

@@ -226,12 +226,14 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
     else:
         # Fetch building data from primary source
         # Each source has different data formats and processing requirements
+        # Floor height (m) for inferring heights from floors/levels
+        floor_height = kwargs.get("floor_height", 3.0)
         if source == 'Microsoft Building Footprints':
             # Machine learning-derived building footprints from satellite imagery
             gdf = get_mbfp_gdf(output_dir, rectangle_vertices)
         elif source == 'OpenStreetMap':
             # Crowd-sourced building data with varying completeness
-            gdf = load_gdf_from_openstreetmap(rectangle_vertices)
+            gdf = load_gdf_from_openstreetmap(rectangle_vertices, floor_height=floor_height)
         elif source == "Open Building 2.5D Temporal":
             # Special case: this source provides both footprints and heights
             # Skip GeoDataFrame processing and create grids directly
@@ -244,7 +246,7 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
         #     gdf = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
         elif source == "Overture":
             # Open building dataset from Overture Maps Foundation
-            gdf = load_gdf_from_overture(rectangle_vertices)
+            gdf = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
         elif source == "Local file":
             # Handle user-provided local building data files
             _, extension = os.path.splitext(kwargs["building_path"])
@@ -285,13 +287,13 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
             if building_complementary_source == 'Microsoft Building Footprints':
                 gdf_comp = get_mbfp_gdf(output_dir, rectangle_vertices)
             elif building_complementary_source == 'OpenStreetMap':
-                gdf_comp = load_gdf_from_openstreetmap(rectangle_vertices)
+                gdf_comp = load_gdf_from_openstreetmap(rectangle_vertices, floor_height=floor_height)
             elif building_complementary_source == 'EUBUCCO v0.1':
                 gdf_comp = load_gdf_from_eubucco(rectangle_vertices, output_dir)
             # elif building_complementary_source == "OpenMapTiles":
             #     gdf_comp = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
             elif building_complementary_source == "Overture":
-                gdf_comp = load_gdf_from_overture(rectangle_vertices)
+                gdf_comp = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
             elif building_complementary_source == "Local file":
                 _, extension = os.path.splitext(kwargs["building_complementary_path"])
                 if extension == ".gpkg":
@@ -715,7 +717,12 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
         # Create uniform canopy height for all tree-covered areas (top grid)
         canopy_height_grid = np.zeros_like(land_cover_grid, dtype=float)
         static_tree_height = kwargs.get("static_tree_height", 10.0)
-        tree_mask = (land_cover_grid == 4)
+        # Determine tree class indices based on source-specific class names
+        _classes = get_land_cover_classes(land_cover_source)
+        _class_to_int = {name: i for i, name in enumerate(_classes.values())}
+        _tree_labels = ["Tree", "Trees", "Tree Canopy"]
+        _tree_indices = [_class_to_int[label] for label in _tree_labels if label in _class_to_int]
+        tree_mask = np.isin(land_cover_grid, _tree_indices) if _tree_indices else np.zeros_like(land_cover_grid, dtype=bool)
         canopy_height_grid[tree_mask] = static_tree_height
 
         # Derive bottom from trunk_height_ratio
@@ -917,11 +924,79 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
     # get all required gdfs    
     building_gdf, terrain_gdf, vegetation_gdf = load_buid_dem_veg_from_citygml(url=url_citygml, citygml_path=citygml_path, base_dir=output_dir, rectangle_vertices=rectangle_vertices)
 
+    # Normalize CRS to WGS84 (EPSG:4326) to ensure consistent operations downstream
+    try:
+        import geopandas as gpd  # noqa: F401
+        if building_gdf is not None:
+            if building_gdf.crs is None:
+                building_gdf = building_gdf.set_crs(epsg=4326)
+            elif getattr(building_gdf.crs, 'to_epsg', lambda: None)() != 4326 and building_gdf.crs != "EPSG:4326":
+                building_gdf = building_gdf.to_crs(epsg=4326)
+        if terrain_gdf is not None:
+            if terrain_gdf.crs is None:
+                terrain_gdf = terrain_gdf.set_crs(epsg=4326)
+            elif getattr(terrain_gdf.crs, 'to_epsg', lambda: None)() != 4326 and terrain_gdf.crs != "EPSG:4326":
+                terrain_gdf = terrain_gdf.to_crs(epsg=4326)
+        if vegetation_gdf is not None:
+            if vegetation_gdf.crs is None:
+                vegetation_gdf = vegetation_gdf.set_crs(epsg=4326)
+            elif getattr(vegetation_gdf.crs, 'to_epsg', lambda: None)() != 4326 and vegetation_gdf.crs != "EPSG:4326":
+                vegetation_gdf = vegetation_gdf.to_crs(epsg=4326)
+    except Exception:
+        pass
+
     land_cover_grid = get_land_cover_grid(rectangle_vertices, meshsize, land_cover_source, output_dir, **kwargs)        
 
     # building_height_grid, building_min_height_grid, building_id_grid, building_gdf = get_building_height_grid(rectangle_vertices, meshsize, building_source, output_dir, **kwargs)
     print("Creating building height grid")
-    # Filter kwargs to only those accepted by create_building_height_grid_from_gdf_polygon
+    # Prepare complementary building source if provided
+    building_complementary_source = kwargs.get("building_complementary_source")
+    gdf_comp = None
+    geotiff_path_comp = None
+    complement_building_footprints = kwargs.get("complement_building_footprints")
+    # Default to complement footprints when a complementary source is specified
+    if complement_building_footprints is None and (building_complementary_source not in (None, "None")):
+        complement_building_footprints = True
+
+    if (building_complementary_source is not None) and (building_complementary_source != "None"):
+        # Vector complementary sources
+        floor_height = kwargs.get("floor_height", 3.0)
+        if building_complementary_source == 'Microsoft Building Footprints':
+            gdf_comp = get_mbfp_gdf(kwargs.get("output_dir", "output"), rectangle_vertices)
+        elif building_complementary_source == 'OpenStreetMap':
+            gdf_comp = load_gdf_from_openstreetmap(rectangle_vertices, floor_height=floor_height)
+        elif building_complementary_source == 'EUBUCCO v0.1':
+            gdf_comp = load_gdf_from_eubucco(rectangle_vertices, kwargs.get("output_dir", "output"))
+        elif building_complementary_source == 'Overture':
+            gdf_comp = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
+        elif building_complementary_source == 'Local file':
+            comp_path = kwargs.get("building_complementary_path")
+            if comp_path is not None:
+                _, extension = os.path.splitext(comp_path)
+                if extension == ".gpkg":
+                    gdf_comp = get_gdf_from_gpkg(comp_path, rectangle_vertices)
+        # Ensure complementary GDF uses WGS84
+        if gdf_comp is not None:
+            try:
+                if gdf_comp.crs is None:
+                    gdf_comp = gdf_comp.set_crs(epsg=4326)
+                elif getattr(gdf_comp.crs, 'to_epsg', lambda: None)() != 4326 and gdf_comp.crs != "EPSG:4326":
+                    gdf_comp = gdf_comp.to_crs(epsg=4326)
+            except Exception:
+                pass
+        # Raster complementary sources (height only)
+        elif building_complementary_source == "Open Building 2.5D Temporal":
+            roi = get_roi(rectangle_vertices)
+            os.makedirs(kwargs.get("output_dir", "output"), exist_ok=True)
+            geotiff_path_comp = os.path.join(kwargs.get("output_dir", "output"), "building_height.tif")
+            save_geotiff_open_buildings_temporal(roi, geotiff_path_comp)
+        elif building_complementary_source in ["England 1m DSM - DTM", "Netherlands 0.5m DSM - DTM"]:
+            roi = get_roi(rectangle_vertices)
+            os.makedirs(kwargs.get("output_dir", "output"), exist_ok=True)
+            geotiff_path_comp = os.path.join(kwargs.get("output_dir", "output"), "building_height.tif")
+            save_geotiff_dsm_minus_dtm(roi, geotiff_path_comp, meshsize, building_complementary_source)
+
+    # Filter and assemble kwargs accepted by the grid function
     _allowed_building_kwargs = {
         "overlapping_footprint",
         "gdf_comp",
@@ -930,6 +1005,21 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
         "complement_height",
     }
     _building_kwargs = {k: v for k, v in kwargs.items() if k in _allowed_building_kwargs}
+    if gdf_comp is not None:
+        _building_kwargs["gdf_comp"] = gdf_comp
+    if geotiff_path_comp is not None:
+        _building_kwargs["geotiff_path_comp"] = geotiff_path_comp
+    if complement_building_footprints is not None:
+        _building_kwargs["complement_building_footprints"] = complement_building_footprints
+
+    # Map user-provided building_complement_height -> complement_height for grid builder
+    comp_height_user = kwargs.get("building_complement_height")
+    if comp_height_user is not None:
+        _building_kwargs["complement_height"] = comp_height_user
+    # If footprints are being complemented and no height provided, default to 10
+    if _building_kwargs.get("complement_building_footprints") and ("complement_height" not in _building_kwargs):
+        _building_kwargs["complement_height"] = 10.0
+
     building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(
         building_gdf, meshsize, rectangle_vertices, **_building_kwargs
     )
@@ -953,7 +1043,12 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
         
         # Set default static height for trees (20 meters is a typical average tree height)
         static_tree_height = kwargs.get("static_tree_height", 10.0)
-        tree_mask = (land_cover_grid == 4)
+        # Determine tree class indices based on source-specific class names
+        _classes = get_land_cover_classes(land_cover_source)
+        _class_to_int = {name: i for i, name in enumerate(_classes.values())}
+        _tree_labels = ["Tree", "Trees", "Tree Canopy"]
+        _tree_indices = [_class_to_int[label] for label in _tree_labels if label in _class_to_int]
+        tree_mask = np.isin(land_cover_grid, _tree_indices) if _tree_indices else np.zeros_like(land_cover_grid, dtype=bool)
         
         # Set static height for tree cells
         canopy_height_grid_comp[tree_mask] = static_tree_height