voxcity 0.6.15__py3-none-any.whl → 0.7.0__py3-none-any.whl

voxcity/geoprocessor/raster/raster.py

@@ -0,0 +1,110 @@
+import numpy as np
+from typing import List, Tuple
+from shapely.geometry import Polygon
+from affine import Affine
+from pyproj import Geod, Transformer, CRS
+import rasterio
+from scipy.interpolate import griddata
+
+
+def create_height_grid_from_geotiff_polygon(
+    tiff_path: str,
+    mesh_size: float,
+    polygon: List[Tuple[float, float]]
+) -> np.ndarray:
+    """
+    Create a height grid from a GeoTIFF file within a polygon boundary.
+    """
+    with rasterio.open(tiff_path) as src:
+        img = src.read(1)
+        left, bottom, right, top = src.bounds
+
+        poly = Polygon(polygon)
+        left_wgs84, bottom_wgs84, right_wgs84, top_wgs84 = poly.bounds
+
+        geod = Geod(ellps="WGS84")
+        _, _, width = geod.inv(left_wgs84, bottom_wgs84, right_wgs84, bottom_wgs84)
+        _, _, height = geod.inv(left_wgs84, bottom_wgs84, left_wgs84, top_wgs84)
+
+        num_cells_x = int(width / mesh_size + 0.5)
+        num_cells_y = int(height / mesh_size + 0.5)
+
+        adjusted_mesh_size_x = (right - left) / num_cells_x
+        adjusted_mesh_size_y = (top - bottom) / num_cells_y
+
+        new_affine = Affine(adjusted_mesh_size_x, 0, left, 0, -adjusted_mesh_size_y, top)
+
+        cols, rows = np.meshgrid(np.arange(num_cells_x), np.arange(num_cells_y))
+        xs, ys = new_affine * (cols, rows)
+        xs_flat, ys_flat = xs.flatten(), ys.flatten()
+
+        row, col = src.index(xs_flat, ys_flat)
+        row, col = np.array(row), np.array(col)
+
+        valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)
+        row, col = row[valid], col[valid]
+
+        grid = np.full((num_cells_y, num_cells_x), np.nan)
+        flat_indices = np.ravel_multi_index((row, col), img.shape)
+        np.put(grid, np.ravel_multi_index((rows.flatten()[valid], cols.flatten()[valid]), grid.shape), img.flat[flat_indices])
+
+    return np.flipud(grid)
+
+
+def create_dem_grid_from_geotiff_polygon(tiff_path, mesh_size, rectangle_vertices, dem_interpolation=False):
+    """
+    Create a Digital Elevation Model (DEM) grid from a GeoTIFF within a polygon boundary.
+    """
+    from shapely.geometry import Polygon as ShapelyPolygon
+    from ..utils import convert_format_lat_lon
+
+    converted_coords = convert_format_lat_lon(rectangle_vertices)
+    roi_shapely = ShapelyPolygon(converted_coords)
+
+    with rasterio.open(tiff_path) as src:
+        dem = src.read(1)
+        dem = np.where(dem < -1000, 0, dem)
+        transform = src.transform
+        src_crs = src.crs
+
+        if src_crs.to_epsg() != 3857:
+            transformer_to_3857 = Transformer.from_crs(src_crs, CRS.from_epsg(3857), always_xy=True)
+        else:
+            transformer_to_3857 = lambda x, y: (x, y)
+
+        roi_bounds = roi_shapely.bounds
+        roi_left, roi_bottom = transformer_to_3857.transform(roi_bounds[0], roi_bounds[1])
+        roi_right, roi_top = transformer_to_3857.transform(roi_bounds[2], roi_bounds[3])
+
+        wgs84 = CRS.from_epsg(4326)
+        transformer_to_wgs84 = Transformer.from_crs(CRS.from_epsg(3857), wgs84, always_xy=True)
+        roi_left_wgs84, roi_bottom_wgs84 = transformer_to_wgs84.transform(roi_left, roi_bottom)
+        roi_right_wgs84, roi_top_wgs84 = transformer_to_wgs84.transform(roi_right, roi_top)
+
+        geod = Geod(ellps="WGS84")
+        _, _, roi_width_m = geod.inv(roi_left_wgs84, roi_bottom_wgs84, roi_right_wgs84, roi_bottom_wgs84)
+        _, _, roi_height_m = geod.inv(roi_left_wgs84, roi_bottom_wgs84, roi_left_wgs84, roi_top_wgs84)
+
+        num_cells_x = int(roi_width_m / mesh_size + 0.5)
+        num_cells_y = int(roi_height_m / mesh_size + 0.5)
+
+        x = np.linspace(roi_left, roi_right, num_cells_x, endpoint=False)
+        y = np.linspace(roi_top, roi_bottom, num_cells_y, endpoint=False)
+        xx, yy = np.meshgrid(x, y)
+
+        rows, cols = np.meshgrid(range(dem.shape[0]), range(dem.shape[1]), indexing='ij')
+        orig_x, orig_y = rasterio.transform.xy(transform, rows.ravel(), cols.ravel())
+        orig_x, orig_y = transformer_to_3857.transform(orig_x, orig_y)
+
+        points = np.column_stack((orig_x, orig_y))
+        values = dem.ravel()
+        if dem_interpolation:
+            grid = griddata(points, values, (xx, yy), method='cubic')
+        else:
+            grid = griddata(points, values, (xx, yy), method='nearest')
+
+    return np.flipud(grid)
+
+
+
+

voxcity/geoprocessor/selection.py

@@ -0,0 +1,85 @@
+"""
+Selection and filtering helpers for building footprints.
+"""
+
+from typing import List, Dict, Tuple
+
+from shapely.geometry import Polygon, Point, shape
+from shapely.errors import ShapelyError
+
+from .utils import validate_polygon_coordinates
+from ..utils.logging import get_logger
+
+
+def filter_buildings(geojson_data, plotting_box):
+    """
+    Filter building features that intersect with a given bounding box.
+    """
+    logger = get_logger(__name__)
+    filtered_features = []
+
+    for feature in geojson_data:
+        if not validate_polygon_coordinates(feature['geometry']):
+            logger.warning("Skipping feature with invalid geometry: %s", feature.get('geometry'))
+            continue
+
+        try:
+            geom = shape(feature['geometry'])
+            if not geom.is_valid:
+                logger.warning("Skipping invalid geometry: %s", geom)
+                continue
+
+            if plotting_box.intersects(geom):
+                filtered_features.append(feature)
+
+        except ShapelyError as e:
+            logger.warning("Skipping feature due to geometry error: %s", e)
+
+    return filtered_features
+
+
+def find_building_containing_point(building_gdf, target_point):
+    """
+    Find building IDs that contain a given point in their footprint.
+    """
+    point = Point(target_point[0], target_point[1])
+
+    id_list = []
+    for _, row in building_gdf.iterrows():
+        if not isinstance(row.geometry, Polygon):
+            continue
+        if row.geometry.contains(point):
+            id_list.append(row.get('id', None))
+
+    return id_list
+
+
+def get_buildings_in_drawn_polygon(building_gdf, drawn_polygons, operation='within'):
+    """
+    Find buildings that intersect with or are contained within user-drawn polygons.
+    """
+    if not drawn_polygons:
+        return []
+
+    included_building_ids = set()
+
+    for polygon_data in drawn_polygons:
+        vertices = polygon_data['vertices']
+        drawn_polygon_shapely = Polygon(vertices)
+
+        for _, row in building_gdf.iterrows():
+            if not isinstance(row.geometry, Polygon):
+                continue
+
+            if operation == 'intersect':
+                if row.geometry.intersects(drawn_polygon_shapely):
+                    included_building_ids.add(row.get('id', None))
+            elif operation == 'within':
+                if row.geometry.within(drawn_polygon_shapely):
+                    included_building_ids.add(row.get('id', None))
+            else:
+                raise ValueError("operation must be 'intersect' or 'within'")
+
+    return list(included_building_ids)
+
+

voxcity/geoprocessor/utils.py

@@ -59,6 +59,10 @@ warnings.filterwarnings("ignore", category=rasterio.errors.NotGeoreferencedWarni
 # Global constants
 floor_height = 2.5  # Standard floor height in meters used for building height calculations
 
+# Package logging
+from ..utils.logging import get_logger
+logger = get_logger(__name__)
+
 # Build a compliant Nominatim user agent once and reuse it
 try:
     # Prefer package metadata if available
@@ -264,10 +268,10 @@ def transform_coords(transformer, lon, lat):
     try:
         x, y = transformer.transform(lon, lat)
         if np.isinf(x) or np.isinf(y):
-            print(f"Transformation resulted in inf values for coordinates: {lon}, {lat}")
+            logger.warning("Transformation resulted in inf values for coordinates: %s, %s", lon, lat)
         return x, y
     except Exception as e:
-        print(f"Error transforming coordinates {lon}, {lat}: {e}")
+        logger.error("Error transforming coordinates %s, %s: %s", lon, lat, e)
         return None, None
 
 def create_polygon(vertices):
@@ -402,7 +406,7 @@ def save_raster(input_path, output_path):
     """
     import shutil
     shutil.copy(input_path, output_path)
-    print(f"Copied original file to: {output_path}")
+    logger.info("Copied original file to: %s", output_path)
 
 def merge_geotiffs(geotiff_files, output_dir):
     """
@@ -449,11 +453,11 @@ def merge_geotiffs(geotiff_files, output_dir):
             with rasterio.open(merged_path, "w", **out_meta) as dest:
                 dest.write(mosaic)
 
-            print(f"Merged output saved to: {merged_path}")
+            logger.info("Merged output saved to: %s", merged_path)
         except Exception as e:
-            print(f"Error merging files: {e}")
+            logger.error("Error merging files: %s", e)
     else:
-        print("No valid files to merge.")
+        logger.info("No valid files to merge.")
 
     # Clean up by closing all opened files
     for src in src_files_to_mosaic:
@@ -511,10 +515,10 @@ def get_coordinates_from_cityname(place_name):
         else:
             return None
     except GeocoderInsufficientPrivileges:
-        print("Warning: Nominatim blocked the request (HTTP 403). Please set a proper user agent and avoid bulk requests.")
+        logger.warning("Nominatim blocked the request (HTTP 403). Please set a proper user agent and avoid bulk requests.")
         return None
     except (GeocoderTimedOut, GeocoderServiceError):
-        print(f"Error: Geocoding service timed out or encountered an error for {place_name}")
+        logger.error("Geocoding service timed out or encountered an error for %s", place_name)
         return None
 
 def get_city_country_name_from_rectangle(coordinates):
@@ -560,7 +564,7 @@ def get_city_country_name_from_rectangle(coordinates):
             country = address.get('country', '')
             return f"{city}/ {country}"
         else:
-            print("Location not found")
+            logger.info("Reverse geocoding location not found for %s", center_coord)
             return "Unknown Location/ Unknown Country"
     except GeocoderInsufficientPrivileges:
         # Fallback to offline reverse_geocoder at coarse resolution
@@ -572,10 +576,10 @@ def get_city_country_name_from_rectangle(coordinates):
                 return f"{name}/ {country}".strip()
         except Exception:
             pass
-        print("Warning: Nominatim blocked the request (HTTP 403). Falling back to offline coarse reverse geocoding.")
+        logger.warning("Nominatim blocked the request (HTTP 403). Falling back to offline coarse reverse geocoding.")
         return "Unknown Location/ Unknown Country"
     except (GeocoderTimedOut, GeocoderServiceError) as e:
-        print(f"Error retrieving location for {center_coord}: {e}")
+        logger.error("Error retrieving location for %s: %s", center_coord, e)
         return "Unknown Location/ Unknown Country"
 
 def get_timezone_info(rectangle_coords):
@@ -626,7 +630,7 @@ def get_timezone_info(rectangle_coords):
         return utc_offset, timezone_longitude_str
     else:
         # Return fallback values if timezone cannot be determined
-        print("Warning: Timezone not found for the given location, using UTC+00:00")
+        logger.warning("Timezone not found for the given location, using UTC+00:00")
         return "UTC+00:00", "0.00000"
 
 def validate_polygon_coordinates(geometry):
@@ -743,7 +747,7 @@ def create_building_polygons(filtered_buildings):
             
             # Skip invalid geometries
             if not polygon.is_valid:
-                print(f"Warning: Skipping invalid polygon geometry")
+                logger.warning("Skipping invalid polygon geometry")
                 continue
                 
             height = building['properties'].get('height')
@@ -786,7 +790,7 @@ def create_building_polygons(filtered_buildings):
             valid_count += 1
             
         except Exception as e:
-            print(f"Warning: Skipping invalid building geometry: {e}")
+            logger.warning("Skipping invalid building geometry: %s", e)
             continue
 
     return building_polygons, idx

voxcity/models.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Tuple, Optional, Dict, Any
+
+import numpy as np
+
+
+@dataclass
+class GridMetadata:
+    crs: str
+    bounds: Tuple[float, float, float, float]
+    meshsize: float
+
+
+@dataclass
+class BuildingGrid:
+    heights: np.ndarray
+    min_heights: np.ndarray  # object-dtype array of lists per cell
+    ids: np.ndarray
+    meta: GridMetadata
+
+
+@dataclass
+class LandCoverGrid:
+    classes: np.ndarray
+    meta: GridMetadata
+
+
+@dataclass
+class DemGrid:
+    elevation: np.ndarray
+    meta: GridMetadata
+
+
+@dataclass
+class VoxelGrid:
+    classes: np.ndarray
+    meta: GridMetadata
+
+
+@dataclass
+class CanopyGrid:
+    top: np.ndarray
+    meta: GridMetadata
+    bottom: Optional[np.ndarray] = None
+
+
+@dataclass
+class VoxCity:
+    voxels: VoxelGrid
+    buildings: BuildingGrid
+    land_cover: LandCoverGrid
+    dem: DemGrid
+    tree_canopy: CanopyGrid
+    extras: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PipelineConfig:
+    rectangle_vertices: Any
+    meshsize: float
+    building_source: Optional[str] = None
+    land_cover_source: Optional[str] = None
+    canopy_height_source: Optional[str] = None
+    dem_source: Optional[str] = None
+    output_dir: str = "output"
+    trunk_height_ratio: Optional[float] = None
+    static_tree_height: Optional[float] = None
+    remove_perimeter_object: Optional[float] = None
+    mapvis: bool = False
+    gridvis: bool = True
+    # Structured options for strategies and I/O/visualization
+    land_cover_options: Dict[str, Any] = field(default_factory=dict)
+    building_options: Dict[str, Any] = field(default_factory=dict)
+    canopy_options: Dict[str, Any] = field(default_factory=dict)
+    dem_options: Dict[str, Any] = field(default_factory=dict)
+    io_options: Dict[str, Any] = field(default_factory=dict)
+    visualize_options: Dict[str, Any] = field(default_factory=dict)
+
+
+# -----------------------------
+# Mesh data structures
+# -----------------------------
+
+@dataclass
+class MeshModel:
+    vertices: np.ndarray  # (N, 3) float
+    faces: np.ndarray     # (M, 3|4) int
+    colors: Optional[np.ndarray] = None  # (M, 4) uint8 or None
+    name: Optional[str] = None
+
+
+@dataclass
+class MeshCollection:
+    """Container for named meshes with simple add/access helpers."""
+    meshes: Dict[str, MeshModel] = field(default_factory=dict)
+
+    def add(self, name: str, mesh: MeshModel) -> None:
+        self.meshes[name] = mesh
+
+    def get(self, name: str) -> Optional[MeshModel]:
+        return self.meshes.get(name)
+
+    def __iter__(self):
+        return iter(self.meshes.items())
+
+    # Compatibility: some renderers expect `collection.items.items()`
+    @property
+    def items(self) -> Dict[str, MeshModel]:
+        return self.meshes
+
+

voxcity/simulator/common/__init__.py

@@ -0,0 +1,22 @@
+"""
+Shared utilities for simulator subpackages.
+
+Currently exposes lightweight 3D geometry helpers used by both
+`visibility` and `solar`.
+"""
+
+from .geometry import (  # noqa: F401
+    _generate_ray_directions_grid,
+    _generate_ray_directions_fibonacci,
+    rotate_vector_axis_angle,
+    _build_face_basis,
+)
+
+__all__ = [
+    "_generate_ray_directions_grid",
+    "_generate_ray_directions_fibonacci",
+    "rotate_vector_axis_angle",
+    "_build_face_basis",
+]
+
+

voxcity/simulator/common/geometry.py

@@ -0,0 +1,98 @@
+import numpy as np
+from numba import njit
+
+
+def _generate_ray_directions_grid(N_azimuth: int, N_elevation: int, elevation_min_degrees: float, elevation_max_degrees: float) -> np.ndarray:
+    azimuth_angles = np.linspace(0.0, 2.0 * np.pi, int(N_azimuth), endpoint=False)
+    elevation_angles = np.deg2rad(
+        np.linspace(float(elevation_min_degrees), float(elevation_max_degrees), int(N_elevation))
+    )
+    ray_directions = np.empty((len(azimuth_angles) * len(elevation_angles), 3), dtype=np.float64)
+    out_idx = 0
+    for elevation in elevation_angles:
+        cos_elev = np.cos(elevation)
+        sin_elev = np.sin(elevation)
+        for azimuth in azimuth_angles:
+            dx = cos_elev * np.cos(azimuth)
+            dy = cos_elev * np.sin(azimuth)
+            dz = sin_elev
+            ray_directions[out_idx, 0] = dx
+            ray_directions[out_idx, 1] = dy
+            ray_directions[out_idx, 2] = dz
+            out_idx += 1
+    return ray_directions
+
+
+def _generate_ray_directions_fibonacci(N_rays: int, elevation_min_degrees: float, elevation_max_degrees: float) -> np.ndarray:
+    N = int(max(1, N_rays))
+    emin = np.deg2rad(float(elevation_min_degrees))
+    emax = np.deg2rad(float(elevation_max_degrees))
+    z_min = np.sin(min(emin, emax))
+    z_max = np.sin(max(emin, emax))
+    golden_angle = np.pi * (3.0 - np.sqrt(5.0))
+    i = np.arange(N, dtype=np.float64)
+    z = z_min + (i + 0.5) * (z_max - z_min) / N
+    phi = i * golden_angle
+    r = np.sqrt(np.clip(1.0 - z * z, 0.0, 1.0))
+    x = r * np.cos(phi)
+    y = r * np.sin(phi)
+    return np.stack((x, y, z), axis=1).astype(np.float64)
+
+
+@njit
+def rotate_vector_axis_angle(vec, axis, angle):
+    axis_len = np.sqrt(axis[0]**2 + axis[1]**2 + axis[2]**2)
+    if axis_len < 1e-12:
+        return vec
+    ux, uy, uz = axis / axis_len
+    c = np.cos(angle)
+    s = np.sin(angle)
+    dot = vec[0]*ux + vec[1]*uy + vec[2]*uz
+    cross_x = uy*vec[2] - uz*vec[1]
+    cross_y = uz*vec[0] - ux*vec[2]
+    cross_z = ux*vec[1] - uy*vec[0]
+    v_rot = np.zeros(3, dtype=np.float64)
+    v_rot[0] = vec[0] * c
+    v_rot[1] = vec[1] * c
+    v_rot[2] = vec[2] * c
+    v_rot[0] += cross_x * s
+    v_rot[1] += cross_y * s
+    v_rot[2] += cross_z * s
+    tmp = dot * (1.0 - c)
+    v_rot[0] += ux * tmp
+    v_rot[1] += uy * tmp
+    v_rot[2] += uz * tmp
+    return v_rot
+
+
+@njit(cache=True, fastmath=True, nogil=True)
+def _build_face_basis(normal):
+    nx = normal[0]; ny = normal[1]; nz = normal[2]
+    nrm = (nx*nx + ny*ny + nz*nz) ** 0.5
+    if nrm < 1e-12:
+        return (np.array((1.0, 0.0, 0.0)),
+                np.array((0.0, 1.0, 0.0)),
+                np.array((0.0, 0.0, 1.0)))
+    invn = 1.0 / nrm
+    nx *= invn; ny *= invn; nz *= invn
+    n = np.array((nx, ny, nz))
+    if abs(nz) < 0.999:
+        helper = np.array((0.0, 0.0, 1.0))
+    else:
+        helper = np.array((1.0, 0.0, 0.0))
+    ux = helper[1]*n[2] - helper[2]*n[1]
+    uy = helper[2]*n[0] - helper[0]*n[2]
+    uz = helper[0]*n[1] - helper[1]*n[0]
+    ul = (ux*ux + uy*uy + uz*uz) ** 0.5
+    if ul < 1e-12:
+        u = np.array((1.0, 0.0, 0.0))
+    else:
+        invul = 1.0 / ul
+        u = np.array((ux*invul, uy*invul, uz*invul))
+    vx = n[1]*u[2] - n[2]*u[1]
+    vy = n[2]*u[0] - n[0]*u[2]
+    vz = n[0]*u[1] - n[1]*u[0]
+    v = np.array((vx, vy, vz))
+    return u, v, n
+
+