voxcity 0.6.14__py3-none-any.whl → 0.6.16__py3-none-any.whl

voxcity/geoprocessor/draw.py

@@ -1096,10 +1096,7 @@ def draw_additional_trees(tree_gdf=None, initial_center=None, zoom=17, rectangle
 
                 tree_layers[next_tree_id] = circle
 
-                with status_output:
-                    print(f"Tree {next_tree_id} added at (lon, lat)=({lon:.6f}, {lat:.6f})")
-                    print(f"Top: {new_row['top_height']} m, Bottom: {new_row['bottom_height']} m, Crown: {new_row['crown_diameter']} m")
-                    print(f"Total trees: {len(updated_trees)}")
+                # Suppress status prints on add
             else:
                 # Remove mode: find the nearest tree within its crown radius + 5m
                 candidate_id = None
@@ -1127,12 +1124,10 @@ def draw_additional_trees(tree_gdf=None, initial_center=None, zoom=17, rectangle
                     # Remove from gdf
                     updated_trees.drop(index=candidate_idx, inplace=True)
                     updated_trees.reset_index(drop=True, inplace=True)
-                    with status_output:
-                        print(f"Removed tree {candidate_id} (distance {candidate_dist:.2f} m)")
-                        print(f"Total trees: {len(updated_trees)}")
+                    # Suppress status prints on remove
                 else:
-                    with status_output:
-                        print("No tree near the clicked location to remove")
+                    # Suppress status prints when nothing to remove
+                    pass
         elif kwargs.get('type') == 'mousemove':
             lat, lon = kwargs.get('coordinates', (None, None))
             if lat is None or lon is None:

voxcity/geoprocessor/grid.py

@@ -1565,4 +1565,169 @@ def create_dem_grid_from_gdf_polygon(terrain_gdf, mesh_size, polygon):
     # By default, row=0 is the "north/top" row, row=-1 is "south/bottom" row.
     # If you prefer the bottom row as index=0, you'd do: np.flipud(dem_grid)
 
-    return np.flipud(dem_grid)
+    return np.flipud(dem_grid)
+
+def create_canopy_grids_from_tree_gdf(tree_gdf, meshsize, rectangle_vertices):
+    """
+    Create canopy top and bottom height grids from a tree GeoDataFrame.
+
+    Assumptions:
+    - Each tree is a point with attributes: 'top_height', 'bottom_height', 'crown_diameter'.
+    - The crown is modeled as a solid of revolution with an ellipsoidal vertical profile.
+      For a tree with top H_t, bottom H_b and crown radius R = crown_diameter/2,
+      at a horizontal distance r (r <= R) from the tree center:
+        z_top(r) = z0 + a * sqrt(1 - (r/R)^2)
+        z_bot(r) = z0 - a * sqrt(1 - (r/R)^2)
+      where a = (H_t - H_b)/2 and z0 = (H_t + H_b)/2.
+
+    The function outputs two grids (shape: (nx, ny) consistent with other grid functions):
+    - canopy_height_grid: maximum canopy top height per cell across trees
+    - canopy_bottom_height_grid: maximum canopy bottom height per cell across trees
+
+    Args:
+        tree_gdf (geopandas.GeoDataFrame): Tree points with required columns.
+        meshsize (float): Grid spacing in meters.
+        rectangle_vertices (list[tuple]): 4 vertices [(lon,lat), ...] defining the grid rectangle.
+
+    Returns:
+        tuple[np.ndarray, np.ndarray]: (canopy_height_grid, canopy_bottom_height_grid)
+    """
+
+    # Validate and prepare input GeoDataFrame
+    if tree_gdf is None or len(tree_gdf) == 0:
+        return np.array([]), np.array([])
+
+    required_cols = ['top_height', 'bottom_height', 'crown_diameter', 'geometry']
+    for col in required_cols:
+        if col not in tree_gdf.columns:
+            raise ValueError(f"tree_gdf must contain '{col}' column.")
+
+    # Ensure CRS is WGS84
+    if tree_gdf.crs is None:
+        warnings.warn("tree_gdf has no CRS. Assuming EPSG:4326.")
+        tree_gdf = tree_gdf.set_crs(epsg=4326)
+    elif tree_gdf.crs.to_epsg() != 4326:
+        tree_gdf = tree_gdf.to_crs(epsg=4326)
+
+    # Grid setup consistent with building/land cover grid functions
+    geod = initialize_geod()
+    vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
+
+    dist_side_1 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_1[0], vertex_1[1])
+    dist_side_2 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_3[0], vertex_3[1])
+
+    side_1 = np.array(vertex_1) - np.array(vertex_0)
+    side_2 = np.array(vertex_3) - np.array(vertex_0)
+    u_vec = normalize_to_one_meter(side_1, dist_side_1)
+    v_vec = normalize_to_one_meter(side_2, dist_side_2)
+
+    origin = np.array(rectangle_vertices[0])
+    grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+
+    nx, ny = grid_size[0], grid_size[1]
+
+    # Precompute metric cell-center coordinates in grid's (u,v) metric space (meters from origin)
+    i_centers_m = (np.arange(nx) + 0.5) * adjusted_meshsize[0]
+    j_centers_m = (np.arange(ny) + 0.5) * adjusted_meshsize[1]
+
+    # Initialize output grids
+    canopy_top = np.zeros((nx, ny), dtype=float)
+    canopy_bottom = np.zeros((nx, ny), dtype=float)
+
+    # Matrix to convert lon/lat offsets to metric (u,v) using u_vec, v_vec
+    # delta_lonlat ≈ [u_vec v_vec] @ [alpha; beta], where alpha/beta are meters along u/v
+    transform_mat = np.column_stack((u_vec, v_vec))  # shape (2,2)
+    try:
+        transform_inv = np.linalg.inv(transform_mat)
+    except np.linalg.LinAlgError:
+        # Fallback if u_vec/v_vec are degenerate (shouldn't happen for proper rectangles)
+        transform_inv = np.linalg.pinv(transform_mat)
+
+    # Iterate trees and accumulate ellipsoidal canopy surfaces
+    for _, row in tree_gdf.iterrows():
+        geom = row['geometry']
+        if geom is None or not hasattr(geom, 'x'):
+            continue
+
+        top_h = float(row.get('top_height', 0.0) or 0.0)
+        bot_h = float(row.get('bottom_height', 0.0) or 0.0)
+        dia = float(row.get('crown_diameter', 0.0) or 0.0)
+
+        # Sanity checks and clamps
+        if dia <= 0 or top_h <= 0:
+            continue
+        if bot_h < 0:
+            bot_h = 0.0
+        if bot_h > top_h:
+            top_h, bot_h = bot_h, top_h
+
+        R = dia / 2.0  # radius (meters)
+        a = max((top_h - bot_h) / 2.0, 0.0)
+        z0 = (top_h + bot_h) / 2.0
+        if a == 0:
+            # Flat disk between bot_h and top_h collapses; treat as constant top/bottom
+            a = 0.0
+
+        # Tree center in lon/lat
+        tree_lon = float(geom.x)
+        tree_lat = float(geom.y)
+
+        # Map tree center to (u,v) metric coordinates relative to origin
+        delta = np.array([tree_lon, tree_lat]) - origin
+        alpha_beta = transform_inv @ delta  # meters along u (alpha) and v (beta)
+        alpha_m = alpha_beta[0]
+        beta_m = alpha_beta[1]
+
+        # Determine affected index ranges (bounding box in grid indices)
+        # Convert radius in meters to index offsets along u and v
+        du_cells = int(R / adjusted_meshsize[0] + 2)
+        dv_cells = int(R / adjusted_meshsize[1] + 2)
+
+        i_center_idx = int(alpha_m / adjusted_meshsize[0])
+        j_center_idx = int(beta_m / adjusted_meshsize[1])
+
+        i_min = max(0, i_center_idx - du_cells)
+        i_max = min(nx - 1, i_center_idx + du_cells)
+        j_min = max(0, j_center_idx - dv_cells)
+        j_max = min(ny - 1, j_center_idx + dv_cells)
+
+        if i_min > i_max or j_min > j_max:
+            continue
+
+        # Slice cell center coords for local window
+        ic = i_centers_m[i_min:i_max + 1][:, None]  # shape (Ii,1)
+        jc = j_centers_m[j_min:j_max + 1][None, :]  # shape (1,Jj)
+
+        # Compute radial distance in meters in grid metric space
+        di = ic - alpha_m
+        dj = jc - beta_m
+        r = np.sqrt(di * di + dj * dj)
+
+        # Mask for points within crown radius
+        within = r <= R
+        if not np.any(within):
+            continue
+
+        # Ellipsoidal vertical profile
+        # Avoid numerical issues for r slightly > R due to precision
+        ratio = np.clip(r / max(R, 1e-9), 0.0, 1.0)
+        factor = np.sqrt(1.0 - ratio * ratio)
+        local_top = z0 + a * factor
+        local_bot = z0 - a * factor
+
+        # Apply mask; cells outside remain zero contribution
+        local_top_masked = np.where(within, local_top, 0.0)
+        local_bot_masked = np.where(within, local_bot, 0.0)
+
+        # Merge with maxima to represent union of crowns
+        canopy_top[i_min:i_max + 1, j_min:j_max + 1] = np.maximum(
+            canopy_top[i_min:i_max + 1, j_min:j_max + 1], local_top_masked
+        )
+        canopy_bottom[i_min:i_max + 1, j_min:j_max + 1] = np.maximum(
+            canopy_bottom[i_min:i_max + 1, j_min:j_max + 1], local_bot_masked
+        )
+
+    # Ensure bottom <= top everywhere
+    canopy_bottom = np.minimum(canopy_bottom, canopy_top)
+
+    return canopy_top, canopy_bottom

{voxcity-0.6.14.dist-info → voxcity-0.6.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: voxcity
-Version: 0.6.14
+Version: 0.6.16
 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.14.dist-info → voxcity-0.6.16.dist-info}/RECORD

@@ -9,14 +9,14 @@ voxcity/downloader/osm.py,sha256=3vyH5jdPNe1vDXBYObLB0mtzYw7Ax8sEoF2KVn6UQO4,455
 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=_I0yJceBR54_BzUzckZNMp_RdknG9gKe0DAT5Aq3M4g,18019
+voxcity/exporter/cityles.py,sha256=Kfl2PAn4WquqCdjOlyPrHysxPLaudh8QfsoC6WAXlvs,18325
 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=ok0LqVk9k0xVqXD9Ybar-CWmqi-vooJmrAFi9WjsaKE,58327
+voxcity/generator.py,sha256=l_oqUPwhZbQNPvEVznJ1ALC5Je3q0yFYRFa3BuF49hA,60873
 voxcity/geoprocessor/__init__.py,sha256=WYxcAQrjGucIvGHF0JTC6rONZzL3kCms1S2vpzS6KaU,127
-voxcity/geoprocessor/draw.py,sha256=_CCQk7lMfwnl2PnRNede6GPEDvZDlf3KCmUC96Nnv3Q,49703
-voxcity/geoprocessor/grid.py,sha256=D4sqoIGK2P1U8uuVQZ-447SD0Yrv6qS_zlmDtKoLDe8,71257
+voxcity/geoprocessor/draw.py,sha256=AZMWq23wxxDJygNloCbVzWAAr1JO7nC94umf9LSxJ5o,49248
+voxcity/geoprocessor/grid.py,sha256=eJjT86P0lOFBdPdz420r63bcH2HCA3uQEBZcPBrRt14,78184
 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=TQKMmATpAqSDTPMvMi1a-n2CvvzE2KcYVsss7iiShS4,116877
 voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.6.14.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.6.14.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.6.14.dist-info/METADATA,sha256=rF1FDSHJSXfZ0UX65Lh0hin_N1RRxhwrgXqIaEWQLWI,26092
-voxcity-0.6.14.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-voxcity-0.6.14.dist-info/RECORD,,
+voxcity-0.6.16.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.16.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.16.dist-info/METADATA,sha256=ef5yw6coxYhtZtCeYwZAh_1f9J0Em7f01ZRnty2PN7c,26092
+voxcity-0.6.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+voxcity-0.6.16.dist-info/RECORD,,