voxcity 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

voxcity/exporter/cityles.py

@@ -190,7 +190,7 @@ def _build_index_to_cityles_map(land_cover_source):
 
 
 def export_topog(building_height_grid, building_id_grid, output_path, 
-                 building_material='default'):
+                 building_material='default', cityles_landuse_grid=None):
     """
     Export topog.txt file for CityLES
     
@@ -226,8 +226,17 @@ def export_topog(building_height_grid, building_id_grid, output_path,
                 i_1based = i + 1
                 j_1based = j + 1
                 height = float(building_height_grid[j, i])
+                # Decide material code per cell
+                if cityles_landuse_grid is not None:
+                    cell_lu = int(cityles_landuse_grid[j, i])
+                    material_code_cell = cell_lu + 100
+                else:
+                    if height > 0:
+                        material_code_cell = material_code
+                    else:
+                        material_code_cell = 102
                 # Format: i j height material_code depth1 depth2 changed_material
-                f.write(f"{i_1based} {j_1based} {height:.1f} {material_code} 0.0 0.0 102\n")
+                f.write(f"{i_1based} {j_1based} {height:.1f} {material_code_cell} 0.0 0.0 102\n")
 
 
 def export_landuse(land_cover_grid, output_path, land_cover_source=None):
@@ -254,6 +263,8 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
 
     # Create mapping statistics
     mapping_stats = {}
+    # Prepare grid to return
+    cityles_landuse_grid = np.zeros((ny, nx), dtype=int)
 
     with open(filename, 'w') as f:
         # Write in row-major order (j varies first, then i)
@@ -263,6 +274,8 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
                 cityles_code = index_to_code.get(idx, 4)
                 f.write(f"{cityles_code}\n")
 
+                cityles_landuse_grid[j, i] = cityles_code
+
                 # Track mapping statistics
                 if idx not in mapping_stats:
                     mapping_stats[idx] = {'cityles_code': cityles_code, 'count': 0}
@@ -277,6 +290,8 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
         class_name = class_names[idx] if 0 <= idx < len(class_names) else 'Unknown'
         print(f"  {idx}: {class_name} -> CityLES {stats['cityles_code']}: "
               f"{stats['count']} cells ({percentage:.1f}%)")
+    
+    return cityles_landuse_grid
 
 
 def export_dem(dem_grid, output_path):
@@ -434,11 +449,17 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
     print(f"Land cover source: {land_cover_source}")
     
     # Export individual files
-    print("\nExporting topog.txt...")
-    export_topog(building_height_grid, building_id_grid, output_path, building_material)
-    
     print("\nExporting landuse.txt...")
-    export_landuse(land_cover_grid, output_path, land_cover_source)
+    cityles_landuse_grid = export_landuse(land_cover_grid, output_path, land_cover_source)
+
+    print("\nExporting topog.txt...")
+    export_topog(
+        building_height_grid,
+        building_id_grid,
+        output_path,
+        building_material,
+        cityles_landuse_grid=cityles_landuse_grid,
+    )
     
     print("\nExporting dem.txt...")
     export_dem(dem_grid, output_path)

voxcity/geoprocessor/grid.py

@@ -263,14 +263,19 @@ def calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize):
         >>> mesh = 10                    # Desired 10-unit mesh
         >>> grid_size, adj_mesh = calculate_grid_size(side1, side2, u, v, mesh)
     """
-    # Calculate number of cells needed in each direction, rounding to nearest integer
-    grid_size_0 = int(np.linalg.norm(side_1) / np.linalg.norm(meshsize * u_vec) + 0.5)
-    grid_size_1 = int(np.linalg.norm(side_2) / np.linalg.norm(meshsize * v_vec) + 0.5)
-    
-    # Adjust mesh sizes to exactly fit the desired area with the calculated number of cells
-    adjusted_mesh_size_0 = meshsize *  np.linalg.norm(meshsize * u_vec) * grid_size_0 / np.linalg.norm(side_1)
-    adjusted_mesh_size_1 = meshsize *  np.linalg.norm(meshsize * v_vec) * grid_size_1 / np.linalg.norm(side_2)
-    
+    # Calculate total side lengths in meters using the relationship between side vectors and unit vectors
+    # u_vec and v_vec represent degrees per meter along each side direction
+    dist_side_1_m = np.linalg.norm(side_1) / (np.linalg.norm(u_vec) + 1e-12)
+    dist_side_2_m = np.linalg.norm(side_2) / (np.linalg.norm(v_vec) + 1e-12)
+
+    # Calculate number of cells (nx along u, ny along v), rounding to nearest integer and ensuring at least 1
+    grid_size_0 = max(1, int(dist_side_1_m / meshsize + 0.5))
+    grid_size_1 = max(1, int(dist_side_2_m / meshsize + 0.5))
+
+    # Adjust mesh sizes (in meters) to exactly fit the sides with the calculated number of cells
+    adjusted_mesh_size_0 = dist_side_1_m / grid_size_0
+    adjusted_mesh_size_1 = dist_side_2_m / grid_size_1
+
     return (grid_size_0, grid_size_1), (adjusted_mesh_size_0, adjusted_mesh_size_1)
 
 def create_coordinate_mesh(origin, grid_size, adjusted_meshsize, u_vec, v_vec):
@@ -908,12 +913,19 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
     Process buildings using fast rasterio-based approach.
     Faster but less precise for overlapping footprints.
     """
-    # Set up transform for rasterio
-    min_x, min_y = origin[0], origin[1]
-    max_corner = origin + grid_size[0] * adjusted_meshsize[0] * u_vec + grid_size[1] * adjusted_meshsize[1] * v_vec
-    max_x, max_y = max_corner[0], max_corner[1]
-    
-    transform = from_bounds(min_x, min_y, max_x, max_y, grid_size[0], grid_size[1])
+    # Set up transform for rasterio using rotated basis defined by u_vec and v_vec
+    # Step vectors in coordinate units (degrees) per cell
+    u_step = adjusted_meshsize[0] * u_vec
+    v_step = adjusted_meshsize[1] * v_vec
+
+    # Define the top-left corner so that row=0 is the northern edge
+    top_left = origin + grid_size[1] * v_step
+
+    # Affine transform mapping (col, row) -> (x, y)
+    # x = a*col + b*row + c ; y = d*col + e*row + f
+    # col increases along u_step; row increases southward, hence -v_step
+    transform = Affine(u_step[0], -v_step[0], top_left[0],
+                       u_step[1], -v_step[1], top_left[1])
     
     # Process buildings data
     filtered_gdf = filtered_gdf.copy()
@@ -934,9 +946,9 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
     regular_buildings = filtered_gdf[~filtered_gdf['is_inner']].copy()
     regular_buildings = regular_buildings.sort_values('height', ascending=True, na_position='first')
     
-    # Initialize grids
-    building_height_grid = np.zeros(grid_size, dtype=np.float64)
-    building_id_grid = np.zeros(grid_size, dtype=np.float64)
+    # Temporary raster grids in rasterio's (rows=ny, cols=nx) order
+    height_raster = np.zeros((grid_size[1], grid_size[0]), dtype=np.float64)
+    id_raster = np.zeros((grid_size[1], grid_size[0]), dtype=np.float64)
     
     # Vectorized rasterization
     if len(regular_buildings) > 0:
@@ -949,9 +961,9 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
                            if pd.notna(height) and height > 0]
             
             if height_shapes:
-                building_height_grid = features.rasterize(
+                height_raster = features.rasterize(
                     height_shapes,
-                    out_shape=grid_size,
+                    out_shape=(grid_size[1], grid_size[0]),
                     transform=transform,
                     fill=0,
                     dtype=np.float64
@@ -962,9 +974,9 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
                         zip(valid_buildings.geometry, valid_buildings['id'])]
             
             if id_shapes:
-                building_id_grid = features.rasterize(
+                id_raster = features.rasterize(
                     id_shapes,
-                    out_shape=grid_size,
+                    out_shape=(grid_size[1], grid_size[0]),
                     transform=transform,
                     fill=0,
                     dtype=np.float64
@@ -977,17 +989,17 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
         if inner_shapes:
             inner_mask = features.rasterize(
                 inner_shapes,
-                out_shape=grid_size,
+                out_shape=(grid_size[1], grid_size[0]),
                 transform=transform,
                 fill=0,
                 dtype=np.uint8
             )
-            building_height_grid[inner_mask > 0] = 0
-            building_id_grid[inner_mask > 0] = 0
+            height_raster[inner_mask > 0] = 0
+            id_raster[inner_mask > 0] = 0
     
     # Simplified min_height grid 
     building_min_height_grid = np.empty(grid_size, dtype=object)
-    min_heights = np.zeros(grid_size, dtype=np.float64)
+    min_heights_raster = np.zeros((grid_size[1], grid_size[0]), dtype=np.float64)
     
     if len(regular_buildings) > 0:
         valid_buildings = regular_buildings[regular_buildings.geometry.is_valid].copy()
@@ -997,27 +1009,27 @@ def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u
                                if pd.notna(min_h)]
             
             if min_height_shapes:
-                min_heights = features.rasterize(
+                min_heights_raster = features.rasterize(
                     min_height_shapes,
-                    out_shape=grid_size,
+                    out_shape=(grid_size[1], grid_size[0]),
                     transform=transform,
                     fill=0,
                     dtype=np.float64
                 )
     
     # Convert to list format (simplified)
+    # Convert raster (ny, nx) to internal orientation (nx, ny) with north-up
+    building_height_grid = np.flipud(height_raster).T
+    building_id_grid = np.flipud(id_raster).T
+    min_heights = np.flipud(min_heights_raster).T
+
     for i in range(grid_size[0]):
         for j in range(grid_size[1]):
             if building_height_grid[i, j] > 0:
                 building_min_height_grid[i, j] = [[min_heights[i, j], building_height_grid[i, j]]]
             else:
                 building_min_height_grid[i, j] = []
-    
-    # Fix north-south orientation by flipping grids
-    building_height_grid = np.flipud(building_height_grid)
-    building_id_grid = np.flipud(building_id_grid)
-    building_min_height_grid = np.flipud(building_min_height_grid)
-    
+
     return building_height_grid, building_min_height_grid, building_id_grid, filtered_gdf
 
 def create_building_height_grid_from_open_building_temporal_polygon(meshsize, rectangle_vertices, output_dir):        

{voxcity-0.6.5.dist-info → voxcity-0.6.7.dist-info}/METADATA

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

{voxcity-0.6.5.dist-info → voxcity-0.6.7.dist-info}/RECORD

@@ -9,14 +9,14 @@ voxcity/downloader/osm.py,sha256=9nOVcVE50N76F5uquJbNIFr8Xajff4ac2Uj2oSGcFrc,425
 voxcity/downloader/overture.py,sha256=4YG2DMwUSSyZKUw_o8cGhMmAkPJon82aPqOFBvrre-Y,11987
 voxcity/downloader/utils.py,sha256=tz6wt4B9BhEOyvoF5OYXlr8rUd5cBEDedWL3j__oT70,3099
 voxcity/exporter/__init__.py,sha256=dvyWJ184Eik9tFc0VviGbzTQzZi7O0JNyrqi_n39pVI,94
-voxcity/exporter/cityles.py,sha256=Xe6VAt_vtfaMsfizXvc-WhzzemwweJz9iESJRvfVCpA,16665
+voxcity/exporter/cityles.py,sha256=OhsGODC8bFq0MTGc0nBnqRyqnqg1JXL7UaL66a-CKsQ,17418
 voxcity/exporter/envimet.py,sha256=Sh7s1JdQ6SgT_L2Xd_c4gtEGWK2hTS87bccaoIqik-s,31105
 voxcity/exporter/magicavoxel.py,sha256=SfGEgTZRlossKx3Xrv9d3iKSX-HmfQJEL9lZHgWMDX4,12782
 voxcity/exporter/obj.py,sha256=h1_aInpemcsu96fSTwjKMqX2VZAFYbZbElWd4M1ogyI,27973
 voxcity/generator.py,sha256=J61i6-bvgOlNQWgxlkSvOZ7CLAjRgh_XRYwslWkKxVM,55756
 voxcity/geoprocessor/__init__.py,sha256=WYxcAQrjGucIvGHF0JTC6rONZzL3kCms1S2vpzS6KaU,127
 voxcity/geoprocessor/draw.py,sha256=avXQwbGQWG3ZPPI8mwy0YN0K_aG4NMBdXI0vDg7yad0,35837
-voxcity/geoprocessor/grid.py,sha256=wrlOsX8cD0W5xCnOS5IOHy8DNqDGTM1I2270eVs787c,70602
+voxcity/geoprocessor/grid.py,sha256=D4sqoIGK2P1U8uuVQZ-447SD0Yrv6qS_zlmDtKoLDe8,71257
 voxcity/geoprocessor/mesh.py,sha256=A7uaCMWfm82KEoYPfQYpxv6xMtQKaU2PBVDfKTpngqg,32027
 voxcity/geoprocessor/network.py,sha256=YynqR0nq_NUra_cQ3Z_56KxfRia1b6-hIzGCj3QT-wE,25137
 voxcity/geoprocessor/polygon.py,sha256=DfzXf6R-qoWXEZv1z1aHCVfr-DCuCFw6lieQT5cNHPA,61188
@@ -30,8 +30,8 @@ voxcity/utils/lc.py,sha256=722Gz3lPbgAp0mmTZ-g-QKBbAnbxrcgaYwb1sa7q8Sk,16189
 voxcity/utils/material.py,sha256=H8K8Lq4wBL6dQtgj7esUW2U6wLCOTeOtelkTDJoRgMo,10007
 voxcity/utils/visualization.py,sha256=ZR9N-XKfydeSStO53IM2hGXyZJoeBiAyIMWw9Cb2MPM,116449
 voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.6.5.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.6.5.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.6.5.dist-info/METADATA,sha256=ebnpwEnZYPa0aSabyohTodRj8IlgoENztRWL-KG4DbU,26091
-voxcity-0.6.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-voxcity-0.6.5.dist-info/RECORD,,
+voxcity-0.6.7.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.7.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.7.dist-info/METADATA,sha256=lICJOYiGbMdF2Lee90GLEP-KBz3S71jHDaHucZrYs7g,26091
+voxcity-0.6.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+voxcity-0.6.7.dist-info/RECORD,,