voxcity 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

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/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/geoprocessor/mesh.py

@@ -1,4 +1,5 @@
 import numpy as np
+import os
 import trimesh
 import matplotlib.colors as mcolors
 import matplotlib.cm as cm
@@ -304,4 +305,107 @@ def export_meshes(meshes, output_directory, base_filename):
     # Export individual meshes as STL
     for class_id, mesh in meshes.items():
         # Convert class_id to a string for filename
-        mesh.export(f"{output_directory}/{base_filename}_{class_id}.stl")
+        mesh.export(f"{output_directory}/{base_filename}_{class_id}.stl")
+
+def split_vertices_manual(mesh):
+    """
+    Imitate trimesh's split_vertices() by giving each face its own copy of vertices.
+    This ensures every face is truly disconnected, preventing smooth shading in Rhino.
+    """
+    new_meshes = []
+    
+    # For each face, build a small, one-face mesh
+    for face_idx, face in enumerate(mesh.faces):
+        face_coords = mesh.vertices[face]
+        
+        # Create mini-mesh without colors first
+        mini_mesh = trimesh.Trimesh(
+            vertices=face_coords,
+            faces=[[0, 1, 2]],
+            process=False  # skip merging/cleaning
+        )
+        
+        # If the mesh has per-face colors, set the face color properly
+        if (mesh.visual.face_colors is not None 
+            and len(mesh.visual.face_colors) == len(mesh.faces)):
+            # Create a visual object with the face color (for one face)
+            face_color = mesh.visual.face_colors[face_idx]
+            color_visual = trimesh.visual.ColorVisuals(
+                mesh=mini_mesh,
+                face_colors=np.array([face_color]),  # One face, one color
+                vertex_colors=None
+            )
+            mini_mesh.visual = color_visual
+        
+        new_meshes.append(mini_mesh)
+    
+    # Concatenate all the single-face meshes
+    out_mesh = trimesh.util.concatenate(new_meshes)
+    return out_mesh
+
+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()))
+    combined_mesh = split_vertices_manual(combined_mesh)
+    
+    # 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/utils/visualization.py

@@ -41,7 +41,8 @@ from ..geoprocessor.mesh import (
     create_voxel_mesh,
     create_sim_surface_mesh,
     create_city_meshes,
-    export_meshes
+    export_meshes,
+    save_obj_from_colored_mesh
 )
 # from ..exporter.obj import save_obj_from_colored_mesh
 from .material import get_material_dict
@@ -1531,6 +1532,7 @@ def visualize_voxcity_multi_view(voxel_array, meshsize, **kwargs):
     projection_type = kwargs.get("projection_type", "perspective")
     distance_factor = kwargs.get("distance_factor", 1.0)
     save_obj = kwargs.get("save_obj", False)
+    show_views = kwargs.get("show_views", True)
 
     # Create meshes
     print("Creating voxel meshes...")
@@ -1567,21 +1569,22 @@ def visualize_voxcity_multi_view(voxel_array, meshsize, **kwargs):
         os.makedirs(output_directory, exist_ok=True)
         export_meshes(meshes, output_directory, base_filename)
 
-    # Create and save multiple views
-    print("Creating multiple views...")        
-    # Create output directory if it doesn't exist
-    os.makedirs(output_directory, exist_ok=True)
-    image_files = create_multi_view_scene(meshes, output_directory=output_directory, projection_type=projection_type, distance_factor=distance_factor)
-
-    # Display each view separately
-    for view_name, img_file in image_files:
-        plt.figure(figsize=(12, 8))
-        img = plt.imread(img_file)
-        plt.imshow(img)
-        plt.title(view_name.replace('_', ' ').title(), pad=20)
-        plt.axis('off')
-        plt.show()
-        plt.close()
+    if show_views:  
+        # Create and save multiple views
+        print("Creating multiple views...")        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_directory, exist_ok=True)
+        image_files = create_multi_view_scene(meshes, output_directory=output_directory, projection_type=projection_type, distance_factor=distance_factor)
+
+        # Display each view separately
+        for view_name, img_file in image_files:
+            plt.figure(figsize=(12, 8))
+            img = plt.imread(img_file)
+            plt.imshow(img)
+            plt.title(view_name.replace('_', ' ').title(), pad=20)
+            plt.axis('off')
+            plt.show()
+            plt.close()
     
         # After creating the meshes and before visualization
     if save_obj:
@@ -1633,6 +1636,8 @@ def visualize_voxcity_multi_view_with_multiple_sim_grids(voxel_array, meshsize,
     dem_grid_ori = kwargs.get("dem_grid", None)
     projection_type = kwargs.get("projection_type", "perspective")
     distance_factor = kwargs.get("distance_factor", 1.0)
+    show_views = kwargs.get("show_views", True)
+    save_obj = kwargs.get("save_obj", False)
 
     if dem_grid_ori is not None:
         dem_grid = dem_grid_ori - np.min(dem_grid_ori)
@@ -1681,27 +1686,33 @@ def visualize_voxcity_multi_view_with_multiple_sim_grids(voxel_array, meshsize,
         os.makedirs(output_directory, exist_ok=True)
         export_meshes(meshes, output_directory, base_filename)
 
-    # Create and save multiple views
-    print("Creating multiple views...")        
-    os.makedirs(output_directory, exist_ok=True)
-    image_files = create_multi_view_scene(
-        meshes, 
-        output_directory=output_directory,
-        projection_type=projection_type,
-        distance_factor=distance_factor
-    )
+    if show_views:
+        # Create and save multiple views
+        print("Creating multiple views...")        
+        os.makedirs(output_directory, exist_ok=True)
+        image_files = create_multi_view_scene(
+            meshes, 
+            output_directory=output_directory,
+            projection_type=projection_type,
+            distance_factor=distance_factor
+        )
 
-    # Display each view separately
-    for view_name, img_file in image_files:
-        plt.figure(figsize=(12, 8))
-        img = plt.imread(img_file)
-        plt.imshow(img)
-        plt.title(view_name.replace('_', ' ').title(), pad=20)
-        plt.axis('off')
-        plt.show()
-        plt.close()
+        # Display each view separately
+        for view_name, img_file in image_files:
+            plt.figure(figsize=(12, 8))
+            img = plt.imread(img_file)
+            plt.imshow(img)
+            plt.title(view_name.replace('_', ' ').title(), pad=20)
+            plt.axis('off')
+            plt.show()
+            plt.close()
 
-    return meshes
+    # 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_with_sim_meshes(voxel_array, meshsize, custom_meshes=None, **kwargs):
     """
@@ -1778,6 +1789,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")
+    show_views = kwargs.get("show_views", True)
     save_obj = kwargs.get("save_obj", False)
     
     if value_name is None:
@@ -1900,28 +1912,28 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     print("Creating multiple views...")        
     # Create output directory if it doesn't exist
     os.makedirs(output_directory, exist_ok=True)
-    image_files = create_multi_view_scene(meshes, output_directory=output_directory, 
+
+    if show_views:
+        image_files = create_multi_view_scene(meshes, output_directory=output_directory, 
                                          projection_type=projection_type, 
                                          distance_factor=distance_factor)
 
-    # Display each view separately
-    for view_name, img_file in image_files:
-        plt.figure(figsize=(24, 16))
-        img = plt.imread(img_file)
-        plt.imshow(img)
-        plt.title(view_name.replace('_', ' ').title(), pad=20)
-        plt.axis('off')
-        plt.show()
-        plt.close()
+        # Display each view separately
+        for view_name, img_file in image_files:
+            plt.figure(figsize=(24, 16))
+            img = plt.imread(img_file)
+            plt.imshow(img)
+            plt.title(view_name.replace('_', ' ').title(), pad=20)
+            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}")
-    
-    return image_files
+        print(f"Saved mesh files to:\n  {obj_path}\n  {mtl_path}")    
 
 def visualize_building_sim_results(voxel_array, meshsize, building_sim_mesh, **kwargs):
     """
@@ -1969,75 +1981,9 @@ def visualize_building_sim_results(voxel_array, meshsize, building_sim_mesh, **k
             kwargs["colorbar_title"] = pretty_name
     
     # Call the more general visualization function
-    return visualize_voxcity_with_sim_meshes(
+    visualize_voxcity_with_sim_meshes(
         voxel_array,
         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.8.dist-info → voxcity-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.5.8
+Version: 0.5.10
 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>
@@ -72,6 +72,10 @@ Dynamic: license-file
   Tutorial preview: <a href="https://colab.research.google.com/drive/1Lofd3RawKMr6QuUsamGaF48u2MN0hfrP?usp=sharing">[Google Colab]</a>
 </p>
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/logo.png" alt="Voxcity logo" width="800">
+</p>
+
 # VoxCity
 
 **voxcity** is a Python package that provides a seamless solution for grid-based 3D city model generation and urban simulation for cities worldwide. VoxCity's generator module automatically downloads building heights, tree canopy heights, land cover, and terrain elevation within a specified target area, and voxelizes buildings, trees, land cover, and terrain to generate an integrated voxel city model. The simulator module enables users to conduct environmental simulations, including solar radiation and view index analyses. Users can export the generated models using several file formats compatible with external software, such as ENVI-met (INX), Blender, and Rhino (OBJ). Try it out using the [Google Colab Demo](https://colab.research.google.com/drive/1Lofd3RawKMr6QuUsamGaF48u2MN0hfrP?usp=sharing) or your local environment.

{voxcity-0.5.8.dist-info → voxcity-0.5.10.dist-info}/RECORD

@@ -1,7 +1,7 @@
 voxcity/__init__.py,sha256=el9v3gfybHOF_GUYPeSOqN0-vCrTW0eU1mcvi0sEfeU,252
-voxcity/generator.py,sha256=XP5-_ojHvKdJ1aTY2EHDaegkRQJFYLLprTIV7zAco0k,42541
+voxcity/generator.py,sha256=Ae0dAqfrVMLmjeilO2oOm5s-TMPbnLo40Z4TFJaWf5A,42651
 voxcity/downloader/__init__.py,sha256=OgGcGxOXF4tjcEL6DhOnt13DYPTvOigUelp5xIpTqM0,171
-voxcity/downloader/citygml.py,sha256=NUqtxQ2aBjdVxxsrPGh3DFHCa1ZcRFWZb3SmLyx8byg,24479
+voxcity/downloader/citygml.py,sha256=R3DvsYJz_S5OPkeA71eEI2U7fBDLcpqdludV6gO1ihw,30305
 voxcity/downloader/eubucco.py,sha256=XCkkdEPNuWdrnuxzL80Ext37WsgiCiZGueb-aQV5rvI,14476
 voxcity/downloader/gee.py,sha256=hEN5OvQAltORYnrlPbmYcDequ6lKLmwyTbNaCZ81Vj8,16089
 voxcity/downloader/mbfp.py,sha256=pGJuXXLRuRedlORXfg8WlgAVwmKI30jxki9t-v5NejY,3972
@@ -17,7 +17,7 @@ voxcity/exporter/obj.py,sha256=M0MT9UZOVYsRJBEJea3qg1uu7NsMXagD24jQnmPaJLo,21629
 voxcity/geoprocessor/__init_.py,sha256=JzPVhhttxBWvaZ0IGX2w7OWL5bCo_TIvpHefWeNXruA,133
 voxcity/geoprocessor/draw.py,sha256=8Em2NvazFpYfFJUqG9LofNXaxdghKLL_rNuztmPwn8Q,13911
 voxcity/geoprocessor/grid.py,sha256=NzUACYEtJ3Wc348ESo_N9VbaXPtSssuF_zad7BtDcmM,56389
-voxcity/geoprocessor/mesh.py,sha256=r3cRPLgpbhjwgESBemHWWJ5pEWl2KdkRhID6mdLhios,11171
+voxcity/geoprocessor/mesh.py,sha256=FC0rgL1b8qYDlAwYwVMS0qcFwBTdqv-RFMw89sCnGOk,15124
 voxcity/geoprocessor/network.py,sha256=opb_kpUCAxDd1qtrWPStqR5reYZtVe96XxazNSen7Lk,18851
 voxcity/geoprocessor/polygon.py,sha256=8Vb2AbkpKYhq1kk2hQMc-gitmUo9pFIe910v4p1vP2g,37772
 voxcity/geoprocessor/utils.py,sha256=1BRHp-DDeOA8HG8jplY7Eo75G3oXkVGL6DGONL4BA8A,19815
@@ -28,11 +28,11 @@ voxcity/simulator/view.py,sha256=YufbLuDXrLg1d1dedM6pVyiJ7uHsqY8F2sLLnIoJvB4,749
 voxcity/utils/__init_.py,sha256=nLYrj2huBbDBNMqfchCwexGP8Tlt9O_XluVDG7MoFkw,98
 voxcity/utils/lc.py,sha256=RwPd-VY3POV3gTrBhM7TubgGb9MCd3nVah_G8iUEF7k,11562
 voxcity/utils/material.py,sha256=Vt3IID5Ft54HNJcEC4zi31BCPqi_687X3CSp7rXaRVY,5907
-voxcity/utils/visualization.py,sha256=ouDRx_KLm25P47CP3d85HTURYb6JdfT-N2frkSx24cU,88923
+voxcity/utils/visualization.py,sha256=jsKfUoRRW0yRCmJ03I7ESK1Tic_Xk1tcliw-8syr3Y0,87228
 voxcity/utils/weather.py,sha256=CFPtoqRTajwMRswswDChwQ3BW1cGsnA3orgWHgz7Ehg,26304
-voxcity-0.5.8.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.5.8.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.5.8.dist-info/METADATA,sha256=MIylY8nmUI7RuH1_Bruq4xp04c82oUyV4lL5cZ6vOws,25734
-voxcity-0.5.8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-voxcity-0.5.8.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.5.8.dist-info/RECORD,,
+voxcity-0.5.10.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.5.10.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.5.10.dist-info/METADATA,sha256=py17aZn67P-e2JouRMZVJqLFERDB-J7ccBRJ7Dc_9Jw,25885
+voxcity-0.5.10.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+voxcity-0.5.10.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.5.10.dist-info/RECORD,,