voxcity 0.6.17__py3-none-any.whl → 0.6.19__py3-none-any.whl

voxcity/utils/visualization.py

@@ -111,6 +111,7 @@ def get_voxel_color_map(color_scheme='default'):
         - 'pastel': Softer, muted colors for aesthetic appeal
         - 'dark_mode': Darker colors for dark backgrounds
         - 'grayscale': Black and white gradient with color accents
+        - 'white_mode': Light minimal palette for white backgrounds
         
         Thematic Schemes:
         - 'autumn': Warm reds, oranges, and browns
@@ -329,6 +330,36 @@ def get_voxel_color_map(color_scheme='default'):
             14: [230, 230, 230],  # 'No Data'
         }
 
+    elif color_scheme == 'white_mode':
+        return {
+            -99: [0, 0, 0],          # void (transparent in rendering)
+            -30: [220, 80, 80],      # subtle highlight for landmarks
+            -17: [250, 250, 250],    # plaster (near white)
+            -16: [210, 225, 235],    # glass (light blue-gray)
+            -15: [230, 225, 215],    # stone (warm light gray)
+            -14: [225, 230, 235],    # metal (cool light gray)
+            -13: [236, 236, 236],    # concrete (very light gray)
+            -12: [245, 232, 210],    # wood (light beige)
+            -11: [235, 210, 205],    # brick (light rose)
+            -3: [225, 230, 240],     # Building (soft blue-gray)
+            -2: [190, 210, 190],     # Tree (soft green)
+            -1: [230, 215, 215],     # Underground (soft pinkish)
+            1: [248, 245, 235],      # Bareland
+            2: [225, 235, 215],      # Rangeland
+            3: [220, 235, 220],      # Shrub
+            4: [240, 235, 215],      # Agriculture land
+            5: [210, 230, 210],      # Tree (ground)
+            6: [245, 250, 235],      # Moss and lichen
+            7: [220, 235, 230],      # Wet land
+            8: [205, 215, 210],      # Mangrove
+            9: [200, 220, 245],      # Water (pale blue)
+            10: [252, 252, 252],     # Snow and ice (almost white)
+            11: [230, 230, 230],     # Developed space
+            12: [210, 210, 215],     # Road (light neutral)
+            13: [230, 235, 240],     # Building (ground surface)
+            14: [248, 245, 235],     # No Data
+        }
+
     elif color_scheme == 'autumn':
         return {
             -99: [0, 0, 0],          # void

voxcity/utils/weather.py

@@ -233,10 +233,15 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
                                        If no stations within this distance, uses closest available.
         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.
-                                            Options: "Africa", "Asia", "Japan", "India", "Argentina",
-                                            "Canada", "USA", "Caribbean", "Southwest_Pacific", 
-                                            "Europe", "Antarctica", or "all".
+        region (str or List[str], optional): Specific region(s) or dataset(s) to scan for stations.
+                                            Regions: "Africa", "Asia", "South_America",
+                                            "North_and_Central_America", "Southwest_Pacific",
+                                            "Europe", "Antarctica".
+                                            Sub-datasets (can be used alone or auto-included by region):
+                                            "Japan", "India", "CSWD", "CityUHK", "PHIKO",
+                                            "Argentina", "INMET_TRY", "AMTUes", "BrazFuture",
+                                            plus legacy "Canada", "USA", "Caribbean" (Region 4).
+                                            Use "all" to scan every dataset.
                                             If None, will auto-detect region based on coordinates.
     
     Returns:
@@ -250,35 +255,83 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         requests.exceptions.RequestException: If network requests fail
     """
     
-    # Regional KML sources from Climate.OneBuilding.Org
-    # Each region maintains its own KML file with weather station locations and metadata
+    # Regional KML sources from Climate.OneBuilding.Org (2024+ TMYx structure)
+    # Each WMO region maintains a primary KML in /sources with the naming pattern:
+    #   Region{N}_{Name}_TMYx_EPW_Processing_locations.kml
+    # Keep sub-region keys for backward compatibility (mapping to the Region KML where applicable)
     KML_SOURCES = {
-        "Africa": "https://climate.onebuilding.org/WMO_Region_1_Africa/Region1_Africa_EPW_Processing_locations.kml",
-        "Asia": "https://climate.onebuilding.org/WMO_Region_2_Asia/Region2_Asia_EPW_Processing_locations.kml",
+        # WMO Region 1
+        "Africa": "https://climate.onebuilding.org/sources/Region1_Africa_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 2
+        "Asia": "https://climate.onebuilding.org/sources/Region2_Asia_TMYx_EPW_Processing_locations.kml",
+        # Subsets/datasets within Asia that still publish dedicated KMLs
         "Japan": "https://climate.onebuilding.org/sources/JGMY_EPW_Processing_locations.kml",
         "India": "https://climate.onebuilding.org/sources/ITMY_EPW_Processing_locations.kml",
+        "CSWD": "https://climate.onebuilding.org/sources/CSWD_EPW_Processing_locations.kml",
+        "CityUHK": "https://climate.onebuilding.org/sources/CityUHK_EPW_Processing_locations.kml",
+        "PHIKO": "https://climate.onebuilding.org/sources/PHIKO_EPW_Processing_locations.kml",
+        # WMO Region 3
+        "South_America": "https://climate.onebuilding.org/sources/Region3_South_America_TMYx_EPW_Processing_locations.kml",
+        # Historical/legacy dataset for Argentina maintained separately
         "Argentina": "https://climate.onebuilding.org/sources/ArgTMY_EPW_Processing_locations.kml",
+        "INMET_TRY": "https://climate.onebuilding.org/sources/INMET_TRY_EPW_Processing_locations.kml",
+        "AMTUes": "https://climate.onebuilding.org/sources/AMTUes_EPW_Processing_locations.kml",
+        "BrazFuture": "https://climate.onebuilding.org/sources/BrazFuture_EPW_Processing_locations.kml",
+        # WMO Region 4 (use subregion KMLs; umbrella selection expands to these)
+        # Note: There is no single unified Region 4 KML in /sources as of 2024.
+        # Use these three subregion KMLs instead.
         "Canada": "https://climate.onebuilding.org/sources/Region4_Canada_TMYx_EPW_Processing_locations.kml",
         "USA": "https://climate.onebuilding.org/sources/Region4_USA_TMYx_EPW_Processing_locations.kml",
         "Caribbean": "https://climate.onebuilding.org/sources/Region4_NA_CA_Caribbean_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 5
         "Southwest_Pacific": "https://climate.onebuilding.org/sources/Region5_Southwest_Pacific_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 6
         "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"
+        # WMO Region 7
+        "Antarctica": "https://climate.onebuilding.org/sources/Region7_Antarctica_TMYx_EPW_Processing_locations.kml",
+    }
+
+    # Group region selections to include relevant sub-datasets automatically
+    REGION_DATASET_GROUPS = {
+        "Africa": ["Africa"],
+        "Asia": ["Asia", "Japan", "India", "CSWD", "CityUHK", "PHIKO"],
+        "South_America": ["South_America", "Argentina", "INMET_TRY", "AMTUes", "BrazFuture"],
+        "North_and_Central_America": ["North_and_Central_America", "Canada", "USA", "Caribbean"],
+        "Southwest_Pacific": ["Southwest_Pacific"],
+        "Europe": ["Europe"],
+        "Antarctica": ["Antarctica"],
     }
     
     # Define approximate geographical boundaries for automatic region detection
     # These bounds help determine which regional KML files to scan based on coordinates
     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},
+        # WMO Region 1 - Africa (includes islands in Indian Ocean and Spanish territories off N. Africa)
+        "Africa": {"lon_min": -25, "lon_max": 80, "lat_min": -55, "lat_max": 45},
+        # WMO Region 2 - Asia (includes SE Asia, West Asia, Asian Russia, and BIOT)
+        "Asia": {"lon_min": 20, "lon_max": 180, "lat_min": -10, "lat_max": 80},
+        # Subsets
         "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},
+        # WMO Region 3 - South America (includes Falklands, South Georgia/Sandwich, Galapagos)
+        "South_America": {"lon_min": -92, "lon_max": -20, "lat_min": -60, "lat_max": 15},
+        # Legacy/compatibility subset
         "Argentina": {"lon_min": -75, "lon_max": -53, "lat_min": -55, "lat_max": -22},
+        # WMO Region 4 - North and Central America (includes Greenland and Caribbean)
+        "North_and_Central_America": {"lon_min": -180, "lon_max": 20, "lat_min": -10, "lat_max": 85},
+        # Backward-compatible subsets mapped to Region 4 KML
         "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},
+        # WMO Region 5 - Southwest Pacific (covers SE Asia + Pacific islands + Hawaii via antimeridian)
+        "Southwest_Pacific": {
+            "boxes": [
+                {"lon_min": 90, "lon_max": 180, "lat_min": -50, "lat_max": 25},
+                {"lon_min": -180, "lon_max": -140, "lat_min": -50, "lat_max": 25},
+            ]
+        },
+        # WMO Region 6 - Europe (includes Middle East countries listed and Greenland)
+        "Europe": {"lon_min": -75, "lon_max": 60, "lat_min": 25, "lat_max": 85},
+        # WMO Region 7 - Antarctica
         "Antarctica": {"lon_min": -180, "lon_max": 180, "lat_min": -90, "lat_max": -60}
     }
 
@@ -306,34 +359,45 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         elif lon > 180:
             lon_adjusted = lon - 360
             
-        # Check if coordinates fall within any region bounds
+        # Helper to test point within a single box
+        def _in_box(bx: Dict[str, float], lon_v: float, lat_v: float) -> bool:
+            return (bx["lon_min"] <= lon_v <= bx["lon_max"] and
+                    bx["lat_min"] <= lat_v <= bx["lat_max"]) 
+
+        # Check if coordinates fall within any region bounds (support multi-box)
         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 "boxes" in bounds:
+                for bx in bounds["boxes"]:
+                    if _in_box(bx, lon_adjusted, lat):
+                        matching_regions.append(region_name)
+                        break
+            else:
+                if _in_box(bounds, lon_adjusted, lat):
+                    matching_regions.append(region_name)
         
         # If no regions matched, find the closest regions by boundary distance
         if not matching_regions:
             # Calculate "distance" to each region's boundary (simplified metric)
             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 Euclidean distance metric (not actual geographic distance)
-                distance = (lon_dist**2 + lat_dist**2)**0.5
-                region_distances.append((region_name, distance))
+                def _box_distance(bx: Dict[str, float]) -> float:
+                    lon_dist = 0
+                    if lon_adjusted < bx["lon_min"]:
+                        lon_dist = bx["lon_min"] - lon_adjusted
+                    elif lon_adjusted > bx["lon_max"]:
+                        lon_dist = lon_adjusted - bx["lon_max"]
+                    lat_dist = 0
+                    if lat < bx["lat_min"]:
+                        lat_dist = bx["lat_min"] - lat
+                    elif lat > bx["lat_max"]:
+                        lat_dist = lat - bx["lat_max"]
+                    return (lon_dist**2 + lat_dist**2)**0.5
+
+                if "boxes" in bounds:
+                    d = min(_box_distance(bx) for bx in bounds["boxes"])
+                else:
+                    d = _box_distance(bounds)
+                region_distances.append((region_name, d))
             
             # Get 3 closest regions to ensure we find stations
             closest_regions = sorted(region_distances, key=lambda x: x[1])[:3]
@@ -511,6 +575,74 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         
         return metadata
 
+    def try_download_station_zip(original_url: str, timeout_s: int = 30) -> Optional[bytes]:
+        """
+        Try downloading station archive; on 404s, attempt smart fallbacks.
+        
+        Fallback strategies:
+        - Country rename: /TUR_Turkey/ -> /TUR_Turkiye/ (per Oct 2024 site update)
+        - TMYx period variants: .2009-2023.zip, .2007-2021.zip, .zip, .2004-2018.zip
+        
+        Args:
+            original_url: URL extracted from KML
+            timeout_s: request timeout seconds
+        Returns:
+            Bytes of the downloaded zip on success, otherwise None
+        """
+        def candidate_urls(url: str) -> List[str]:
+            urls = []
+            urls.append(url)
+            # Country rename variants
+            if "/TUR_Turkey/" in url:
+                urls.append(url.replace("/TUR_Turkey/", "/TUR_Turkiye/"))
+            if "/TUR_Turkiye/" in url:
+                urls.append(url.replace("/TUR_Turkiye/", "/TUR_Turkey/"))
+            # TMYx period variants
+            m = re.search(r"(.*_TMYx)(?:\.(\d{4}-\d{4}))?\.zip$", url)
+            if m:
+                base = m.group(1)
+                suffix = m.group(2)
+                variants = [
+                    f"{base}.2009-2023.zip",
+                    f"{base}.2007-2021.zip",
+                    f"{base}.zip",
+                    f"{base}.2004-2018.zip",
+                ]
+                for v in variants:
+                    if v not in urls:
+                        urls.append(v)
+                # Also apply country rename to each variant
+                extra = []
+                for v in variants:
+                    if "/TUR_Turkey/" in url:
+                        extra.append(v.replace("/TUR_Turkey/", "/TUR_Turkiye/"))
+                    if "/TUR_Turkiye/" in url:
+                        extra.append(v.replace("/TUR_Turkiye/", "/TUR_Turkey/"))
+                for v in extra:
+                    if v not in urls:
+                        urls.append(v)
+            return urls
+
+        tried = set()
+        for u in candidate_urls(original_url):
+            if u in tried:
+                continue
+            tried.add(u)
+            try:
+                resp = requests.get(u, timeout=timeout_s)
+                resp.raise_for_status()
+                return resp.content
+            except requests.exceptions.HTTPError as he:
+                # Only continue on 404; raise on other HTTP errors
+                if getattr(he.response, "status_code", None) == 404:
+                    continue
+                else:
+                    raise
+            except requests.exceptions.RequestException:
+                # On network errors, try next candidate
+                continue
+        return None
+
     def get_stations_from_kml(kml_url: str) -> List[Dict]:
         """
         Get weather stations from a KML file.
@@ -584,6 +716,18 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         
         # Determine which regions to scan based on user input or auto-detection
         regions_to_scan = {}
+        def _add_selection(selection_name: str, mapping: Dict[str, str], out: Dict[str, str]):
+            """Expand a region or dataset selection into concrete KML URLs."""
+            if selection_name in REGION_DATASET_GROUPS:
+                for key in REGION_DATASET_GROUPS[selection_name]:
+                    if key in KML_SOURCES:
+                        out[key] = KML_SOURCES[key]
+            elif selection_name in KML_SOURCES:
+                out[selection_name] = KML_SOURCES[selection_name]
+            else:
+                valid = sorted(list(REGION_DATASET_GROUPS.keys()) + list(KML_SOURCES.keys()))
+                raise ValueError(f"Invalid region/dataset: '{selection_name}'. Valid options include: {', '.join(valid)}")
+
         if region is None:
             # Auto-detect regions based on coordinates
             detected_regions = detect_regions(longitude, latitude)
@@ -591,34 +735,32 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
             if detected_regions:
                 print(f"Auto-detected regions: {', '.join(detected_regions)}")
                 for r in detected_regions:
-                    regions_to_scan[r] = KML_SOURCES[r]
+                    _add_selection(r, KML_SOURCES, regions_to_scan)
             else:
                 # Fallback to all regions if detection fails
                 print("Could not determine region from coordinates. Scanning all regions.")
-                regions_to_scan = KML_SOURCES
+                regions_to_scan = dict(KML_SOURCES)
         elif isinstance(region, str):
             # Handle string input for region selection
             if region.lower() == "all":
-                regions_to_scan = KML_SOURCES
-            elif region in KML_SOURCES:
-                regions_to_scan[region] = KML_SOURCES[region]
+                regions_to_scan = dict(KML_SOURCES)
             else:
-                valid_regions = ", ".join(KML_SOURCES.keys())
-                raise ValueError(f"Invalid region: '{region}'. Valid regions are: {valid_regions}")
+                _add_selection(region, KML_SOURCES, regions_to_scan)
         else:
             # Handle list input for multiple regions
             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]
+                _add_selection(r, KML_SOURCES, regions_to_scan)
         
         # Get stations from selected KML sources
         print("Fetching weather station data from Climate.OneBuilding.Org...")
         all_stations = []
         
         # Process each selected region
+        scanned_urls = set()
         for region_name, url in regions_to_scan.items():
+            if url in scanned_urls:
+                continue
+            scanned_urls.add(url)
             print(f"Scanning {region_name}...")
             stations = get_stations_from_kml(url)
             all_stations.extend(stations)
@@ -627,7 +769,23 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         print(f"\nTotal stations found: {len(all_stations)}")
         
         if not all_stations:
-            raise ValueError("No weather stations found")
+            # Fallback: if no stations found, try scanning all available datasets
+            if not (isinstance(region, str) and region.lower() == "all"):
+                print("No stations found from detected/selected regions. Falling back to global scan...")
+                regions_to_scan = dict(KML_SOURCES)
+                all_stations = []
+                scanned_urls = set()
+                for region_name, url in regions_to_scan.items():
+                    if url in scanned_urls:
+                        continue
+                    scanned_urls.add(url)
+                    print(f"Scanning {region_name}...")
+                    stations = get_stations_from_kml(url)
+                    all_stations.extend(stations)
+                    print(f"Found {len(stations)} stations in {region_name}")
+                print(f"\nTotal stations found after global scan: {len(all_stations)}")
+            if not all_stations:
+                raise ValueError("No weather stations found")
             
         # Calculate distances from target coordinates to all stations
         stations_with_distances = [
@@ -654,10 +812,11 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         # Find the nearest weather station
         nearest_station, distance = min(stations_with_distances, key=lambda x: x[1])
         
-        # Download the EPW file from the nearest station
+        # Download the EPW archive from the nearest station with fallbacks
         print(f"\nDownloading EPW file for {nearest_station['name']}...")
-        epw_response = requests.get(nearest_station['url'])
-        epw_response.raise_for_status()
+        archive_bytes = try_download_station_zip(nearest_station['url'], timeout_s=30)
+        if archive_bytes is None:
+            raise ValueError(f"Failed to download EPW archive from station URL and fallbacks: {nearest_station['url']}")
         
         # Create a temporary directory for zip extraction
         temp_dir = Path(output_dir) / "temp"
@@ -666,7 +825,7 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         # Save the downloaded zip file temporarily
         zip_file = temp_dir / "weather_data.zip"
         with open(zip_file, 'wb') as f:
-            f.write(epw_response.content)
+            f.write(archive_bytes)
         
         final_epw = None
         try:

{voxcity-0.6.17.dist-info → voxcity-0.6.19.dist-info}/METADATA

@@ -1,8 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: voxcity
-Version: 0.6.17
+Version: 0.6.19
 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
+License-File: AUTHORS.rst
+License-File: LICENSE
 Author: Kunihiko Fujiwara
 Author-email: fujiwara.kunihiko@takenaka.co.jp
 Maintainer: Kunihiko Fujiwara
@@ -27,6 +29,7 @@ Requires-Dist: ipyleaflet
 Requires-Dist: joblib
 Requires-Dist: lxml
 Requires-Dist: matplotlib
+Requires-Dist: netCDF4
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: osmnx
@@ -51,6 +54,7 @@ Requires-Dist: timezonefinder
 Requires-Dist: tqdm
 Requires-Dist: trimesh
 Requires-Dist: typer
+Requires-Dist: xarray
 Project-URL: bugs, https://github.com/kunifujiwara/voxcity/issues
 Project-URL: changelog, https://github.com/kunifujiwara/voxcity/blob/master/changelog.md
 Project-URL: homepage, https://github.com/kunifujiwara/voxcity
@@ -232,7 +236,7 @@ Generate voxel data grids and corresponding building geoJSON:
 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, \
+building_id_grid, canopy_height_grid, canopy_bottom_height_grid, land_cover_grid, dem_grid, \
 building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,

{voxcity-0.6.17.dist-info → voxcity-0.6.19.dist-info}/RECORD

@@ -8,11 +8,12 @@ voxcity/downloader/oemj.py,sha256=iDacTpiqn7RAXuqyEtHP29m0Cycwta5sMy9-GdvX3Fg,12
 voxcity/downloader/osm.py,sha256=7Wo6lSodci7gALMKLQ_0ricmn0ZrfUK90vKYQ-ayU2A,46285
 voxcity/downloader/overture.py,sha256=hVxu-3Fmuu2E1tEzcDcNyU1cR-aE-6h6jkcxkuqN1-s,13343
 voxcity/downloader/utils.py,sha256=tz6wt4B9BhEOyvoF5OYXlr8rUd5cBEDedWL3j__oT70,3099
-voxcity/exporter/__init__.py,sha256=dvyWJ184Eik9tFc0VviGbzTQzZi7O0JNyrqi_n39pVI,94
+voxcity/exporter/__init__.py,sha256=ikmRs3jGKvYTjpleiROfiCPYlwtqxwl1T6pk8pievQw,117
 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/exporter/netcdf.py,sha256=48rJ3wDsFhi9ANbElhMjXLxWMJoJzBt1gFbN0ekPp-A,7404
+voxcity/exporter/obj.py,sha256=7xmVSQ_y-X8QLjNdASDPsaltGvmyW9-yAacocByYKl4,58160
 voxcity/generator.py,sha256=4WSjO09f8z3zt0tpKY0fyAfOMym1JT4VH3Tt1lOg2Bk,66900
 voxcity/geoprocessor/__init__.py,sha256=WYxcAQrjGucIvGHF0JTC6rONZzL3kCms1S2vpzS6KaU,127
 voxcity/geoprocessor/draw.py,sha256=AZMWq23wxxDJygNloCbVzWAAr1JO7nC94umf9LSxJ5o,49248
@@ -28,10 +29,10 @@ voxcity/simulator/view.py,sha256=k3FoS6gsibR-eDrTHJivJSQfvN3Tg8R8eSTeMqd9ans,939
 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=TQKMmATpAqSDTPMvMi1a-n2CvvzE2KcYVsss7iiShS4,116877
-voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.6.17.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.6.17.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.6.17.dist-info/METADATA,sha256=pAyV4xbQG-58dQrWCWOMqcVCn1pDkhq8DXDs7SteiG8,26092
-voxcity-0.6.17.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-voxcity-0.6.17.dist-info/RECORD,,
+voxcity/utils/visualization.py,sha256=_c5WnhA0fawkseUviKEIpUUsF-M-OOLOT9FrpgQIh1A,118556
+voxcity/utils/weather.py,sha256=WcmohW0yx2-uNMO5ffgxCtKUt32q6PQsAT43P5DwJx4,44760
+voxcity-0.6.19.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.19.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.19.dist-info/METADATA,sha256=AUmkbdSOZM7RywhizzSM_xzphJ-QLbQEuHx9IjvGSKQ,26212
+voxcity-0.6.19.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+voxcity-0.6.19.dist-info/RECORD,,

{voxcity-0.6.17.dist-info → voxcity-0.6.19.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.0
 Root-Is-Purelib: true
 Tag: py3-none-any