voxcity 0.3.27__py3-none-any.whl → 0.4.2__py3-none-any.whl

voxcity/utils/weather.py

@@ -164,7 +164,7 @@ def process_epw(epw_path: Union[str, Path]) -> Tuple[pd.DataFrame, Dict]:
     return df, headers
 
 def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float, output_dir: str = "./", max_distance: Optional[float] = None, 
-                extract_zip: bool = True, load_data: bool = True) -> Tuple[Optional[str], Optional[pd.DataFrame], Optional[Dict]]:
+                extract_zip: bool = True, load_data: bool = True, region: Optional[Union[str, List[str]]] = None) -> Tuple[Optional[str], Optional[pd.DataFrame], Optional[Dict]]:
     """
     Download and process EPW weather file from Climate.OneBuilding.Org based on coordinates.
     
@@ -175,6 +175,8 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         max_distance (float, optional): Maximum distance in kilometers to search for stations
         extract_zip (bool): Whether to extract the ZIP file (default True)
         load_data (bool): Whether to load the EPW data into a DataFrame (default True)
+        region (str or List[str], optional): Specific region(s) to scan for stations (e.g., "Asia", ["Europe", "Africa"])
+                                            If None, will auto-detect region based on coordinates.
     
     Returns:
         Tuple containing:
@@ -197,6 +199,66 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         "Europe": "https://climate.onebuilding.org/sources/Region6_Europe_TMYx_EPW_Processing_locations.kml",
         "Antarctica": "https://climate.onebuilding.org/sources/Region7_Antarctica_TMYx_EPW_Processing_locations.kml"
     }
+    
+    # Define approximate geographical boundaries for regions
+    REGION_BOUNDS = {
+        "Africa": {"lon_min": -20, "lon_max": 55, "lat_min": -35, "lat_max": 40},
+        "Asia": {"lon_min": 25, "lon_max": 150, "lat_min": 0, "lat_max": 55},
+        "Japan": {"lon_min": 127, "lon_max": 146, "lat_min": 24, "lat_max": 46},
+        "India": {"lon_min": 68, "lon_max": 97, "lat_min": 6, "lat_max": 36},
+        "Argentina": {"lon_min": -75, "lon_max": -53, "lat_min": -55, "lat_max": -22},
+        "Canada": {"lon_min": -141, "lon_max": -52, "lat_min": 42, "lat_max": 83},
+        "USA": {"lon_min": -170, "lon_max": -65, "lat_min": 20, "lat_max": 72},
+        "Caribbean": {"lon_min": -90, "lon_max": -59, "lat_min": 10, "lat_max": 27},
+        "Southwest_Pacific": {"lon_min": 110, "lon_max": 180, "lat_min": -50, "lat_max": 0},
+        "Europe": {"lon_min": -25, "lon_max": 40, "lat_min": 35, "lat_max": 72},
+        "Antarctica": {"lon_min": -180, "lon_max": 180, "lat_min": -90, "lat_max": -60}
+    }
+
+    def detect_regions(lon: float, lat: float) -> List[str]:
+        """Detect which region(s) the coordinates belong to."""
+        matching_regions = []
+        
+        # Handle special case of longitude wrap around 180/-180
+        lon_adjusted = lon
+        if lon < -180:
+            lon_adjusted = lon + 360
+        elif lon > 180:
+            lon_adjusted = lon - 360
+            
+        for region_name, bounds in REGION_BOUNDS.items():
+            # Check if point is within region bounds
+            if (bounds["lon_min"] <= lon_adjusted <= bounds["lon_max"] and 
+                bounds["lat_min"] <= lat <= bounds["lat_max"]):
+                matching_regions.append(region_name)
+        
+        # If no regions matched, check the closest regions
+        if not matching_regions:
+            # Calculate "distance" to each region's boundary (simplified)
+            region_distances = []
+            for region_name, bounds in REGION_BOUNDS.items():
+                # Calculate distance to closest edge of region bounds
+                lon_dist = 0
+                if lon_adjusted < bounds["lon_min"]:
+                    lon_dist = bounds["lon_min"] - lon_adjusted
+                elif lon_adjusted > bounds["lon_max"]:
+                    lon_dist = lon_adjusted - bounds["lon_max"]
+                
+                lat_dist = 0
+                if lat < bounds["lat_min"]:
+                    lat_dist = bounds["lat_min"] - lat
+                elif lat > bounds["lat_max"]:
+                    lat_dist = lat - bounds["lat_max"]
+                
+                # Simple distance metric (not actual distance)
+                distance = (lon_dist**2 + lat_dist**2)**0.5
+                region_distances.append((region_name, distance))
+            
+            # Get 3 closest regions
+            closest_regions = sorted(region_distances, key=lambda x: x[1])[:3]
+            matching_regions = [r[0] for r in closest_regions]
+        
+        return matching_regions
 
     def try_decode(content: bytes) -> str:
         """Try different encodings to decode content."""
@@ -353,15 +415,46 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         # Create output directory if it doesn't exist
         Path(output_dir).mkdir(parents=True, exist_ok=True)
         
-        # Get stations from all KML sources
+        # Determine which regions to scan
+        regions_to_scan = {}
+        if region is None:
+            # Auto-detect regions based on coordinates
+            detected_regions = detect_regions(longitude, latitude)
+            
+            if detected_regions:
+                print(f"Auto-detected regions: {', '.join(detected_regions)}")
+                for r in detected_regions:
+                    regions_to_scan[r] = KML_SOURCES[r]
+            else:
+                # Fallback to all regions if detection fails
+                print("Could not determine region from coordinates. Scanning all regions.")
+                regions_to_scan = KML_SOURCES
+        elif isinstance(region, str):
+            # Handle string input
+            if region.lower() == "all":
+                regions_to_scan = KML_SOURCES
+            elif region in KML_SOURCES:
+                regions_to_scan[region] = KML_SOURCES[region]
+            else:
+                valid_regions = ", ".join(KML_SOURCES.keys())
+                raise ValueError(f"Invalid region: '{region}'. Valid regions are: {valid_regions}")
+        else:
+            # Handle list input
+            for r in region:
+                if r not in KML_SOURCES:
+                    valid_regions = ", ".join(KML_SOURCES.keys())
+                    raise ValueError(f"Invalid region: '{r}'. Valid regions are: {valid_regions}")
+                regions_to_scan[r] = KML_SOURCES[r]
+        
+        # Get stations from selected KML sources
         print("Fetching weather station data from Climate.OneBuilding.Org...")
         all_stations = []
         
-        for region, url in KML_SOURCES.items():
-            print(f"Scanning {region}...")
+        for region_name, url in regions_to_scan.items():
+            print(f"Scanning {region_name}...")
             stations = get_stations_from_kml(url)
             all_stations.extend(stations)
-            print(f"Found {len(stations)} stations in {region}")
+            print(f"Found {len(stations)} stations in {region_name}")
         
         print(f"\nTotal stations found: {len(all_stations)}")
         

{voxcity-0.3.27.dist-info → voxcity-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.27
+Version: 0.4.2
 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>
@@ -69,7 +69,7 @@ Requires-Dist: ruff; extra == "dev"
 
 # VoxCity
 
-**VoxCity** is a Python package that provides a one-stop solution for grid-based 3D city model generation and urban simulation for cities worldwide. It integrates various geospatial datasets—such as building footprints, land cover, canopy height, and digital elevation models (DEMs)—to generate 2D and 3D representations of urban areas. It can export data in formats compatible with popular simulation tools like ENVI-MET, as well as visualization tools like MagicaVoxel, and supports simulations such as sky view index and green view index calculations.
+**voxcity** is a Python package that provides a seamless solution for grid-based 3D city model generation and urban simulation for cities worldwide. VoxCity's generator module automatically downloads building heights, tree canopy heights, land cover, and terrain elevation within a specified target area, and voxelizes buildings, trees, land cover, and terrain to generate an integrated voxel city model. The simulator module enables users to conduct environmental simulations, including solar radiation and view index analyses. Users can export the generated models using several file formats compatible with external software, such as ENVI-met (INX), Blender, and Rhino (OBJ). Try it out using the [Google Colab Demo](https://colab.research.google.com/drive/1Lofd3RawKMr6QuUsamGaF48u2MN0hfrP?usp=sharing) or your local environment.
 
 <!-- <p align="center">
   <picture>
@@ -180,7 +180,7 @@ rectangle_vertices = [
 Use the GUI map interface to draw a rectangular domain of interest.
 
 ```python
-from voxcity.geo.draw import draw_rectangle_map_cityname
+from voxcity.geoprocessor.draw import draw_rectangle_map_cityname
 
 cityname = "tokyo"
 m, rectangle_vertices = draw_rectangle_map_cityname(cityname, zoom=15)
@@ -191,7 +191,7 @@ m
 Choose the width and height in meters and select the center point on the map.
 
 ```python
-from voxcity.geo.draw import center_location_map_cityname
+from voxcity.geoprocessor.draw import center_location_map_cityname
 
 width = 500
 height = 500
@@ -224,7 +224,7 @@ kwargs = {
 Generate voxel data grids and corresponding building geoJSON:
 
 ```python
-from voxcity import get_voxcity
+from voxcity.generator import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
 building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
@@ -245,7 +245,7 @@ building_gdf = get_voxcity(
 [ENVI-MET](https://www.envi-met.com/) is an advanced microclimate simulation software specialized in modeling urban environments. It simulates the interactions between buildings, vegetation, and various climate parameters like temperature, wind flow, humidity, and radiation. The software is used widely in urban planning, architecture, and environmental studies (Commercial, offers educational licenses).
 
 ```python
-from voxcity.file.envimet import export_inx, generate_edb_file
+from voxcity.exporter.envimet import export_inx, generate_edb_file
 
 envimet_kwargs = {
     "output_directory": "output",                     # Directory where output files will be saved
@@ -271,7 +271,7 @@ generate_edb_file(**envimet_kwargs)
 #### OBJ Files:
 
 ```python
-from voxcity.file.obj import export_obj
+from voxcity.exporter.obj import export_obj
 
 output_directory = "output"  # Directory where output files will be saved
 output_file_name = "voxcity" # Base name for the output OBJ file
@@ -295,7 +295,7 @@ The generated OBJ files can be opened and rendered in the following 3D visualiza
 [MagicaVoxel](https://ephtracy.github.io/) is a lightweight and user-friendly voxel art editor. It allows users to create, edit, and render voxel-based 3D models with an intuitive interface, making it perfect for modifying and visualizing voxelized city models. The software is free and available for Windows and Mac.
 
 ```python
-from voxcity.file.magicavoxel import export_magicavoxel_vox
+from voxcity.exporter.magicavoxel import export_magicavoxel_vox
 
 output_path = "output"
 base_filename = "voxcity"
@@ -313,7 +313,7 @@ export_magicavoxel_vox(voxcity_grid, output_path, base_filename=base_filename)
 #### Compute Solar Irradiance:
 
 ```python
-from voxcity.sim.solar import get_global_solar_irradiance_using_epw
+from voxcity.simulator.solar import get_global_solar_irradiance_using_epw
 
 solar_kwargs = {
     "download_nearest_epw": True,  # Whether to automatically download nearest EPW weather file based on location from Climate.OneBuilding.Org
@@ -369,7 +369,7 @@ cum_solar_grid = get_global_solar_irradiance_using_epw(
 #### Compute Green View Index (GVI) and Sky View Index (SVI):
 
 ```python
-from voxcity.sim.view import get_view_index
+from voxcity.simulator.view import get_view_index
 
 view_kwargs = {
     "view_point_height": 1.5,      # Height of observer viewpoint in meters
@@ -401,7 +401,7 @@ svi_grid = get_view_index(voxcity_grid, meshsize, mode='sky', **view_kwargs)
 #### Landmark Visibility Map:
 
 ```python
-from voxcity.sim.view import get_landmark_visibility_map
+from voxcity.simulator.view import get_landmark_visibility_map
 
 # Dictionary of parameters for landmark visibility analysis
 landmark_kwargs = {
@@ -425,7 +425,7 @@ landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, b
 #### Network Analysis:
 
 ```python
-from voxcity.geo.network import get_network_values
+from voxcity.geoprocessor.network import get_network_values
 
 network_kwargs = {
     "network_type": "walk",        # Type of network to download from OSM (walk, drive, all, etc.)

{voxcity-0.3.27.dist-info → voxcity-0.4.2.dist-info}/RECORD

@@ -12,26 +12,26 @@ voxcity/downloader/utils.py,sha256=z6MdPxM96FWQVqvZW2Eg5pMewVHVysUP7F6ueeCwMfI,1
 voxcity/exporter/__init_.py,sha256=cVyNyE6axEpSd3CT5hGuMOAlOyU1p8lVP4jkF1-0Ad8,94
 voxcity/exporter/envimet.py,sha256=m-y2IYw-yp45AT2wN9UIlxvMjvDvupTKzyfRJl057fE,24300
 voxcity/exporter/magicavoxel.py,sha256=Fsv7yGRXeKmp82xcG3rOb0t_HtoqltNq2tHl08xVlqY,7500
-voxcity/exporter/obj.py,sha256=oW-kPoZj53nfmO9tXP3Wvizq6Kkjh-QQR8UBexRuMiI,21609
+voxcity/exporter/obj.py,sha256=0RBFPMKGRH6uNmCLIwAoYFko1bOZKtTSwg7QnoPMud0,21593
 voxcity/geoprocessor/__init_.py,sha256=JzPVhhttxBWvaZ0IGX2w7OWL5bCo_TIvpHefWeNXruA,133
 voxcity/geoprocessor/draw.py,sha256=8Em2NvazFpYfFJUqG9LofNXaxdghKLL_rNuztmPwn8Q,13911
-voxcity/geoprocessor/grid.py,sha256=DYphECd0v4o7_ZH5rd-_AWSvNaKoAsQ2fuko1sh-2AM,44113
-voxcity/geoprocessor/mesh.py,sha256=u4j5wombULMc26yhH8seltMZvmeKab1oequnZYrbiuE,9454
+voxcity/geoprocessor/grid.py,sha256=t-KAdYOk1iUeBuOMcoAb5e4hzJjMIfVItTdFP6FJs1A,44340
+voxcity/geoprocessor/mesh.py,sha256=z6e-BigN_K1CGpS9mopkf121pbCnBFJMu32XYfqpLI4,10506
 voxcity/geoprocessor/network.py,sha256=opb_kpUCAxDd1qtrWPStqR5reYZtVe96XxazNSen7Lk,18851
-voxcity/geoprocessor/polygon.py,sha256=wMVn2Y7rfbzOlTBktq4pBNZ7-Dmh3jOqRBHk450Ywss,33669
+voxcity/geoprocessor/polygon.py,sha256=wXU3K-lghAlAOe_C-m1YD4_75DvCWzdszuWieenP5mA,37208
 voxcity/geoprocessor/utils.py,sha256=1BRHp-DDeOA8HG8jplY7Eo75G3oXkVGL6DGONL4BA8A,19815
 voxcity/simulator/__init_.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/simulator/solar.py,sha256=FOcHoUm4miJNyeCcGs2oL93Vu38Affyywt29dJcmIT4,31974
+voxcity/simulator/solar.py,sha256=7IGmCCYsAnBguID2IT2xjzfbK7msxakaJ0_0Eu0cvX0,58607
 voxcity/simulator/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
-voxcity/simulator/view.py,sha256=zNbfTLQ2Jo0V5-rFA3-xamRjOuw3H3MBrLKpQp8x3hY,36737
+voxcity/simulator/view.py,sha256=iNJxeY3HH3YNAF0nh6HxthyW001HNH4wvLZFp7_YkS8,63669
 voxcity/utils/__init_.py,sha256=nLYrj2huBbDBNMqfchCwexGP8Tlt9O_XluVDG7MoFkw,98
 voxcity/utils/lc.py,sha256=RwPd-VY3POV3gTrBhM7TubgGb9MCd3nVah_G8iUEF7k,11562
 voxcity/utils/material.py,sha256=Vt3IID5Ft54HNJcEC4zi31BCPqi_687X3CSp7rXaRVY,5907
-voxcity/utils/visualization.py,sha256=ufS6aMIaDUmFNTiqQS5If7SgHxMm6unKIIOkFdnSkOQ,54253
-voxcity/utils/weather.py,sha256=P6s1y_EstBL1OGP_MR_6u3vr-t6Uawg8uDckJnoI7FI,21482
-voxcity-0.3.27.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.3.27.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
-voxcity-0.3.27.dist-info/METADATA,sha256=-2DQaO2L5yJXuJ5tQv-sC6s-VIip3dcEhbpVtSUpjeo,25186
-voxcity-0.3.27.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-voxcity-0.3.27.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.3.27.dist-info/RECORD,,
+voxcity/utils/visualization.py,sha256=8r7ffnvBCAmvEYnJQ4KKh18aaah3G9ARoV9EDXUyo8I,85255
+voxcity/utils/weather.py,sha256=CFPtoqRTajwMRswswDChwQ3BW1cGsnA3orgWHgz7Ehg,26304
+voxcity-0.4.2.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.4.2.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
+voxcity-0.4.2.dist-info/METADATA,sha256=LKhFX_8JNN3pafmDgzH2f5ZhIBryTgql-BL9HxrdA28,25527
+voxcity-0.4.2.dist-info/WHEEL,sha256=EaM1zKIUYa7rQnxGiOCGhzJABRwy4WO57rWMR3_tj4I,91
+voxcity-0.4.2.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.4.2.dist-info/RECORD,,

{voxcity-0.3.27.dist-info → voxcity-0.4.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (75.9.1)
 Root-Is-Purelib: true
 Tag: py3-none-any