voxcity 0.5.6__tar.gz → 0.5.9__tar.gz

{voxcity-0.5.6 → voxcity-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.5.6
+Version: 0.5.9
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 Author-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
 Maintainer-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
@@ -45,7 +45,7 @@ Requires-Dist: pycountry
 Requires-Dist: osm2geojson
 Requires-Dist: seaborn
 Requires-Dist: overturemaps
-Requires-Dist: protobuf<=3.20.3
+Requires-Dist: protobuf<6,>=4.21
 Requires-Dist: timezonefinder
 Requires-Dist: astral
 Requires-Dist: osmnx

{voxcity-0.5.6 → voxcity-0.5.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voxcity"
-version = "0.5.6"
+version = "0.5.9"
 requires-python = ">=3.10,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3.10",
@@ -47,7 +47,7 @@ dependencies = [
     "osm2geojson",
     "seaborn",
     "overturemaps",
-    "protobuf<=3.20.3",
+    "protobuf>=4.21,<6",
     "timezonefinder",
     "astral",
     "osmnx",
@@ -56,7 +56,6 @@ dependencies = [
     "pyvista",
     "IPython",
     "lxml"
-
 ]
 
 [project.optional-dependencies]

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity/downloader/citygml.py

@@ -11,30 +11,126 @@ from shapely.geometry import Polygon, Point, MultiPolygon
 import pandas as pd
 from tqdm import tqdm
 
+# --------------------------------------------------------------------
+# Script to get tile boundary from file name
+# --------------------------------------------------------------------
+import re
+from shapely.geometry import Polygon
+
+def decode_2nd_level_mesh(mesh6):
+    """
+    Given exactly 6 digits (string) for a standard (2nd-level) mesh code,
+    return (lat_sw, lon_sw, lat_ne, lon_ne) in degrees.
+    """
+    code = int(mesh6)
+    # Extract each piece
+    N1 = code // 10000              # first 2 digits
+    M1 = (code // 100) % 100        # next 2 digits
+    row_2nd = (code // 10) % 10     # 5th digit
+    col_2nd = code % 10             # 6th digit
+    
+    # 1st-level mesh "southwest" corner
+    lat_sw_1 = (N1 * 40.0) / 60.0    # each N1 => 40' => 2/3 degrees
+    lon_sw_1 = 100.0 + M1           # each M1 => offset from 100°E
+    
+    # 2nd-level mesh subdivides that 8×8 => each cell = 1/12° lat x 0.125° lon
+    dlat_2nd = (40.0 / 60.0) / 8.0   # 1/12°
+    dlon_2nd = 1.0 / 8.0            # 0.125°
+    
+    lat_sw = lat_sw_1 + row_2nd * dlat_2nd
+    lon_sw = lon_sw_1 + col_2nd * dlon_2nd
+    lat_ne = lat_sw + dlat_2nd
+    lon_ne = lon_sw + dlon_2nd
+    
+    return (lat_sw, lon_sw, lat_ne, lon_ne)
+
+def decode_mesh_code(mesh_str):
+    """
+    Handles:
+      - 6-digit codes (standard 2nd-level mesh),
+      - 8-digit codes (2nd-level subdivided 10×10).
+
+    Returns a list of (lon, lat) forming a *closed* bounding polygon in WGS84.
+    """
+    if len(mesh_str) < 6:
+        raise ValueError(f"Mesh code '{mesh_str}' is too short.")
+    
+    # Decode the first 6 digits as a 2nd-level mesh
+    mesh6 = mesh_str[:6]
+    lat_sw_2, lon_sw_2, lat_ne_2, lon_ne_2 = decode_2nd_level_mesh(mesh6)
+    
+    # If exactly 6 digits => full 2nd-level tile
+    if len(mesh_str) == 6:
+        return [
+            (lon_sw_2, lat_sw_2),
+            (lon_ne_2, lat_sw_2),
+            (lon_ne_2, lat_ne_2),
+            (lon_sw_2, lat_ne_2),
+            (lon_sw_2, lat_sw_2)
+        ]
+    
+    # If 8 digits => last 2 subdivide the tile 10×10
+    elif len(mesh_str) == 8:
+        row_10 = int(mesh_str[6])  # 7th digit
+        col_10 = int(mesh_str[7])  # 8th digit
+        
+        # Sub-tile size in lat/lon
+        dlat_10 = (lat_ne_2 - lat_sw_2) / 10.0
+        dlon_10 = (lon_ne_2 - lon_sw_2) / 10.0
+        
+        lat_sw = lat_sw_2 + row_10 * dlat_10
+        lon_sw = lon_sw_2 + col_10 * dlon_10
+        lat_ne = lat_sw + dlat_10
+        lon_ne = lon_sw + dlon_10
+        
+        return [
+            (lon_sw, lat_sw),
+            (lon_ne, lat_sw),
+            (lon_ne, lat_ne),
+            (lon_sw, lat_ne),
+            (lon_sw, lat_sw)
+        ]
+    
+    else:
+        raise ValueError(
+            f"Unsupported mesh code length '{mesh_str}'. "
+            "This script only handles 6-digit or 8-digit codes."
+        )
+
+def get_tile_polygon_from_filename(filename):
+    """
+    Extract the mesh code from a typical Project PLATEAU filename 
+    (e.g. '51357348_bldg_6697_op.gml') and decode it. 
+    Returns the bounding polygon in WGS84 as a list of (lon, lat).
+    """
+    # Look for leading digits until the first underscore
+    m = re.match(r'^(\d+)_', filename)
+    if not m:
+        # If no match, you can either raise an error or return None
+        raise ValueError(f"No leading digit code found in filename: {filename}")
+    
+    mesh_code = m.group(1)
+    return decode_mesh_code(mesh_code)
+
+# --------------------------------------------------------------------
+# Original script logic
+# --------------------------------------------------------------------
+
 def download_and_extract_zip(url, extract_to='.'):
     """
     Download and extract a zip file from a URL
     """
-    # Send a GET request to the URL
     response = requests.get(url)
-
-    # Check if the request was successful
     if response.status_code == 200:
-        # Extract the base name of the zip file from the URL
         parsed_url = urlparse(url)
         zip_filename = os.path.basename(parsed_url.path)
         folder_name = os.path.splitext(zip_filename)[0]  # Remove the .zip extension
 
-        # Create the extraction directory
         extraction_path = os.path.join(extract_to, folder_name)
         os.makedirs(extraction_path, exist_ok=True)
 
-        # Create a BytesIO object from the response content
         zip_file = io.BytesIO(response.content)
-
-        # Open the zip file
         with zipfile.ZipFile(zip_file) as z:
-            # Extract all the contents of the zip file to the specified directory
             z.extractall(extraction_path)
             print(f"Extracted to {extraction_path}")
     else:
@@ -55,7 +151,6 @@ def swap_coordinates(polygon):
     Swap coordinates in a polygon (lat/lon to lon/lat or vice versa)
     """
     if isinstance(polygon, MultiPolygon):
-        # Handle MultiPolygon objects
         new_polygons = []
         for geom in polygon.geoms:
             coords = list(geom.exterior.coords)
@@ -63,7 +158,6 @@ def swap_coordinates(polygon):
             new_polygons.append(Polygon(swapped_coords))
         return MultiPolygon(new_polygons)
     else:
-        # Handle regular Polygon objects
         coords = list(polygon.exterior.coords)
         swapped_coords = [(y, x) for x, y in coords]
         return Polygon(swapped_coords)
@@ -87,25 +181,20 @@ def extract_terrain_info(file_path, namespaces):
             for tin in relief.findall('.//dem:TINRelief', namespaces):
                 tin_id = tin.get('{http://www.opengis.net/gml}id')
 
-                # Extract triangulated surface
                 triangles = tin.findall('.//gml:Triangle', namespaces)
                 for i, triangle in enumerate(triangles):
-                    # Extract the coordinates of each triangle
                     pos_lists = triangle.findall('.//gml:posList', namespaces)
-
                     for pos_list in pos_lists:
                         try:
-                            # Process the coordinates
                             coords_text = pos_list.text.strip().split()
                             coords = []
                             elevations = []
 
-                            # Process coordinates in triplets (x, y, z)
                             for j in range(0, len(coords_text), 3):
                                 if j + 2 < len(coords_text):
                                     x = float(coords_text[j])
-                                    y = float(coords_text[j + 1])
-                                    z = float(coords_text[j + 2])  # Elevation
+                                    y = float(coords_text[j+1])
+                                    z = float(coords_text[j+2])
 
                                     if not np.isinf(x) and not np.isinf(y) and not np.isinf(z):
                                         coords.append((x, y))
@@ -114,10 +203,8 @@ def extract_terrain_info(file_path, namespaces):
                             if len(coords) >= 3 and validate_coords(coords):
                                 polygon = Polygon(coords)
                                 if polygon.is_valid:
-                                    # Calculate centroid for point representation
                                     centroid = polygon.centroid
                                     avg_elevation = np.mean(elevations)
-
                                     terrain_elements.append({
                                         'relief_id': relief_id,
                                         'tin_id': tin_id,
@@ -136,7 +223,6 @@ def extract_terrain_info(file_path, namespaces):
                 for line in breakline.findall('.//gml:LineString', namespaces):
                     line_id = line.get('{http://www.opengis.net/gml}id')
                     pos_list = line.find('.//gml:posList', namespaces)
-
                     if pos_list is not None:
                         try:
                             coords_text = pos_list.text.strip().split()
@@ -146,9 +232,8 @@ def extract_terrain_info(file_path, namespaces):
                             for j in range(0, len(coords_text), 3):
                                 if j + 2 < len(coords_text):
                                     x = float(coords_text[j])
-                                    y = float(coords_text[j + 1])
-                                    z = float(coords_text[j + 2])
-
+                                    y = float(coords_text[j+1])
+                                    z = float(coords_text[j+2])
                                     if not np.isinf(x) and not np.isinf(y) and not np.isinf(z):
                                         points.append(Point(x, y))
                                         elevations.append(z)
@@ -173,7 +258,6 @@ def extract_terrain_info(file_path, namespaces):
                 for point in mass_point.findall('.//gml:Point', namespaces):
                     point_id = point.get('{http://www.opengis.net/gml}id')
                     pos = point.find('.//gml:pos', namespaces)
-
                     if pos is not None:
                         try:
                             coords = pos.text.strip().split()
@@ -181,7 +265,6 @@ def extract_terrain_info(file_path, namespaces):
                                 x = float(coords[0])
                                 y = float(coords[1])
                                 z = float(coords[2])
-
                                 if not np.isinf(x) and not np.isinf(y) and not np.isinf(z):
                                     point_geom = Point(x, y)
                                     if point_geom.is_valid:
@@ -204,13 +287,13 @@ def extract_terrain_info(file_path, namespaces):
         print(f"Error processing terrain in file {Path(file_path).name}: {e}")
         return []
 
+
 def extract_vegetation_info(file_path, namespaces):
     """
     Extract vegetation features (PlantCover, SolitaryVegetationObject)
     from a CityGML file, handling LOD0..LOD3 geometry and MultiSurface/CompositeSurface.
     """
     vegetation_elements = []
-
     try:
         tree = ET.parse(file_path)
         root = tree.getroot()
@@ -218,32 +301,23 @@ def extract_vegetation_info(file_path, namespaces):
         print(f"Error parsing CityGML file {Path(file_path).name}: {e}")
         return vegetation_elements
 
-    # ----------------------------------------------------------------------------
-    # Helper: parse all polygons from a <gml:MultiSurface> or <veg:lodXMultiSurface>
-    # ----------------------------------------------------------------------------
+    # Helper: parse polygons in <gml:MultiSurface> or <veg:lodXMultiSurface>
     def parse_lod_multisurface(lod_elem):
-        """Return a Shapely (Multi)Polygon from gml:Polygon elements under lod_elem."""
         polygons = []
-        # Find all Polygons (including nested in CompositeSurface)
         for poly_node in lod_elem.findall('.//gml:Polygon', namespaces):
             ring_node = poly_node.find('.//gml:exterior//gml:LinearRing//gml:posList', namespaces)
             if ring_node is None or ring_node.text is None:
                 continue
-
-            # Parse coordinate text
             coords_text = ring_node.text.strip().split()
             coords = []
-            # Typically posList is in triplets: (x, y, z)
             for i in range(0, len(coords_text), 3):
                 try:
                     x = float(coords_text[i])
                     y = float(coords_text[i+1])
-                    # z = float(coords_text[i+2])  # if you want z
+                    # z = float(coords_text[i+2])  # If you need Z
                     coords.append((x, y))
                 except:
-                    # Skip any parse error or incomplete coordinate
                     pass
-
             if len(coords) >= 3:
                 polygon = Polygon(coords)
                 if polygon.is_valid:
@@ -256,36 +330,27 @@ def extract_vegetation_info(file_path, namespaces):
         else:
             return MultiPolygon(polygons)
 
-    # ----------------------------------------------------------------------------
-    # Helper: retrieve geometry from all LOD tags
-    # ----------------------------------------------------------------------------
     def get_veg_geometry(veg_elem):
         """
         Search for geometry under lod0Geometry, lod1Geometry, lod2Geometry,
-        lod3Geometry, lod4Geometry, as well as lod0MultiSurface ... lod3MultiSurface, etc.
+        lod3Geometry, lod4Geometry, as well as lod0MultiSurface ... lod4MultiSurface.
         Return a Shapely geometry (Polygon or MultiPolygon) if found.
         """
         geometry_lods = [
             "lod0Geometry", "lod1Geometry", "lod2Geometry", "lod3Geometry", "lod4Geometry",
             "lod0MultiSurface", "lod1MultiSurface", "lod2MultiSurface", "lod3MultiSurface", "lod4MultiSurface"
         ]
-
         for lod_tag in geometry_lods:
-            # e.g. .//veg:lod3Geometry
             lod_elem = veg_elem.find(f'.//veg:{lod_tag}', namespaces)
             if lod_elem is not None:
                 geom = parse_lod_multisurface(lod_elem)
                 if geom is not None:
                     return geom
-
         return None
 
-    # ----------------------------------------------------------------------------
     # 1) PlantCover
-    # ----------------------------------------------------------------------------
     for plant_cover in root.findall('.//veg:PlantCover', namespaces):
         cover_id = plant_cover.get('{http://www.opengis.net/gml}id')
-        # averageHeight (if present)
         avg_height_elem = plant_cover.find('.//veg:averageHeight', namespaces)
         if avg_height_elem is not None and avg_height_elem.text:
             try:
@@ -295,9 +360,7 @@ def extract_vegetation_info(file_path, namespaces):
         else:
             vegetation_height = None
 
-        # parse geometry from LOD0..LOD3
         geometry = get_veg_geometry(plant_cover)
-
         if geometry is not None and not geometry.is_empty:
             vegetation_elements.append({
                 'object_type': 'PlantCover',
@@ -307,9 +370,7 @@ def extract_vegetation_info(file_path, namespaces):
                 'source_file': Path(file_path).name
             })
 
-    # ----------------------------------------------------------------------------
     # 2) SolitaryVegetationObject
-    # ----------------------------------------------------------------------------
     for solitary in root.findall('.//veg:SolitaryVegetationObject', namespaces):
         veg_id = solitary.get('{http://www.opengis.net/gml}id')
         height_elem = solitary.find('.//veg:height', namespaces)
@@ -335,6 +396,51 @@ def extract_vegetation_info(file_path, namespaces):
         print(f"Extracted {len(vegetation_elements)} vegetation objects from {Path(file_path).name}")
     return vegetation_elements
 
+
+def extract_building_footprint(building, namespaces):
+    """
+    Extract building footprint from possible LOD representations
+    """
+    lod_tags = [
+        # LOD0
+        './/bldg:lod0FootPrint//gml:MultiSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        './/bldg:lod0RoofEdge//gml:MultiSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        './/bldg:lod0Solid//gml:Solid//gml:exterior//gml:CompositeSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        
+        # LOD1
+        './/bldg:lod1Solid//gml:Solid//gml:exterior//gml:CompositeSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        
+        # LOD2
+        './/bldg:lod2Solid//gml:Solid//gml:exterior//gml:CompositeSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        
+        # fallback
+        './/gml:MultiSurface//gml:surfaceMember//gml:Polygon//gml:exterior//gml:LinearRing//gml:posList',
+        './/gml:Polygon//gml:exterior//gml:LinearRing//gml:posList'
+    ]
+    
+    for tag in lod_tags:
+        pos_list_elements = building.findall(tag, namespaces)
+        if pos_list_elements:
+            # If in LOD1/LOD2 solid, we look for the bottom face
+            if 'lod1Solid' in tag or 'lod2Solid' in tag or 'lod0Solid' in tag:
+                lowest_z = float('inf')
+                footprint_pos_list = None
+                for pos_list_elem in pos_list_elements:
+                    coords_text = pos_list_elem.text.strip().split()
+                    z_values = [float(coords_text[i+2]) 
+                                for i in range(0, len(coords_text), 3) 
+                                if i+2 < len(coords_text)]
+                    if z_values and all(z == z_values[0] for z in z_values) and z_values[0] < lowest_z:
+                        lowest_z = z_values[0]
+                        footprint_pos_list = pos_list_elem
+                if footprint_pos_list:
+                    return footprint_pos_list, lowest_z
+            else:
+                # For simpler LOD0 footprints, just return the first
+                return pos_list_elements[0], None
+    return None, None
+
+
 def process_citygml_file(file_path):
     """
     Process a CityGML file to extract building, terrain, and vegetation information
@@ -343,7 +449,6 @@ def process_citygml_file(file_path):
     terrain_elements = []
     vegetation_elements = []
 
-    # Namespaces (now includes 'veg')
     namespaces = {
         'core': 'http://www.opengis.net/citygml/2.0',
         'bldg': 'http://www.opengis.net/citygml/building/2.0',
@@ -354,27 +459,36 @@ def process_citygml_file(file_path):
     }
 
     try:
-        # Parse the file once at the start (optional; if you want to share 'root' among sub-extractors)
         tree = ET.parse(file_path)
         root = tree.getroot()
 
-        # --- Extract Building Info (existing approach) ---
+        # Extract Buildings
         for building in root.findall('.//bldg:Building', namespaces):
             building_id = building.get('{http://www.opengis.net/gml}id')
+            
             measured_height = building.find('.//bldg:measuredHeight', namespaces)
-            height = float(measured_height.text) if measured_height is not None else None
-
-            # Extract the footprint (LOD0)
-            lod0_roof_edge = building.find('.//bldg:lod0RoofEdge//gml:posList', namespaces)
-            if lod0_roof_edge is not None:
+            height = float(measured_height.text) if measured_height is not None and measured_height.text else None
+            
+            storeys = building.find('.//bldg:storeysAboveGround', namespaces)
+            num_storeys = int(storeys.text) if storeys is not None and storeys.text else None
+            
+            pos_list, ground_elevation = extract_building_footprint(building, namespaces)
+            if pos_list is not None:
                 try:
-                    pos_list = lod0_roof_edge.text.strip().split()
+                    coords_text = pos_list.text.strip().split()
                     coords = []
-                    for i in range(0, len(pos_list), 3):
-                        if i + 2 < len(pos_list):
-                            lon = float(pos_list[i])
-                            lat = float(pos_list[i + 1])
-                            elevation = float(pos_list[i + 2])  # z value
+                    
+                    # Decide if we have (x,y) pairs or (x,y,z) triplets
+                    coord_step = 3 if (len(coords_text) % 3) == 0 else 2
+
+                    for i in range(0, len(coords_text), coord_step):
+                        if i + coord_step - 1 < len(coords_text):
+                            lon = float(coords_text[i])
+                            lat = float(coords_text[i+1])
+                            if coord_step == 3 and i+2 < len(coords_text):
+                                z = float(coords_text[i+2])
+                                if ground_elevation is None:
+                                    ground_elevation = z
                             if not np.isinf(lon) and not np.isinf(lat):
                                 coords.append((lon, lat))
 
@@ -384,17 +498,18 @@ def process_citygml_file(file_path):
                             buildings.append({
                                 'building_id': building_id,
                                 'height': height,
-                                'ground_elevation': elevation,  # Add ground elevation if relevant
+                                'storeys': num_storeys,
+                                'ground_elevation': ground_elevation,
                                 'geometry': polygon,
                                 'source_file': Path(file_path).name
                             })
                 except (ValueError, IndexError) as e:
-                    print(f"Error processing building {building_id} in file {Path(file_path).name}: {e}")
+                    print(f"Error processing building {building_id} footprint in {Path(file_path).name}: {e}")
 
-        # --- Extract Terrain Info (existing function) ---
+        # Extract Terrain
         terrain_elements = extract_terrain_info(file_path, namespaces)
 
-        # --- Extract Vegetation Info (new function) ---
+        # Extract Vegetation
         vegetation_elements = extract_vegetation_info(file_path, namespaces)
 
         print(f"Processed {Path(file_path).name}: "
@@ -406,151 +521,189 @@ def process_citygml_file(file_path):
 
     return buildings, terrain_elements, vegetation_elements
 
-def load_plateau_with_terrain(url, base_dir):
+
+def parse_file(file_path, file_type=None):
+    """
+    Parse a file based on its detected type
+    """
+    if file_type is None:
+        file_ext = os.path.splitext(file_path)[1].lower()
+        if file_ext == '.gml':
+            file_type = 'citygml'
+        elif file_ext == '.xml':
+            try:
+                tree = ET.parse(file_path)
+                root = tree.getroot()
+                ns = root.nsmap
+                if any('citygml' in ns_uri.lower() for ns_uri in ns.values()):
+                    file_type = 'citygml'
+                else:
+                    file_type = 'xml'
+            except:
+                file_type = 'xml'
+        elif file_ext in ['.json', '.geojson']:
+            file_type = 'geojson'
+        else:
+            print(f"Unsupported file type: {file_ext}")
+            return None, None, None
+    
+    if file_type == 'citygml':
+        return process_citygml_file(file_path)
+    elif file_type == 'geojson':
+        print(f"GeoJSON processing not implemented for {file_path}")
+        return [], [], []
+    elif file_type == 'xml':
+        print(f"Generic XML processing not implemented for {file_path}")
+        return [], [], []
+    else:
+        print(f"Unsupported file type: {file_type}")
+        return [], [], []
+
+
+def swap_coordinates_if_needed(gdf, geometry_col='geometry'):
+    """
+    Swap lat/lon coordinates in a GeoDataFrame if its geometry is in lat-lon order.
+    We assume the original data is EPSG:6697 (which is a projected coordinate system).
+    But we frequently find that data is actually lat-lon. This function ensures
+    final geometry is in the correct coordinate order (lon, lat).
+    """
+    swapped_geometries = []
+    for geom in gdf[geometry_col]:
+        # If it's a Polygon or MultiPolygon, use swap_coordinates()
+        if isinstance(geom, (Polygon, MultiPolygon)):
+            swapped_geometries.append(swap_coordinates(geom))
+        elif isinstance(geom, Point):
+            swapped_geometries.append(Point(geom.y, geom.x))
+        else:
+            swapped_geometries.append(geom)
+    return swapped_geometries
+
+
+def load_buid_dem_veg_from_citygml(url=None, 
+                              base_dir='.', 
+                              citygml_path=None,
+                              rectangle_vertices=None):
     """
-    Load PLATEAU data, extracting Buildings, Terrain, and Vegetation data from CityGML.
+    Load PLATEAU data, extracting Buildings, Terrain, and Vegetation data.
+    Can process from URL (download & extract) or directly from local file.
+
+    If rectangle_vertices is provided (as [(lon1, lat1), (lon2, lat2), ...]),
+    only tiles intersecting that rectangle will be processed.
     """
-    # 1) Download & unzip
-    citygml_path, foldername = download_and_extract_zip(url, extract_to=base_dir)
+    all_buildings = []
+    all_terrain = []
+    all_vegetation = []
+    
+    # Build the rectangle polygon if given
+    rectangle_polygon = None
+    if rectangle_vertices and len(rectangle_vertices) >= 3:
+        rectangle_polygon = Polygon(rectangle_vertices)
+    
+    if url:
+        citygml_path, foldername = download_and_extract_zip(url, extract_to=base_dir)
+    elif citygml_path:
+        foldername = os.path.basename(citygml_path)
+    else:
+        print("Either url or citygml_path must be specified")
+        return None, None, None
 
-    # 2) Identify CityGML files in typical folder structure
+    # Identify CityGML files in typical folder structure
     try:
         citygml_dir = os.path.join(citygml_path, 'udx')
         if not os.path.exists(citygml_dir):
-            citygml_dir = os.path.join(citygml_path, foldername, 'udx')
-
+            citygml_dir_2 = os.path.join(citygml_path, foldername, 'udx')
+            if os.path.exists(citygml_dir_2):
+                citygml_dir = citygml_dir_2
+        
+        # Potential sub-folders
         bldg_dir = os.path.join(citygml_dir, 'bldg')
         dem_dir = os.path.join(citygml_dir, 'dem')
-
-        # NEW: check for vegetation folder
         veg_dir = os.path.join(citygml_dir, 'veg')
-
+        
         citygml_files = []
-
-        # If there's a building folder, gather .gml from there
-        if os.path.exists(bldg_dir):
-            citygml_files += [
-                os.path.join(bldg_dir, f) for f in os.listdir(bldg_dir) if f.endswith('.gml')
-            ]
-        else:
-            # If no 'bldg' folder, look directly in 'udx'
-            citygml_files += [
-                os.path.join(citygml_dir, f) for f in os.listdir(citygml_dir) if f.endswith('.gml')
-            ]
-
-        # Also gather DEM .gml (terrain)
-        if os.path.exists(dem_dir):
-            citygml_files += [
-                os.path.join(dem_dir, f) for f in os.listdir(dem_dir) if f.endswith('.gml')
-            ]
-
-        # ADD THIS: gather VEG .gml (vegetation)
-        if os.path.exists(veg_dir):
-            citygml_files += [
-                os.path.join(veg_dir, f) for f in os.listdir(veg_dir) if f.endswith('.gml')
-            ]
-
-        total_files = len(citygml_files)
-        print(f"Found {total_files} CityGML files to process")
-
+        for folder in [bldg_dir, dem_dir, veg_dir, citygml_dir]:
+            if os.path.exists(folder):
+                citygml_files += [
+                    os.path.join(folder, f) for f in os.listdir(folder) 
+                    if f.endswith(('.gml', '.xml'))
+                ]
+        
+        print(f"Found {len(citygml_files)} CityGML files to process")
+
+        for file_path in tqdm(citygml_files, desc="Processing files"):
+            filename = os.path.basename(file_path)
+
+            # If a rectangle is given, check tile intersection
+            if rectangle_polygon is not None:
+                try:
+                    tile_polygon_lonlat = get_tile_polygon_from_filename(filename)  # returns [(lon, lat), ...]
+                    tile_polygon = Polygon(tile_polygon_lonlat)
+                    
+                    # If no overlap, skip processing
+                    if not tile_polygon.intersects(rectangle_polygon):
+                        continue
+                except Exception as e:
+                    # If we cannot parse a tile boundary, skip or handle as you wish
+                    print(f"Warning: could not get tile boundary from {filename}: {e}, extracting the tile whether it is in the rectangle or not.")
+                    # continue
+
+            # Parse the file
+            buildings, terrain_elements, vegetation_elements = parse_file(file_path)
+            all_buildings.extend(buildings)
+            all_terrain.extend(terrain_elements)
+            all_vegetation.extend(vegetation_elements)
+    
     except Exception as e:
         print(f"Error finding CityGML files: {e}")
         return None, None, None
 
-    all_buildings = []
-    all_terrain = []
-    all_vegetation = []
-
-    # 3) Process each CityGML
-    for file_path in tqdm(citygml_files, desc="Processing CityGML files"):
-        buildings, terrain_elements, vegetation_elements = process_citygml_file(file_path)
-        all_buildings.extend(buildings)
-        all_terrain.extend(terrain_elements)
-        all_vegetation.extend(vegetation_elements)
+    # Convert to GeoDataFrames
+    gdf_buildings = None
+    gdf_terrain = None
+    gdf_vegetation = None
 
-    # 4) Create GeoDataFrame for Buildings
     if all_buildings:
         gdf_buildings = gpd.GeoDataFrame(all_buildings, geometry='geometry')
-        gdf_buildings.set_crs(epsg=6697, inplace=True)
-
-        # Swap coords from (lon, lat) to (lat, lon) if needed
-        swapped_geometries = [swap_coordinates(geom) for geom in gdf_buildings.geometry]
-        gdf_buildings_swapped = gpd.GeoDataFrame(
-            {
-                'building_id': gdf_buildings['building_id'],
-                'height': gdf_buildings['height'],
-                'ground_elevation': gdf_buildings['ground_elevation'],
-                'source_file': gdf_buildings['source_file'],
-                'geometry': swapped_geometries
-            },
-            crs='EPSG:6697'
-        )
-
-        # Save
-        gdf_buildings_swapped['id'] = gdf_buildings_swapped.index
-        # gdf_buildings_swapped.to_file('all_buildings_with_elevation.geojson', driver='GeoJSON')
-        # print(f"\nBuildings saved to all_buildings_with_elevation.geojson")
-    else:
-        gdf_buildings_swapped = None
+        gdf_buildings.set_crs(epsg=6697, inplace=True)  # or "EPSG:4326", depending on your data
+        # Swap if needed
+        gdf_buildings['geometry'] = swap_coordinates_if_needed(gdf_buildings, geometry_col='geometry')
+        # Add an ID
+        gdf_buildings['id'] = range(len(gdf_buildings))
 
-    # 5) Create GeoDataFrame for Terrain
     if all_terrain:
         gdf_terrain = gpd.GeoDataFrame(all_terrain, geometry='geometry')
         gdf_terrain.set_crs(epsg=6697, inplace=True)
+        gdf_terrain['geometry'] = swap_coordinates_if_needed(gdf_terrain, geometry_col='geometry')
 
-        swapped_geometries = []
-        for geom in gdf_terrain.geometry:
-            if isinstance(geom, (Polygon, MultiPolygon)):
-                swapped_geometries.append(swap_coordinates(geom))
-            elif isinstance(geom, Point):
-                swapped_geometries.append(Point(geom.y, geom.x))
-            else:
-                swapped_geometries.append(geom)
-
-        terrain_data = {
-            'relief_id': gdf_terrain.get('relief_id', ''),
-            'tin_id': gdf_terrain.get('tin_id', ''),
-            'triangle_id': gdf_terrain.get('triangle_id', ''),
-            'breakline_id': gdf_terrain.get('breakline_id', ''),
-            'mass_point_id': gdf_terrain.get('mass_point_id', ''),
-            'point_id': gdf_terrain.get('point_id', ''),
-            'elevation': gdf_terrain['elevation'],
-            'source_file': gdf_terrain['source_file'],
-            'geometry': swapped_geometries
-        }
-
-        gdf_terrain_swapped = gpd.GeoDataFrame(terrain_data, geometry='geometry', crs='EPSG:6697')
-        # gdf_terrain_swapped.to_file('terrain_elevation.geojson', driver='GeoJSON')
-        # print(f"Terrain saved to terrain_elevation.geojson")
-    else:
-        gdf_terrain_swapped = None
-
-    # 6) Create GeoDataFrame for Vegetation
     if all_vegetation:
-        gdf_veg = gpd.GeoDataFrame(all_vegetation, geometry='geometry')
-        gdf_veg.set_crs(epsg=6697, inplace=True)
-
-        swapped_geometries = []
-        for geom in gdf_veg.geometry:
-            if isinstance(geom, (Polygon, MultiPolygon)):
-                swapped_geometries.append(swap_coordinates(geom))
-            elif isinstance(geom, Point):
-                swapped_geometries.append(Point(geom.y, geom.x))
-            else:
-                swapped_geometries.append(geom)
-
-        vegetation_data = {
-            'object_type':    gdf_veg.get('object_type', ''),
-            'vegetation_id':  gdf_veg.get('vegetation_id', ''),
-            'height':         gdf_veg.get('height', None),
-            'avg_elevation':  gdf_veg.get('avg_elevation', None),  # Use .get() with a default
-            'source_file':    gdf_veg.get('source_file', ''),
-            'geometry':       swapped_geometries
-        }
-        gdf_vegetation_swapped = gpd.GeoDataFrame(vegetation_data, geometry='geometry', crs='EPSG:6697')
-        # gdf_vegetation_swapped.to_file('vegetation_elevation.geojson', driver='GeoJSON')
-        # print(f"Vegetation saved to vegetation_elevation.geojson")
-    else:
-        gdf_vegetation_swapped = None
+        gdf_vegetation = gpd.GeoDataFrame(all_vegetation, geometry='geometry')
+        gdf_vegetation.set_crs(epsg=6697, inplace=True)
+        gdf_vegetation['geometry'] = swap_coordinates_if_needed(gdf_vegetation, geometry_col='geometry')
 
-    return gdf_buildings_swapped, gdf_terrain_swapped, gdf_vegetation_swapped
+    return gdf_buildings, gdf_terrain, gdf_vegetation
+
+
+def process_single_file(file_path):
+    """
+    Process a single file (for testing)
+    """
+    file_ext = os.path.splitext(file_path)[1].lower()
+    if file_ext in ['.gml', '.xml']:
+        buildings, terrain, vegetation = parse_file(file_path)
+        print(f"\nProcessed {file_path}:")
+        print(f"  - {len(buildings)} buildings extracted")
+        print(f"  - {len(terrain)} terrain elements extracted")
+        print(f"  - {len(vegetation)} vegetation objects extracted")
+        
+        # Example: create building GeoDataFrame and save to GeoJSON
+        if buildings:
+            gdf_buildings = gpd.GeoDataFrame(buildings, geometry='geometry')
+            gdf_buildings.set_crs(epsg=6697, inplace=True)
+            output_file = os.path.splitext(file_path)[0] + "_buildings.geojson"
+            gdf_buildings.to_file(output_file, driver='GeoJSON')
+            print(f"Buildings saved to {output_file}")
+        
+        return buildings, terrain, vegetation
+    else:
+        print(f"Unsupported file type: {file_ext}")
+        return None, None, None

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity/exporter/obj.py

@@ -9,6 +9,8 @@ import numpy as np
 import os
 from numba import njit, prange
 import matplotlib.pyplot as plt
+import trimesh
+import numpy as np
 from ..utils.visualization import get_voxel_color_map
 
 def convert_colormap_indices(original_map):

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity/generator.py

@@ -23,7 +23,7 @@ from .downloader.oemj import save_oemj_as_geotiff
 from .downloader.omt import load_gdf_from_openmaptiles
 from .downloader.eubucco import load_gdf_from_eubucco
 from .downloader.overture import load_gdf_from_overture
-from .downloader.citygml import load_plateau_with_terrain
+from .downloader.citygml import load_buid_dem_veg_from_citygml
 from .downloader.gee import (
     initialize_earth_engine,
     get_roi,
@@ -691,7 +691,7 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
 
     return voxcity_grid, building_height_grid, building_min_height_grid, building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, building_gdf
 
-def get_voxcity_CityGML(rectangle_vertices, url_citygml, land_cover_source, canopy_height_source, meshsize, **kwargs):
+def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_source, meshsize, url_citygml=None, citygml_path=None, **kwargs):
     """Main function to generate a complete voxel city model.
 
     Args:
@@ -728,7 +728,7 @@ def get_voxcity_CityGML(rectangle_vertices, url_citygml, land_cover_source, cano
     kwargs.pop('output_dir', None)
 
     # get all required gdfs    
-    building_gdf, terrain_gdf, vegetation_gdf = load_plateau_with_terrain(url_citygml, base_dir=output_dir)
+    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)
 
     land_cover_grid = get_land_cover_grid(rectangle_vertices, meshsize, land_cover_source, output_dir, **kwargs)        
 
@@ -817,7 +817,7 @@ def get_voxcity_CityGML(rectangle_vertices, url_citygml, land_cover_source, cano
     # 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)
 
-    return voxcity_grid, building_height_grid, building_min_height_grid, building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, building_gdf
+    return voxcity_grid, building_height_grid, building_min_height_grid, building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, filtered_buildings
 
 def replace_nan_in_nested(arr, replace_value=10.0):
     """Replace NaN values in a nested array structure with a specified value.

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity/geoprocessor/grid.py

@@ -11,6 +11,7 @@ from pyproj import Geod, Transformer, CRS
 import rasterio
 from affine import Affine
 from shapely.geometry import box, Polygon, Point, MultiPolygon
+import warnings
 
 from scipy.interpolate import griddata
 from shapely.errors import GEOSException

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity/utils/visualization.py

@@ -43,6 +43,7 @@ from ..geoprocessor.mesh import (
     create_city_meshes,
     export_meshes
 )
+# from ..exporter.obj import save_obj_from_colored_mesh
 from .material import get_material_dict
 
 # def get_voxel_color_map():
@@ -74,6 +75,7 @@ from .material import get_material_dict
 #         13: [150, 166, 190],    #  'Building (ground surface)'
 #         14: [239, 228, 176],    #  'No Data (ground surface)'
 #     }
+
 def get_voxel_color_map(color_scheme='default'):
     """
     Returns a color map for voxel visualization based on the specified color scheme.
@@ -1528,6 +1530,7 @@ def visualize_voxcity_multi_view(voxel_array, meshsize, **kwargs):
     vmax = kwargs.get("vmax", np.nanmax(sim_grid))
     projection_type = kwargs.get("projection_type", "perspective")
     distance_factor = kwargs.get("distance_factor", 1.0)
+    save_obj = kwargs.get("save_obj", False)
 
     # Create meshes
     print("Creating voxel meshes...")
@@ -1579,6 +1582,13 @@ def visualize_voxcity_multi_view(voxel_array, meshsize, **kwargs):
         plt.axis('off')
         plt.show()
         plt.close()
+    
+        # After creating the meshes and before visualization
+    if save_obj:
+        output_directory = kwargs.get('output_directory', 'output')
+        output_file_name = kwargs.get('output_file_name', 'voxcity_mesh')
+        obj_path, mtl_path = save_obj_from_colored_mesh(meshes, output_directory, output_file_name)
+        print(f"Saved mesh files to:\n  {obj_path}\n  {mtl_path}")
 
 def visualize_voxcity_multi_view_with_multiple_sim_grids(voxel_array, meshsize, sim_configs, **kwargs):
     """
@@ -1610,7 +1620,9 @@ def visualize_voxcity_multi_view_with_multiple_sim_grids(voxel_array, meshsize,
     # Configure PyVista settings
     pv.set_plot_theme('document')
     pv.global_theme.background = 'white'
-    pv.global_theme.window_size = [1024, 768]
+    window_width = kwargs.get("window_width", 1024)
+    window_height = kwargs.get("window_height", 768)
+    pv.global_theme.window_size = [window_width, window_height]
     pv.global_theme.jupyter_backend = 'static'
 
     # Parse general kwargs
@@ -1743,7 +1755,9 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     # Configure PyVista settings
     pv.set_plot_theme('document')
     pv.global_theme.background = 'white'
-    pv.global_theme.window_size = [1024, 768]
+    window_width = kwargs.get("window_width", 1024)
+    window_height = kwargs.get("window_height", 768)
+    pv.global_theme.window_size = [window_width, window_height]
     pv.global_theme.jupyter_backend = 'static'
     
     # Parse kwargs
@@ -1764,6 +1778,7 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     colorbar_title = kwargs.get("colorbar_title", "")
     value_name = kwargs.get("value_name", None)
     nan_color = kwargs.get("nan_color", "gray")
+    save_obj = kwargs.get("save_obj", False)
     
     if value_name is None:
         print("Set value_name")
@@ -1891,7 +1906,7 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
 
     # Display each view separately
     for view_name, img_file in image_files:
-        plt.figure(figsize=(12, 8))
+        plt.figure(figsize=(24, 16))
         img = plt.imread(img_file)
         plt.imshow(img)
         plt.title(view_name.replace('_', ' ').title(), pad=20)
@@ -1899,6 +1914,13 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
         plt.show()
         plt.close()
         
+    # After creating the meshes and before visualization
+    if save_obj:
+        output_directory = kwargs.get('output_directory', 'output')
+        output_file_name = kwargs.get('output_file_name', 'voxcity_mesh')
+        obj_path, mtl_path = save_obj_from_colored_mesh(meshes, output_directory, output_file_name)
+        print(f"Saved mesh files to:\n  {obj_path}\n  {mtl_path}")
+    
     return image_files
 
 def visualize_building_sim_results(voxel_array, meshsize, building_sim_mesh, **kwargs):
@@ -1952,4 +1974,70 @@ def visualize_building_sim_results(voxel_array, meshsize, building_sim_mesh, **k
         meshsize,
         custom_meshes=custom_meshes,
         **kwargs
-    )
+    )
+
+def save_obj_from_colored_mesh(meshes, output_path, base_filename):
+    """
+    Save colored meshes as OBJ and MTL files.
+    
+    Parameters
+    ----------
+    meshes : dict
+        Dictionary of trimesh.Trimesh objects with face colors.
+    output_path : str
+        Directory path where to save the files.
+    base_filename : str
+        Base name for the output files (without extension).
+        
+    Returns
+    -------
+    tuple
+        Paths to the saved (obj_file, mtl_file).
+    """
+    
+    os.makedirs(output_path, exist_ok=True)
+    obj_path = os.path.join(output_path, f"{base_filename}.obj")
+    mtl_path = os.path.join(output_path, f"{base_filename}.mtl")
+    
+    # Combine all meshes
+    combined_mesh = trimesh.util.concatenate(list(meshes.values()))
+    
+    # Create unique materials for each unique face color
+    face_colors = combined_mesh.visual.face_colors
+    unique_colors = np.unique(face_colors, axis=0)
+    
+    # Write MTL file
+    with open(mtl_path, 'w') as mtl_file:
+        for i, color in enumerate(unique_colors):
+            material_name = f'material_{i}'
+            mtl_file.write(f'newmtl {material_name}\n')
+            # Convert RGBA to RGB float values
+            rgb = color[:3].astype(float) / 255.0
+            mtl_file.write(f'Kd {rgb[0]:.6f} {rgb[1]:.6f} {rgb[2]:.6f}\n')
+            mtl_file.write(f'd {color[3]/255.0:.6f}\n\n')  # Alpha value
+    
+    # Create material groups based on face colors
+    color_to_material = {tuple(c): f'material_{i}' for i, c in enumerate(unique_colors)}
+    
+    # Write OBJ file
+    with open(obj_path, 'w') as obj_file:
+        obj_file.write(f'mtllib {os.path.basename(mtl_path)}\n')
+        
+        # Write vertices
+        for vertex in combined_mesh.vertices:
+            obj_file.write(f'v {vertex[0]:.6f} {vertex[1]:.6f} {vertex[2]:.6f}\n')
+        
+        # Write faces grouped by material
+        current_material = None
+        for face_idx, face in enumerate(combined_mesh.faces):
+            face_color = tuple(face_colors[face_idx])
+            material_name = color_to_material[face_color]
+            
+            if material_name != current_material:
+                obj_file.write(f'usemtl {material_name}\n')
+                current_material = material_name
+            
+            # OBJ indices are 1-based
+            obj_file.write(f'f {face[0]+1} {face[1]+1} {face[2]+1}\n')
+    
+    return obj_path, mtl_path

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.5.6
+Version: 0.5.9
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 Author-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
 Maintainer-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
@@ -45,7 +45,7 @@ Requires-Dist: pycountry
 Requires-Dist: osm2geojson
 Requires-Dist: seaborn
 Requires-Dist: overturemaps
-Requires-Dist: protobuf<=3.20.3
+Requires-Dist: protobuf<6,>=4.21
 Requires-Dist: timezonefinder
 Requires-Dist: astral
 Requires-Dist: osmnx

{voxcity-0.5.6 → voxcity-0.5.9}/src/voxcity.egg-info/requires.txt

@@ -28,7 +28,7 @@ pycountry
 osm2geojson
 seaborn
 overturemaps
-protobuf<=3.20.3
+protobuf<6,>=4.21
 timezonefinder
 astral
 osmnx