voxcity 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

voxcity/geo/utils.py

@@ -177,16 +177,15 @@ def transform_coords(transformer, lon, lat):
 def create_polygon(vertices):
     """
     Create a Shapely polygon from vertices.
-    Converts from (lat,lon) format to (lon,lat) format required by Shapely.
+    Input vertices are already in (lon,lat) format required by Shapely.
     
     Args:
-        vertices (list): List of (lat, lon) coordinate pairs
+        vertices (list): List of (lon, lat) coordinate pairs
         
     Returns:
         Polygon: Shapely polygon object
     """
-    flipped_vertices = [(lon, lat) for lat, lon in vertices]
-    return Polygon(flipped_vertices)
+    return Polygon(vertices)
 
 def create_geodataframe(polygon, crs=4326):
     """
@@ -202,14 +201,14 @@ def create_geodataframe(polygon, crs=4326):
     """
     return gpd.GeoDataFrame({'geometry': [polygon]}, crs=from_epsg(crs))
 
-def haversine_distance(lat1, lon1, lat2, lon2):
+def haversine_distance(lon1, lat1, lon2, lat2):
     """
     Calculate great-circle distance between two points using Haversine formula.
     This is an approximation that treats the Earth as a perfect sphere.
     
     Args:
-        lat1, lon1 (float): Coordinates of first point
-        lat2, lon2 (float): Coordinates of second point
+        lon1, lat1 (float): Coordinates of first point
+        lon2, lat2 (float): Coordinates of second point
         
     Returns:
         float: Distance in kilometers
@@ -323,15 +322,16 @@ def merge_geotiffs(geotiff_files, output_dir):
 def convert_format_lat_lon(input_coords):
     """
     Convert coordinate format and close polygon.
+    Input coordinates are already in [lon, lat] format.
     
     Args:
         input_coords (list): List of [lon, lat] coordinates
         
     Returns:
-        list: List of [lat, lon] coordinates with first point repeated at end
+        list: List of [lon, lat] coordinates with first point repeated at end
     """
-    # Swap lon/lat to lat/lon format and create list
-    output_coords = [[coord[1], coord[0]] for coord in input_coords]
+    # Create list with coordinates in same order
+    output_coords = input_coords.copy()
     # Close polygon by repeating first point at end
     output_coords.append(output_coords[0])
     return output_coords
@@ -344,7 +344,7 @@ def get_coordinates_from_cityname(place_name):
         place_name (str): Name of city to geocode
         
     Returns:
-        tuple: (latitude, longitude) or None if geocoding fails
+        tuple: (longitude, latitude) or None if geocoding fails
     """
     # Initialize geocoder with user agent
     geolocator = Nominatim(user_agent="my_geocoding_script")
@@ -366,16 +366,16 @@ def get_city_country_name_from_rectangle(coordinates):
     Get city and country name from rectangle coordinates.
     
     Args:
-        coordinates (list): List of (lat, lon) coordinates defining rectangle
+        coordinates (list): List of (lon, lat) coordinates defining rectangle
         
     Returns:
         str: String in format "city/ country" or None if lookup fails
     """
     # Calculate center point of rectangle
-    latitudes = [coord[0] for coord in coordinates]
-    longitudes = [coord[1] for coord in coordinates]
-    center_lat = sum(latitudes) / len(latitudes)
+    longitudes = [coord[0] for coord in coordinates]
+    latitudes = [coord[1] for coord in coordinates]
     center_lon = sum(longitudes) / len(longitudes)
+    center_lat = sum(latitudes) / len(latitudes)
     center_coord = (center_lat, center_lon)
 
     # Initialize geocoder with rate limiting to avoid hitting API limits
@@ -401,17 +401,16 @@ def get_timezone_info(rectangle_coords):
     Get timezone and central meridian info for a location.
     
     Args:
-        rectangle_coords (list): List of (lat, lon) coordinates defining rectangle
+        rectangle_coords (list): List of (lon, lat) coordinates defining rectangle
         
     Returns:
         tuple: (timezone string, central meridian longitude string)
     """
     # Calculate center point of rectangle
-    latitudes = [coord[0] for coord in rectangle_coords]
-    longitudes = [coord[1] for coord in rectangle_coords]
-    center_lat = sum(latitudes) / len(latitudes)
+    longitudes = [coord[0] for coord in rectangle_coords]
+    latitudes = [coord[1] for coord in rectangle_coords]
     center_lon = sum(longitudes) / len(longitudes)
-    center_coord = (center_lat, center_lon)
+    center_lat = sum(latitudes) / len(latitudes)
     
     # Find timezone at center coordinates
     tf = TimezoneFinder()
@@ -475,6 +474,7 @@ def create_building_polygons(filtered_buildings):
     """
     building_polygons = []
     idx = index.Index()
+    valid_count = 0
     count = 0
     
     # Find highest existing ID to avoid duplicates
@@ -487,63 +487,76 @@ def create_building_polygons(filtered_buildings):
     else:
         id_count = 1
 
-    for i, building in enumerate(filtered_buildings):
-        # Create polygon from coordinates
-        polygon = Polygon(building['geometry']['coordinates'][0])
-        
-        # Extract height information from various possible property fields
-        height = building['properties'].get('height')
-        levels = building['properties'].get('levels')
-        floors = building['properties'].get('num_floors')
-        min_height = building['properties'].get('min_height')
-        min_level = building['properties'].get('min_level')    
-        min_floor = building['properties'].get('min_floor')        
-
-        # Calculate height if not directly specified
-        if (height is None) or (height<=0):
-            if levels is not None:
-                height = floor_height * levels
-            elif floors is not None:
-                height = floor_height * floors
-            else:
-                count += 1
-                height = np.nan
-
-        # Calculate minimum height if not directly specified
-        if (min_height is None) or (min_height<=0):
-            if min_level is not None:
-                min_height = floor_height * float(min_level) 
-            elif min_floor is not None:
-                min_height = floor_height * float(min_floor)
+    for building in filtered_buildings:
+        try:
+            # Handle potential nested coordinate tuples
+            coords = building['geometry']['coordinates'][0]
+            # Flatten coordinates if they're nested tuples
+            if isinstance(coords[0], tuple):
+                coords = [list(c) for c in coords]
+            elif isinstance(coords[0][0], tuple):
+                coords = [list(c[0]) for c in coords]
+                
+            # Create polygon from coordinates
+            polygon = Polygon(coords)
+            
+            # Skip invalid geometries
+            if not polygon.is_valid:
+                print(f"Warning: Skipping invalid polygon geometry")
+                continue
+                
+            height = building['properties'].get('height')
+            levels = building['properties'].get('levels')
+            floors = building['properties'].get('num_floors')
+            min_height = building['properties'].get('min_height')
+            min_level = building['properties'].get('min_level')    
+            min_floor = building['properties'].get('min_floor')        
+
+            if (height is None) or (height<=0):
+                if levels is not None:
+                    height = floor_height * levels
+                elif floors is not None:
+                    height = floor_height * floors
+                else:
+                    count += 1
+                    height = np.nan
+
+            if (min_height is None) or (min_height<=0):
+                if min_level is not None:
+                    min_height = floor_height * float(min_level) 
+                elif min_floor is not None:
+                    min_height = floor_height * float(min_floor)
+                else:
+                    min_height = 0
+
+            if building['properties'].get('id') is not None:
+                feature_id = building['properties']['id']
             else:
-                min_height = 0
+                feature_id = id_count
+                id_count += 1
 
-        # Get or assign building ID
-        if building['properties'].get('id') is not None:
-            feature_id = building['properties']['id']
-        else:
-            feature_id = id_count
-            id_count += 1
-
-        # Check if building is inner part of another building
-        if building['properties'].get('is_inner') is not None:
-            is_inner = building['properties']['is_inner']
-        else:
-            is_inner = False
+            if building['properties'].get('is_inner') is not None:
+                is_inner = building['properties']['is_inner']
+            else:
+                is_inner = False
 
-        # Store polygon with all properties and add to spatial index
-        building_polygons.append((polygon, height, min_height, is_inner, feature_id))
-        idx.insert(i, polygon.bounds)
+            building_polygons.append((polygon, height, min_height, is_inner, feature_id))
+            idx.insert(valid_count, polygon.bounds)
+            valid_count += 1
+            
+        except Exception as e:
+            print(f"Warning: Skipping invalid building geometry: {e}")
+            continue
 
     return building_polygons, idx
 
-def get_country_name(lat, lon):
+def get_country_name(lon, lat):
     """
     Get country name from coordinates using reverse geocoding.
     
     Args:
-        lat (float): Latitude
         lon (float): Longitude
+        lat (float): Latitude
         
     Returns:
         str: Country name or None if lookup fails

voxcity/sim/solar.py

@@ -374,7 +374,7 @@ def get_global_solar_irradiance_map(
 
     return global_map
 
-def get_solar_positions_astral(times, lat, lon):
+def get_solar_positions_astral(times, lon, lat):
     """
     Compute solar azimuth and elevation using Astral for given times and location.
     
@@ -385,8 +385,8 @@ def get_solar_positions_astral(times, lat, lon):
     
     Args:
         times (DatetimeIndex): Array of timezone-aware datetime objects.
-        lat (float): Latitude in degrees.
         lon (float): Longitude in degrees.
+        lat (float): Latitude in degrees.
 
     Returns:
         DataFrame: DataFrame with columns 'azimuth' and 'elevation' containing solar positions.
@@ -406,7 +406,7 @@ def get_solar_positions_astral(times, lat, lon):
 def get_cumulative_global_solar_irradiance(
     voxel_data,
     meshsize,
-    df, lat, lon, tz,
+    df, lon, lat, tz,
     direct_normal_irradiance_scaling=1.0,
     diffuse_irradiance_scaling=1.0,
     **kwargs
@@ -424,8 +424,8 @@ def get_cumulative_global_solar_irradiance(
         voxel_data (ndarray): 3D array of voxel values.
         meshsize (float): Size of each voxel in meters.
         df (DataFrame): EPW weather data.
-        lat (float): Latitude in degrees.
         lon (float): Longitude in degrees.
+        lat (float): Latitude in degrees.
         tz (float): Timezone offset in hours.
         direct_normal_irradiance_scaling (float): Scaling factor for direct normal irradiance.
         diffuse_irradiance_scaling (float): Scaling factor for diffuse horizontal irradiance.
@@ -498,7 +498,7 @@ def get_cumulative_global_solar_irradiance(
     df_period_utc = df_period_local.tz_convert(pytz.UTC)
 
     # Compute solar positions for period
-    solar_positions = get_solar_positions_astral(df_period_utc.index, lat, lon)
+    solar_positions = get_solar_positions_astral(df_period_utc.index, lon, lat)
 
     # Create kwargs for diffuse calculation
     diffuse_kwargs = kwargs.copy()

voxcity/sim/view.py

@@ -78,7 +78,7 @@ def calculate_transmittance(length, tree_k=0.6, tree_lad=1.0):
 def trace_ray_generic(voxel_data, origin, direction, hit_values, meshsize, tree_k, tree_lad, inclusion_mode=True):
     """Trace a ray through a voxel grid and check for hits with specified values.
     
-    Uses DDA (Digital Differential Analyzer) algorithm for efficient ray traversal.
+    Uses DDA algorithm to efficiently traverse voxels along ray path.
     Handles tree transmittance using Beer-Lambert law.
     
     The DDA algorithm:
@@ -749,11 +749,11 @@ def get_landmark_visibility_map(voxcity_grid_ori, building_id_grid, building_geo
                 return None
                 
             # Calculate center point of rectangle
-            lats = [coord[0] for coord in rectangle_vertices]
-            lons = [coord[1] for coord in rectangle_vertices]
-            center_lat = (min(lats) + max(lats)) / 2
+            lons = [coord[0] for coord in rectangle_vertices]
+            lats = [coord[1] for coord in rectangle_vertices]
             center_lon = (min(lons) + max(lons)) / 2
-            target_point = (center_lat, center_lon)
+            center_lat = (min(lats) + max(lats)) / 2
+            target_point = (center_lon, center_lat)
             
             # Find buildings at center point
             landmark_ids = find_building_containing_point(features, target_point)

voxcity/utils/__init_.py

@@ -1,3 +1,4 @@
 from .visualization import *
 from .lc import *
-from .weather import *
+from .weather import *
+from .material import *

voxcity/utils/material.py

@@ -0,0 +1,139 @@
+import numpy as np
+
+def get_material_dict():
+    """
+    Returns a dictionary mapping material names to their corresponding ID values.
+    """
+    return {
+        "unknown": -3,
+        "brick": -11,  
+        "wood": -12,  
+        "concrete": -13,  
+        "metal": -14,  
+        "stone": -15,  
+        "glass": -16,  
+        "plaster": -17,  
+    }
+
+def get_modulo_numbers(window_ratio):
+    """
+    Determines the appropriate modulo numbers for x, y, z based on window_ratio.
+    
+    Parameters:
+    window_ratio: float between 0 and 1.0
+    
+    Returns:
+    tuple (x_mod, y_mod, z_mod): modulo numbers for each dimension
+    """
+    if window_ratio <= 0.125 + 0.0625:  # around 0.125
+        return (2, 2, 2)
+    elif window_ratio <= 0.25 + 0.125:  # around 0.25
+        combinations = [(2, 2, 1), (2, 1, 2), (1, 2, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    elif window_ratio <= 0.5 + 0.125:  # around 0.5
+        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    elif window_ratio <= 0.75 + 0.125:  # around 0.75
+        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    else:  # above 0.875
+        return (1, 1, 1)
+
+def set_building_material_by_id(voxelcity_grid, building_id_grid_ori, ids, mark, window_ratio=0.125, glass_id=-16):
+    """
+    Marks cells in voxelcity_grid based on building IDs and window ratio.
+    Never sets glass_id to cells with maximum z index.
+    
+    Parameters:
+    voxelcity_grid: 3D numpy array
+    building_id_grid_ori: 2D numpy array containing building IDs
+    ids: list/array of building IDs to check
+    mark: value to set for marked cells
+    window_ratio: float between 0 and 1.0, determines window density:
+        ~0.125: sparse windows (2,2,2)
+        ~0.25: medium-sparse windows (2,2,1), (2,1,2), or (1,2,2)
+        ~0.5: medium windows (2,1,1), (1,2,1), or (1,1,2)
+        ~0.75: dense windows (2,1,1), (1,2,1), or (1,1,2)
+        >0.875: maximum density (1,1,1)
+    glass_id: value to set for glass cells (default: -16)
+    
+    Returns:
+    Modified voxelcity_grid
+    """
+    building_id_grid = np.flipud(building_id_grid_ori.copy())
+    
+    # Get modulo numbers based on window_ratio
+    x_mod, y_mod, z_mod = get_modulo_numbers(window_ratio)
+    
+    # Get positions where building IDs match
+    building_positions = np.where(np.isin(building_id_grid, ids))
+    
+    # Loop through each position that matches building IDs
+    for i in range(len(building_positions[0])):
+        x, y = building_positions[0][i], building_positions[1][i]
+        z_mask = voxelcity_grid[x, y, :] == -3
+        voxelcity_grid[x, y, z_mask] = mark
+        
+        # Check if x and y meet the modulo conditions
+        if x % x_mod == 0 and y % y_mod == 0:
+            z_mask = voxelcity_grid[x, y, :] == mark
+            if np.any(z_mask):
+                # Find the maximum z index where z_mask is True
+                z_indices = np.where(z_mask)[0]
+                max_z_index = np.max(z_indices)
+                
+                # Create base mask excluding maximum z index
+                base_mask = z_mask.copy()
+                base_mask[max_z_index] = False
+                
+                # Create pattern mask based on z modulo
+                pattern_mask = np.zeros_like(z_mask)
+                valid_z_indices = z_indices[z_indices != max_z_index]  # Exclude max_z_index
+                if len(valid_z_indices) > 0:
+                    pattern_mask[valid_z_indices[valid_z_indices % z_mod == 0]] = True
+                
+                # For window_ratio around 0.75, add additional pattern
+                if 0.625 < window_ratio <= 0.875 and len(valid_z_indices) > 0:
+                    additional_pattern = np.zeros_like(z_mask)
+                    additional_pattern[valid_z_indices[valid_z_indices % (z_mod + 1) == 0]] = True
+                    pattern_mask = np.logical_or(pattern_mask, additional_pattern)
+                
+                # Final mask combines base_mask and pattern_mask
+                final_glass_mask = np.logical_and(base_mask, pattern_mask)
+                
+                # Set glass_id for all positions in the final mask
+                voxelcity_grid[x, y, final_glass_mask] = glass_id
+    
+    return voxelcity_grid
+
+def set_building_material_by_gdf(voxelcity_grid_ori, building_id_grid, gdf_buildings, material_id_dict=None):
+    """
+    Sets building materials based on a GeoDataFrame containing building information.
+    
+    Parameters:
+    voxelcity_grid_ori: 3D numpy array of the original voxel grid
+    building_id_grid: 2D numpy array containing building IDs
+    gdf_buildings: GeoDataFrame containing building information with columns:
+                  'building_id', 'surface_material', 'window_ratio'
+    material_id_dict: Dictionary mapping material names to their IDs (optional)
+    
+    Returns:
+    Modified voxelcity_grid
+    """
+    voxelcity_grid = voxelcity_grid_ori.copy()
+    if material_id_dict == None:
+        material_id_dict = get_material_dict()
+
+    for index, row in gdf_buildings.iterrows():
+        # Access properties
+        osmid = row['building_id']
+        surface_material = row['surface_material']
+        window_ratio = row['window_ratio']
+        if surface_material is None:
+            surface_material = 'unknown'            
+        set_building_material_by_id(voxelcity_grid, building_id_grid, osmid, 
+                                  material_id_dict[surface_material], 
+                                  window_ratio=window_ratio, 
+                                  glass_id=material_id_dict['glass'])
+    
+    return voxelcity_grid