voxcity 0.6.9__tar.gz → 0.6.11__tar.gz

{voxcity-0.6.9 → voxcity-0.6.11}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.9"
+version = "0.6.11"
 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.9 → voxcity-0.6.11}/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.9 → voxcity-0.6.11}/src/voxcity/generator.py

@@ -710,6 +710,7 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
     # This is useful when the area of interest is part of a larger urban area
     remove_perimeter_object = kwargs.get("remove_perimeter_object")
     if (remove_perimeter_object is not None) and (remove_perimeter_object > 0):
+        print("apply perimeter removal")
         # Calculate perimeter width based on grid dimensions
         w_peri = int(remove_perimeter_object * building_height_grid.shape[0] + 0.5)
         h_peri = int(remove_perimeter_object * building_height_grid.shape[1] + 0.5)
@@ -730,6 +731,31 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
             building_height_grid[positions] = 0
             building_min_height_grid[positions] = [[] for _ in range(len(building_min_height_grid[positions]))]
 
+        # Visualize grids after optional perimeter removal
+        grid_vis = kwargs.get("gridvis", True)
+        if grid_vis:
+            # Building height grid visualization (zeros hidden)
+            building_height_grid_nan = building_height_grid.copy()
+            building_height_grid_nan[building_height_grid_nan == 0] = np.nan
+            visualize_numerical_grid(
+                np.flipud(building_height_grid_nan),
+                meshsize,
+                "building height (m)",
+                cmap='viridis',
+                label='Value'
+            )
+
+            # Canopy height grid visualization (zeros hidden)
+            canopy_height_grid_nan = canopy_height_grid.copy()
+            canopy_height_grid_nan[canopy_height_grid_nan == 0] = np.nan
+            visualize_numerical_grid(
+                np.flipud(canopy_height_grid_nan),
+                meshsize,
+                "Tree canopy height (m)",
+                cmap='Greens',
+                label='Tree canopy height (m)'
+            )
+
     # STEP 5: Generate optional 2D visualizations on interactive maps
     mapvis = kwargs.get("mapvis")
     if mapvis:
@@ -926,6 +952,7 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
     # Remove objects near perimeter if specified
     remove_perimeter_object = kwargs.get("remove_perimeter_object")
     if (remove_perimeter_object is not None) and (remove_perimeter_object > 0):
+        print("apply perimeter removal")
         # Calculate perimeter width based on grid dimensions
         w_peri = int(remove_perimeter_object * building_height_grid.shape[0] + 0.5)
         h_peri = int(remove_perimeter_object * building_height_grid.shape[1] + 0.5)
@@ -944,7 +971,32 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
         for remove_id in remove_ids:
             positions = np.where(building_id_grid == remove_id)
             building_height_grid[positions] = 0
-            building_min_height_grid[positions] = [[] for _ in range(len(building_min_height_grid[positions]))]    
+            building_min_height_grid[positions] = [[] for _ in range(len(building_min_height_grid[positions]))] 
+
+        # Visualize grids after optional perimeter removal
+        grid_vis = kwargs.get("gridvis", True)
+        if grid_vis:
+            # Building height grid visualization (zeros hidden)
+            building_height_grid_nan = building_height_grid.copy()
+            building_height_grid_nan[building_height_grid_nan == 0] = np.nan
+            visualize_numerical_grid(
+                np.flipud(building_height_grid_nan),
+                meshsize,
+                "building height (m)",
+                cmap='viridis',
+                label='Value'
+            )
+
+            # Canopy height grid visualization (zeros hidden)
+            canopy_height_grid_nan = canopy_height_grid.copy()
+            canopy_height_grid_nan[canopy_height_grid_nan == 0] = np.nan
+            visualize_numerical_grid(
+                np.flipud(canopy_height_grid_nan),
+                meshsize,
+                "Tree canopy height (m)",
+                cmap='Greens',
+                label='Tree canopy height (m)'
+            )
 
     # Generate 3D voxel grid
     voxcity_grid = create_3d_voxel(building_height_grid, building_min_height_grid, building_id_grid, land_cover_grid, dem_grid, canopy_height_grid, meshsize, land_cover_source)