voxcity 0.6.3__py3-none-any.whl → 0.6.4__py3-none-any.whl

voxcity/simulator/solar.py

@@ -1328,9 +1328,17 @@ def get_building_solar_irradiance(
     sun_dz = np.sin(el_rad)
     sun_direction = np.array([sun_dx, sun_dy, sun_dz], dtype=np.float64)
     
-    # Extract mesh geometry data for processing
-    face_centers = building_svf_mesh.triangles_center  # Center point of each face
-    face_normals = building_svf_mesh.face_normals      # Normal vector for each face
+    # Extract mesh geometry data for processing (optionally from cache)
+    precomputed_geometry = kwargs.get("precomputed_geometry", None)
+    if precomputed_geometry is not None:
+        face_centers = precomputed_geometry.get("face_centers", building_svf_mesh.triangles_center)
+        face_normals = precomputed_geometry.get("face_normals", building_svf_mesh.face_normals)
+        face_svf_opt = precomputed_geometry.get("face_svf", None)
+        grid_bounds_real = precomputed_geometry.get("grid_bounds_real", None)
+        boundary_epsilon = precomputed_geometry.get("boundary_epsilon", None)
+    else:
+        face_centers = building_svf_mesh.triangles_center  # Center point of each face
+        face_normals = building_svf_mesh.face_normals      # Normal vector for each face
     
     # Extract Sky View Factor data from mesh metadata
     if hasattr(building_svf_mesh, 'metadata') and ('svf' in building_svf_mesh.metadata):
@@ -1339,20 +1347,27 @@ def get_building_solar_irradiance(
         # Initialize with zeros if SVF not available (should be pre-calculated)
         face_svf = np.zeros(len(building_svf_mesh.faces), dtype=np.float64)
     
-    # Set up domain boundaries for boundary face detection
-    grid_shape = voxel_data.shape
-    grid_bounds_voxel = np.array([[0,0,0],[grid_shape[0], grid_shape[1], grid_shape[2]]], dtype=np.float64)
-    grid_bounds_real = grid_bounds_voxel * meshsize
-    boundary_epsilon = meshsize * 0.05  # Small tolerance for boundary detection
+    # Set up domain boundaries for boundary face detection (use cache if available)
+    if grid_bounds_real is None or boundary_epsilon is None:
+        grid_shape = voxel_data.shape
+        grid_bounds_voxel = np.array([[0,0,0],[grid_shape[0], grid_shape[1], grid_shape[2]]], dtype=np.float64)
+        grid_bounds_real = grid_bounds_voxel * meshsize
+        boundary_epsilon = meshsize * 0.05  # Small tolerance for boundary detection
     
     # Optional fast path using masked DDA kernel
     fast_path = kwargs.get("fast_path", True)
+    precomputed_masks = kwargs.get("precomputed_masks", None)
     t0 = time.time()
     if fast_path:
-        # Prepare masks once
-        vox_is_tree = (voxel_data == -2)
-        vox_is_opaque = (voxel_data != 0) & (~vox_is_tree)
-        att = float(np.exp(-tree_k * tree_lad * meshsize))
+        # Prepare masks (reuse cache when possible)
+        if precomputed_masks is not None:
+            vox_is_tree = precomputed_masks.get("vox_is_tree", (voxel_data == -2))
+            vox_is_opaque = precomputed_masks.get("vox_is_opaque", (voxel_data != 0) & (voxel_data != -2))
+            att = float(precomputed_masks.get("att", np.exp(-tree_k * tree_lad * meshsize)))
+        else:
+            vox_is_tree = (voxel_data == -2)
+            vox_is_opaque = (voxel_data != 0) & (~vox_is_tree)
+            att = float(np.exp(-tree_k * tree_lad * meshsize))
 
         face_direct, face_diffuse, face_global = compute_solar_irradiance_for_all_faces_masked(
             face_centers.astype(np.float64),
@@ -1373,7 +1388,7 @@ def get_building_solar_irradiance(
         face_direct, face_diffuse, face_global = compute_solar_irradiance_for_all_faces(
             face_centers,
             face_normals,
-            face_svf,
+            face_svf_opt if (precomputed_geometry is not None and face_svf_opt is not None) else face_svf,
             sun_direction,
             direct_normal_irradiance,
             diffuse_irradiance,
@@ -1757,13 +1772,29 @@ def get_cumulative_building_solar_irradiance(
     face_cum_global  = np.zeros(n_faces, dtype=np.float64)
 
     # Pre-extract mesh face arrays and domain bounds for fast path
-    face_centers = building_svf_mesh.triangles_center
-    face_normals = building_svf_mesh.face_normals
-    face_svf = building_svf_mesh.metadata['svf'] if ('svf' in building_svf_mesh.metadata) else np.zeros(n_faces, dtype=np.float64)
-    grid_shape = voxel_data.shape
-    grid_bounds_voxel = np.array([[0, 0, 0], [grid_shape[0], grid_shape[1], grid_shape[2]]], dtype=np.float64)
-    grid_bounds_real = grid_bounds_voxel * meshsize
-    boundary_epsilon = meshsize * 0.05
+    # Optionally reuse precomputed geometry/bounds
+    precomputed_geometry = kwargs.get("precomputed_geometry", None)
+    if precomputed_geometry is not None:
+        face_centers = precomputed_geometry.get("face_centers", building_svf_mesh.triangles_center)
+        face_normals = precomputed_geometry.get("face_normals", building_svf_mesh.face_normals)
+        face_svf = precomputed_geometry.get(
+            "face_svf",
+            building_svf_mesh.metadata['svf'] if ('svf' in building_svf_mesh.metadata) else np.zeros(n_faces, dtype=np.float64)
+        )
+        grid_bounds_real = precomputed_geometry.get("grid_bounds_real", None)
+        boundary_epsilon = precomputed_geometry.get("boundary_epsilon", None)
+    else:
+        face_centers = building_svf_mesh.triangles_center
+        face_normals = building_svf_mesh.face_normals
+        face_svf = building_svf_mesh.metadata['svf'] if ('svf' in building_svf_mesh.metadata) else np.zeros(n_faces, dtype=np.float64)
+        grid_bounds_real = None
+        boundary_epsilon = None
+
+    if grid_bounds_real is None or boundary_epsilon is None:
+        grid_shape = voxel_data.shape
+        grid_bounds_voxel = np.array([[0, 0, 0], [grid_shape[0], grid_shape[1], grid_shape[2]]], dtype=np.float64)
+        grid_bounds_real = grid_bounds_voxel * meshsize
+        boundary_epsilon = meshsize * 0.05
 
     # Params used in Numba kernel
     hit_values = (0,)      # sky
@@ -1779,20 +1810,28 @@ def get_cumulative_building_solar_irradiance(
     progress_every = max(1, total_steps // 20)  # ~5% steps
 
     # Pre-cast stable arrays to avoid repeated allocations
-    face_centers64 = building_svf_mesh.triangles_center.astype(np.float64)
-    face_normals64 = building_svf_mesh.face_normals.astype(np.float64)
+    face_centers64 = (face_centers if isinstance(face_centers, np.ndarray) else building_svf_mesh.triangles_center).astype(np.float64)
+    face_normals64 = (face_normals if isinstance(face_normals, np.ndarray) else building_svf_mesh.face_normals).astype(np.float64)
     face_svf64 = face_svf.astype(np.float64)
     x_min, y_min, z_min = grid_bounds_real[0, 0], grid_bounds_real[0, 1], grid_bounds_real[0, 2]
     x_max, y_max, z_max = grid_bounds_real[1, 0], grid_bounds_real[1, 1], grid_bounds_real[1, 2]
 
     if fast_path:
         # Use masked cumulative kernel with chunking to minimize Python overhead
-        vox_is_tree = (voxel_data == -2)
-        vox_is_opaque = (voxel_data != 0) & (~vox_is_tree)
-        att = float(np.exp(-tree_k * tree_lad * meshsize))
+        precomputed_masks = kwargs.get("precomputed_masks", None)
+        if precomputed_masks is not None:
+            vox_is_tree = precomputed_masks.get("vox_is_tree", (voxel_data == -2))
+            vox_is_opaque = precomputed_masks.get("vox_is_opaque", (voxel_data != 0) & (voxel_data != -2))
+            att = float(precomputed_masks.get("att", np.exp(-tree_k * tree_lad * meshsize)))
+        else:
+            vox_is_tree = (voxel_data == -2)
+            vox_is_opaque = (voxel_data != 0) & (~vox_is_tree)
+            att = float(np.exp(-tree_k * tree_lad * meshsize))
 
         # Auto-tune chunk size if user didn't pass one
         time_batch_size = _auto_time_batch_size(n_faces, total_steps, kwargs.get("time_batch_size", None))
+        if progress_report:
+            print(f"Faces: {n_faces:,}, Timesteps: {total_steps:,}, Batch size: {time_batch_size}")
 
         for start in range(0, total_steps, time_batch_size):
             end = min(start + time_batch_size, total_steps)
@@ -2023,6 +2062,38 @@ def get_building_global_solar_irradiance_using_epw(
         )
 
     if progress_report:
+        print(f"SVF ready. Faces: {len(building_svf_mesh.faces):,}")
+
+    # Step 2: Build precomputed caches (geometry, masks, attenuation) for speed
+    precomputed_geometry = {}
+    try:
+        grid_shape = voxel_data.shape
+        grid_bounds_voxel = np.array([[0, 0, 0], [grid_shape[0], grid_shape[1], grid_shape[2]]], dtype=np.float64)
+        grid_bounds_real = grid_bounds_voxel * meshsize
+        boundary_epsilon = meshsize * 0.05
+        precomputed_geometry = {
+            'face_centers': building_svf_mesh.triangles_center,
+            'face_normals': building_svf_mesh.face_normals,
+            'face_svf': building_svf_mesh.metadata['svf'] if ('svf' in building_svf_mesh.metadata) else None,
+            'grid_bounds_real': grid_bounds_real,
+            'boundary_epsilon': boundary_epsilon,
+        }
+    except Exception:
+        # Fallback silently
+        precomputed_geometry = {}
+
+    tree_k = kwargs.get("tree_k", 0.6)
+    tree_lad = kwargs.get("tree_lad", 1.0)
+    precomputed_masks = {
+        'vox_is_tree': (voxel_data == -2),
+        'vox_is_opaque': (voxel_data != 0) & (voxel_data != -2),
+        'att': float(np.exp(-tree_k * tree_lad * meshsize)),
+    }
+
+    if progress_report:
+        t_cnt = int(np.count_nonzero(precomputed_masks['vox_is_tree']))
+        b_cnt = int(np.count_nonzero(voxel_data == -3)) if hasattr(voxel_data, 'shape') else 0
+        print(f"Precomputed caches: trees={t_cnt:,}, buildings={b_cnt:,}, tree_att_per_voxel={precomputed_masks['att']:.4f}")
         print(f"Processing Solar Irradiance for building surfaces...")
     result_mesh = None
     
@@ -2084,6 +2155,9 @@ def get_building_global_solar_irradiance_using_epw(
                 direct_normal_irradiance,
                 diffuse_irradiance,
                 progress_report=progress_report,
+                fast_path=fast_path,
+                precomputed_geometry=precomputed_geometry,
+                precomputed_masks=precomputed_masks,
                 **_call_kwargs
             )
 
@@ -2146,6 +2220,8 @@ def get_building_global_solar_irradiance_using_epw(
             progress_report=progress_report,
             fast_path=fast_path,
             precomputed_solar_positions=solar_positions,
+            precomputed_geometry=precomputed_geometry,
+            precomputed_masks=precomputed_masks,
             colormap=kwargs.get('colormap', 'jet'),
             show_each_timestep=kwargs.get('show_each_timestep', False),
             obj_export=kwargs.get('obj_export', False),

voxcity/utils/visualization.py

@@ -1654,7 +1654,8 @@ def visualize_numerical_grid_on_basemap(grid, rectangle_vertices, meshsize, valu
 
 def visualize_numerical_gdf_on_basemap(gdf, value_name="value", cmap='viridis', vmin=None, vmax=None,
                             alpha=0.6, figsize=(12, 8), basemap='CartoDB light',
-                            show_edge=False, edge_color='black', edge_width=0.5):
+                            show_edge=False, edge_color='black', edge_width=0.5,
+                            input_crs=None):
     """Visualizes a GeoDataFrame with numerical values on a basemap.
     
     Args:
@@ -1669,9 +1670,34 @@ def visualize_numerical_gdf_on_basemap(gdf, value_name="value", cmap='viridis',
         show_edge: Whether to show cell edges (default: False)
         edge_color: Color of cell edges (default: 'black')
         edge_width: Width of cell edges (default: 0.5)
+        input_crs: Optional CRS to assign if the GeoDataFrame has no CRS. If not provided
+            and CRS is missing, the function will attempt to infer WGS84 (EPSG:4326)
+            when coordinates look like lon/lat; otherwise it will raise a clear error.
     """
+    # Ensure CRS is defined; if missing, assign or infer
+    if gdf.crs is None:
+        if input_crs is not None:
+            gdf = gdf.set_crs(input_crs, allow_override=True)
+        else:
+            # Try to infer WGS84 if bounds look like lon/lat
+            try:
+                minx, miny, maxx, maxy = gdf.total_bounds
+                looks_like_lonlat = (
+                    -180.0 <= minx <= 180.0 and -180.0 <= maxx <= 180.0 and
+                    -90.0 <= miny <= 90.0 and -90.0 <= maxy <= 90.0
+                )
+            except Exception:
+                looks_like_lonlat = False
+            if looks_like_lonlat:
+                gdf = gdf.set_crs("EPSG:4326", allow_override=True)
+            else:
+                raise ValueError(
+                    "Input GeoDataFrame has no CRS. Provide 'input_crs' (e.g., 'EPSG:4326' or 'EPSG:XXXX') "
+                    "or set gdf.crs before calling visualize_numerical_gdf_on_basemap."
+                )
+
     # Convert to Web Mercator if not already in that CRS
-    if gdf.crs != 'EPSG:3857':
+    if str(gdf.crs) != 'EPSG:3857':
         gdf_web = gdf.to_crs(epsg=3857)
     else:
         gdf_web = gdf

{voxcity-0.6.3.dist-info → voxcity-0.6.4.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.6.3
+Version: 0.6.4
 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>
+Author-email: Kunihiko Fujiwara <fujiwara.kunihiko@takenaka.co.jp>
+Maintainer-email: Kunihiko Fujiwara <fujiwara.kunihiko@takenaka.co.jp>
 License: MIT
 Project-URL: bugs, https://github.com/kunifujiwara/voxcity/issues
 Project-URL: changelog, https://github.com/kunifujiwara/voxcity/blob/master/changelog.md

{voxcity-0.6.3.dist-info → voxcity-0.6.4.dist-info}/RECORD

@@ -3,7 +3,7 @@ voxcity/generator.py,sha256=J61i6-bvgOlNQWgxlkSvOZ7CLAjRgh_XRYwslWkKxVM,55756
 voxcity/downloader/__init__.py,sha256=o_T_EU7hZLGyXxX9wVWn1x-OAa3ThGYdnpgB1_2v3AE,151
 voxcity/downloader/citygml.py,sha256=jVeHCLlJTf7k55OQGX0lZGQAngz_DD2V5TldSqRFlvc,36024
 voxcity/downloader/eubucco.py,sha256=ln1YNaaOgJfxNfCtVbYaMm775-bUvpAA_LDv60_i22w,17875
-voxcity/downloader/gee.py,sha256=O6HhQnUUumg_tTm4pP_cuyu5YjupDA1uKFxZWxD-i2E,23205
+voxcity/downloader/gee.py,sha256=nvJvYqcSZyyontRtG2cFeb__ZJfeY4rRN1NBPORxLwQ,23557
 voxcity/downloader/mbfp.py,sha256=UXDVjsO0fnb0fSal9yqrSFEIBThnRmnutnp08kZTmCA,6595
 voxcity/downloader/oemj.py,sha256=iDacTpiqn7RAXuqyEtHP29m0Cycwta5sMy9-GdvX3Fg,12293
 voxcity/downloader/osm.py,sha256=9nOVcVE50N76F5uquJbNIFr8Xajff4ac2Uj2oSGcFrc,42591
@@ -20,19 +20,19 @@ voxcity/geoprocessor/grid.py,sha256=wrlOsX8cD0W5xCnOS5IOHy8DNqDGTM1I2270eVs787c,
 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
-voxcity/geoprocessor/utils.py,sha256=DVg3EMRytLQLEQeXLvNgjt1Ynoa689EsD-To-14xgSQ,30369
+voxcity/geoprocessor/utils.py,sha256=s17XpgkLBelmNCk2wcUwTK1tEiFpguWR2BF_n7K17jg,31378
 voxcity/simulator/__init__.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/simulator/solar.py,sha256=h_jVPjJ8wKl8z8Tx0EcVJBzNRKSr8WXBL9bVCgJpyZE,101788
+voxcity/simulator/solar.py,sha256=4WBFgMm25-9rZ5bSGBmIpaxq2mma9X46Fom7UvGEnT8,106361
 voxcity/simulator/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
 voxcity/simulator/view.py,sha256=ClmRL0Yw3-4_jVF2c_w5KRxGWloVbkpcr9qwwL4OVJc,94258
 voxcity/utils/__init__.py,sha256=Q-NYCqYnAAaF80KuNwpqIjbE7Ec3Gr4y_khMLIMhJrg,68
 voxcity/utils/lc.py,sha256=722Gz3lPbgAp0mmTZ-g-QKBbAnbxrcgaYwb1sa7q8Sk,16189
 voxcity/utils/material.py,sha256=H8K8Lq4wBL6dQtgj7esUW2U6wLCOTeOtelkTDJoRgMo,10007
-voxcity/utils/visualization.py,sha256=Hk31pVOZ3q8K0QaudAMSqKUquF1Hd1Hug8626D4JJ74,115143
+voxcity/utils/visualization.py,sha256=ZR9N-XKfydeSStO53IM2hGXyZJoeBiAyIMWw9Cb2MPM,116449
 voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.6.3.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.6.3.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.6.3.dist-info/METADATA,sha256=S5Zctnc0Kyudy7rQxK8ziE2wYzKKDGWniUhwFhmMnOI,26723
-voxcity-0.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-voxcity-0.6.3.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.6.3.dist-info/RECORD,,
+voxcity-0.6.4.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.4.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.4.dist-info/METADATA,sha256=DXSMc39qi5ebhxnONiV2LWsPX-nCWiau4yMstqwl-jA,26749
+voxcity-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+voxcity-0.6.4.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.6.4.dist-info/RECORD,,