voxcity 1.0.2__py3-none-any.whl → 1.0.15__py3-none-any.whl

voxcity/generator/grids.py

@@ -46,16 +46,19 @@ def get_last_effective_land_cover_source():
 
 
 def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, print_class_info=True, **kwargs):
-    print("Creating Land Use Land Cover grid\n ")
-    print(f"Data source: {source}")
-    if print_class_info:
-        print(get_source_class_descriptions(source))
+    quiet = kwargs.get('quiet', False)
+    if not quiet:
+        print("Creating Land Use Land Cover grid\n ")
+        print(f"Data source: {source}")
+        if print_class_info:
+            print(get_source_class_descriptions(source))
 
     if source not in ["OpenStreetMap", "OpenEarthMapJapan"]:
         try:
             initialize_earth_engine()
         except Exception as e:
-            print("Earth Engine unavailable (", str(e), ") — falling back to OpenStreetMap for land cover.")
+            if not quiet:
+                print("Earth Engine unavailable (", str(e), ") — falling back to OpenStreetMap for land cover.")
             source = 'OpenStreetMap'
 
     os.makedirs(output_dir, exist_ok=True)
@@ -70,11 +73,12 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, print_
         try:
             image = get_ee_image_collection(collection_name, roi)
             # If collection is empty, image operations may fail; guard with try/except
-            save_geotiff(image, geotiff_path)
+            save_geotiff(image, geotiff_path, scale=meshsize, region=roi, crs='EPSG:4326')
             if (not os.path.exists(geotiff_path)) or (os.path.getsize(geotiff_path) == 0):
                 raise RuntimeError("Urbanwatch export produced no file")
         except Exception as e:
-            print("Urbanwatch coverage not found for AOI; falling back to OpenStreetMap (reason:", str(e), ")")
+            if not quiet:
+                print("Urbanwatch coverage not found for AOI; falling back to OpenStreetMap (reason:", str(e), ")")
             effective_source = 'OpenStreetMap'
             land_cover_gdf = load_land_cover_gdf_from_osm(rectangle_vertices)
     elif source == 'ESA WorldCover':
@@ -114,7 +118,11 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, print_
 
     if effective_source == 'OpenStreetMap':
         default_class = kwargs.get('default_land_cover_class', 'Developed space')
-        land_cover_grid_str = create_land_cover_grid_from_gdf_polygon(land_cover_gdf, meshsize, effective_source, rectangle_vertices, default_class=default_class)
+        detect_ocean = kwargs.get('detect_ocean', True)  # Default True for OSM
+        land_cover_grid_str = create_land_cover_grid_from_gdf_polygon(
+            land_cover_gdf, meshsize, effective_source, rectangle_vertices, 
+            default_class=default_class, detect_ocean=detect_ocean
+        )
     else:
         land_cover_grid_str = create_land_cover_grid_from_geotiff_polygon(geotiff_path, meshsize, land_cover_classes, rectangle_vertices)
 
@@ -137,14 +145,17 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
     if source in ee_required_sources:
         initialize_earth_engine()
 
-    print("Creating Building Height grid\n ")
-    print(f"Base data source: {source}")
+    quiet = kwargs.get('quiet', False)
+    if not quiet:
+        print("Creating Building Height grid\n ")
+        print(f"Base data source: {source}")
 
     os.makedirs(output_dir, exist_ok=True)
 
     if building_gdf is not None:
         gdf = building_gdf
-        print("Using provided GeoDataFrame for building data")
+        if not quiet:
+            print("Using provided GeoDataFrame for building data")
     else:
         floor_height = kwargs.get("floor_height", 3.0)
         if source == 'Microsoft Building Footprints':
@@ -171,7 +182,8 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
     building_complementary_source = kwargs.get("building_complementary_source")
     try:
         comp_label = building_complementary_source if building_complementary_source not in (None, "") else "None"
-        print(f"Complementary data source: {comp_label}")
+        if not quiet:
+            print(f"Complementary data source: {comp_label}")
     except Exception:
         pass
     building_complement_height = kwargs.get("building_complement_height")
@@ -189,7 +201,8 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
                 save_geotiff_open_buildings_temporal(roi, geotiff_path_comp)
                 building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp, complement_height=building_complement_height, overlapping_footprint=overlapping_footprint)
             except Exception as e:
-                print("Open Building 2.5D Temporal requires Earth Engine (", str(e), ") — proceeding without complementary raster.")
+                if not quiet:
+                    print("Open Building 2.5D Temporal requires Earth Engine (", str(e), ") — proceeding without complementary raster.")
                 building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, complement_height=building_complement_height, overlapping_footprint=overlapping_footprint)
         elif building_complementary_source in ["England 1m DSM - DTM", "Netherlands 0.5m DSM - DTM"]:
             try:
@@ -199,7 +212,8 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
                 save_geotiff_dsm_minus_dtm(roi, geotiff_path_comp, meshsize, building_complementary_source)
                 building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp, complement_height=building_complement_height, overlapping_footprint=overlapping_footprint)
             except Exception as e:
-                print("DSM-DTM complementary raster requires Earth Engine (", str(e), ") — proceeding without complementary raster.")
+                if not quiet:
+                    print("DSM-DTM complementary raster requires Earth Engine (", str(e), ") — proceeding without complementary raster.")
                 building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, complement_height=building_complement_height, overlapping_footprint=overlapping_footprint)
         else:
             if building_complementary_source == 'Microsoft Building Footprints':
@@ -232,8 +246,10 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
 
 
 def get_canopy_height_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
-    print("Creating Canopy Height grid\n ")
-    print(f"Data source: {source}")
+    quiet = kwargs.get('quiet', False)
+    if not quiet:
+        print("Creating Canopy Height grid\n ")
+        print(f"Data source: {source}")
 
     os.makedirs(output_dir, exist_ok=True)
 
@@ -297,7 +313,8 @@ def get_canopy_height_grid(rectangle_vertices, meshsize, source, output_dir, **k
     try:
         initialize_earth_engine()
     except Exception as e:
-        print("Earth Engine unavailable (", str(e), ") — falling back to Static canopy heights.")
+        if not quiet:
+            print("Earth Engine unavailable (", str(e), ") — falling back to Static canopy heights.")
         # Re-enter with explicit Static logic using land cover mask
         return get_canopy_height_grid(rectangle_vertices, meshsize, 'Static', output_dir, **kwargs)
 
@@ -313,7 +330,7 @@ def get_canopy_height_grid(rectangle_vertices, meshsize, source, output_dir, **k
     else:
         raise ValueError(f"Unsupported canopy source: {source}")
 
-    save_geotiff(image, geotiff_path, resolution=meshsize)
+    save_geotiff(image, geotiff_path, scale=meshsize, region=roi, crs='EPSG:4326')
     canopy_height_grid = create_height_grid_from_geotiff_polygon(geotiff_path, meshsize, rectangle_vertices)
 
     trunk_height_ratio = kwargs.get("trunk_height_ratio")
@@ -330,8 +347,10 @@ def get_canopy_height_grid(rectangle_vertices, meshsize, source, output_dir, **k
 
 
 def get_dem_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
-    print("Creating Digital Elevation Model (DEM) grid\n ")
-    print(f"Data source: {source}")
+    quiet = kwargs.get('quiet', False)
+    if not quiet:
+        print("Creating Digital Elevation Model (DEM) grid\n ")
+        print(f"Data source: {source}")
 
     if source == "Local file":
         geotiff_path = kwargs["dem_path"]
@@ -339,18 +358,12 @@ def get_dem_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
         try:
             initialize_earth_engine()
         except Exception as e:
-            print("Earth Engine unavailable (", str(e), ") — falling back to flat DEM.")
-            dem_interpolation = kwargs.get("dem_interpolation")
-            # Return flat DEM (zeros) with same shape as would be produced after rasterization
-            # We defer to downstream to handle zeros appropriately.
-            # To avoid shape inference here, we'll build after default path below.
-            geotiff_path = None
-            # Bypass EE path and produce zeros later
-            dem_grid = np.zeros((1, 1), dtype=float)
-            # Build shape using land cover grid shape if provided via kwargs for robustness
-            lc_like = kwargs.get("land_cover_like")
-            if lc_like is not None:
-                dem_grid = np.zeros_like(lc_like)
+            if not quiet:
+                print("Earth Engine unavailable (", str(e), ") — falling back to flat DEM.")
+            # Compute grid shape directly from rectangle_vertices and meshsize
+            from ..geoprocessor.raster.core import compute_grid_shape
+            grid_shape = compute_grid_shape(rectangle_vertices, meshsize)
+            dem_grid = np.zeros(grid_shape, dtype=float)
             return dem_grid
 
         geotiff_path = os.path.join(output_dir, "dem.tif")

voxcity/generator/pipeline.py

@@ -1,6 +1,7 @@
 import os
 from ..utils.logging import get_logger
 from typing import Optional
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import numpy as np
 
 from ..models import (
@@ -78,33 +79,70 @@ class VoxCityPipeline:
         canopy_strategy = CanopySourceFactory.create(cfg.canopy_height_source, cfg)
         dem_strategy = DemSourceFactory.create(cfg.dem_source)
 
-        # Prefer structured options from cfg; allow legacy kwargs for back-compat
-        land_cover_grid = land_strategy.build_grid(
-            cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
-            **{**cfg.land_cover_options, **kwargs}
-        )
-        # Detect effective land cover source (e.g., Urbanwatch -> OpenStreetMap fallback)
-        try:
-            from .grids import get_last_effective_land_cover_source
-            lc_src_effective = get_last_effective_land_cover_source() or cfg.land_cover_source
-        except Exception:
-            lc_src_effective = cfg.land_cover_source
-        bh, bmin, bid, building_gdf_out = build_strategy.build_grids(
-            cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
-            building_gdf=building_gdf,
-            **{**cfg.building_options, **kwargs}
-        )
-        canopy_top, canopy_bottom = canopy_strategy.build_grids(
-            cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
-            land_cover_source=lc_src_effective,
-            **{**cfg.canopy_options, **kwargs}
-        )
-        dem = dem_strategy.build_grid(
-            cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
-            terrain_gdf=terrain_gdf,
-            land_cover_like=land_cover_grid,
-            **{**cfg.dem_options, **kwargs}
-        )
+        # Check if parallel download is enabled
+        parallel_download = getattr(cfg, 'parallel_download', False)
+
+        if parallel_download and cfg.canopy_height_source != "Static":
+            # All 4 downloads are independent - run in parallel
+            land_cover_grid, bh, bmin, bid, building_gdf_out, canopy_top, canopy_bottom, dem, lc_src_effective = \
+                self._run_parallel_downloads(
+                    cfg, land_strategy, build_strategy, canopy_strategy, dem_strategy,
+                    building_gdf, terrain_gdf, kwargs
+                )
+            # Run visualizations after parallel downloads complete (if gridvis enabled)
+            if kwargs.get('gridvis', cfg.gridvis):
+                self._visualize_grids_after_parallel(
+                    land_cover_grid, bh, canopy_top, dem, 
+                    lc_src_effective, cfg.meshsize
+                )
+        elif parallel_download and cfg.canopy_height_source == "Static":
+            # Static canopy needs land_cover_grid for tree mask
+            # Run land_cover + building + dem in parallel, then canopy sequentially
+            land_cover_grid, bh, bmin, bid, building_gdf_out, dem, lc_src_effective = \
+                self._run_parallel_downloads_static_canopy(
+                    cfg, land_strategy, build_strategy, dem_strategy,
+                    building_gdf, terrain_gdf, kwargs
+                )
+            # Visualize land_cover, building, dem after parallel (if gridvis enabled)
+            if kwargs.get('gridvis', cfg.gridvis):
+                self._visualize_grids_after_parallel(
+                    land_cover_grid, bh, None, dem,
+                    lc_src_effective, cfg.meshsize
+                )
+            # Now run canopy with land_cover_grid available (this will visualize itself)
+            canopy_top, canopy_bottom = canopy_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
+                land_cover_source=lc_src_effective,
+                **{**cfg.canopy_options, **kwargs}
+            )
+        else:
+            # Sequential mode (original behavior)
+            land_cover_grid = land_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                **{**cfg.land_cover_options, **kwargs}
+            )
+            # Detect effective land cover source (e.g., Urbanwatch -> OpenStreetMap fallback)
+            try:
+                from .grids import get_last_effective_land_cover_source
+                lc_src_effective = get_last_effective_land_cover_source() or cfg.land_cover_source
+            except Exception:
+                lc_src_effective = cfg.land_cover_source
+            bh, bmin, bid, building_gdf_out = build_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                building_gdf=building_gdf,
+                **{**cfg.building_options, **kwargs}
+            )
+            canopy_top, canopy_bottom = canopy_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
+                land_cover_source=lc_src_effective,
+                **{**cfg.canopy_options, **kwargs}
+            )
+            dem = dem_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
+                terrain_gdf=terrain_gdf,
+                land_cover_like=land_cover_grid,
+                **{**cfg.dem_options, **kwargs}
+            )
 
         ro = cfg.remove_perimeter_object
         if (ro is not None) and (ro > 0):
@@ -152,6 +190,258 @@ class VoxCityPipeline:
             },
         )
 
+    def _visualize_grids_after_parallel(
+        self, land_cover_grid, building_height_grid, canopy_top, dem_grid,
+        land_cover_source, meshsize
+    ):
+        """
+        Run grid visualizations after parallel downloads complete.
+        This ensures matplotlib calls happen sequentially on the main thread.
+        """
+        from ..visualizer.grids import visualize_land_cover_grid, visualize_numerical_grid
+        from ..utils.lc import get_land_cover_classes
+        
+        # Visualize land cover (convert int grid back to string for visualization)
+        try:
+            land_cover_classes = get_land_cover_classes(land_cover_source)
+            # Create reverse mapping: int -> string class name
+            int_to_class = {i: name for i, name in enumerate(land_cover_classes.values())}
+            # Convert integer grid to string grid for visualization
+            land_cover_grid_str = np.empty(land_cover_grid.shape, dtype=object)
+            for i, name in int_to_class.items():
+                land_cover_grid_str[land_cover_grid == i] = name
+            color_map = {cls: [r/255, g/255, b/255] for (r,g,b), cls in land_cover_classes.items()}
+            visualize_land_cover_grid(np.flipud(land_cover_grid_str), meshsize, color_map, land_cover_classes)
+        except Exception as e:
+            get_logger(__name__).warning("Land cover visualization failed: %s", e)
+        
+        # Visualize building height
+        try:
+            building_height_grid_nan = building_height_grid.copy().astype(float)
+            building_height_grid_nan[building_height_grid_nan == 0] = np.nan
+            visualize_numerical_grid(np.flipud(building_height_grid_nan), meshsize, "building height (m)", cmap='viridis', label='Value')
+        except Exception as e:
+            get_logger(__name__).warning("Building height visualization failed: %s", e)
+        
+        # Visualize canopy height (if provided)
+        if canopy_top is not None:
+            try:
+                canopy_height_grid_nan = canopy_top.copy()
+                canopy_height_grid_nan[canopy_height_grid_nan == 0] = np.nan
+                visualize_numerical_grid(np.flipud(canopy_height_grid_nan), meshsize, "Tree canopy height", cmap='Greens', label='Tree canopy height (m)')
+            except Exception as e:
+                get_logger(__name__).warning("Canopy height visualization failed: %s", e)
+        
+        # Visualize DEM
+        try:
+            visualize_numerical_grid(np.flipud(dem_grid), meshsize, title='Digital Elevation Model', cmap='terrain', label='Elevation (m)')
+        except Exception as e:
+            get_logger(__name__).warning("DEM visualization failed: %s", e)
+
+    def _run_parallel_downloads(
+        self, cfg, land_strategy, build_strategy, canopy_strategy, dem_strategy,
+        building_gdf, terrain_gdf, kwargs
+    ):
+        """
+        Run all 4 downloads (land_cover, building, canopy, dem) in parallel.
+        Used when canopy source is NOT 'Static' (no land_cover dependency).
+        """
+        import logging
+        logger = get_logger(__name__)
+        
+        # Print clean header for parallel mode
+        print("\n" + "="*60)
+        print("Downloading data in parallel mode (4 concurrent downloads)")
+        print("="*60)
+        print(f"  • Land Cover:  {cfg.land_cover_source}")
+        print(f"  • Building:    {cfg.building_source}")
+        print(f"  • Canopy:      {cfg.canopy_height_source}")
+        print(f"  • DEM:         {cfg.dem_source}")
+        print("-"*60)
+        print("Downloading... (this may take a moment)")
+        
+        results = {}
+        
+        # Disable gridvis and verbose prints in parallel mode
+        # Also suppress httpx INFO logs during parallel downloads
+        parallel_kwargs = {**kwargs, 'gridvis': False, 'print_class_info': False, 'quiet': True}
+        lc_opts = {**cfg.land_cover_options, 'gridvis': False, 'print_class_info': False, 'quiet': True}
+        bld_opts = {**cfg.building_options, 'gridvis': False, 'quiet': True}
+        canopy_opts = {**cfg.canopy_options, 'gridvis': False, 'quiet': True}
+        dem_opts = {**cfg.dem_options, 'gridvis': False, 'quiet': True}
+        
+        # Suppress httpx verbose logging during parallel downloads
+        httpx_logger = logging.getLogger("httpx")
+        original_httpx_level = httpx_logger.level
+        httpx_logger.setLevel(logging.WARNING)
+        
+        def download_land_cover():
+            grid = land_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                **{**lc_opts, **parallel_kwargs}
+            )
+            # Get effective source after download
+            try:
+                from .grids import get_last_effective_land_cover_source
+                effective = get_last_effective_land_cover_source() or cfg.land_cover_source
+            except Exception:
+                effective = cfg.land_cover_source
+            return ('land_cover', (grid, effective))
+        
+        def download_building():
+            bh, bmin, bid, gdf_out = build_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                building_gdf=building_gdf,
+                **{**bld_opts, **parallel_kwargs}
+            )
+            return ('building', (bh, bmin, bid, gdf_out))
+        
+        def download_canopy():
+            # For non-static canopy, we don't need land_cover_grid
+            # Pass None or empty array as placeholder - the strategy will download from GEE
+            placeholder_grid = np.zeros((1, 1), dtype=float)
+            top, bottom = canopy_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, placeholder_grid, cfg.output_dir,
+                land_cover_source=cfg.land_cover_source,
+                **{**canopy_opts, **parallel_kwargs}
+            )
+            return ('canopy', (top, bottom))
+        
+        def download_dem():
+            # DEM no longer depends on land_cover_like for shape
+            dem = dem_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, None, cfg.output_dir,
+                terrain_gdf=terrain_gdf,
+                **{**dem_opts, **parallel_kwargs}
+            )
+            return ('dem', dem)
+        
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [
+                executor.submit(download_land_cover),
+                executor.submit(download_building),
+                executor.submit(download_canopy),
+                executor.submit(download_dem),
+            ]
+            completed_count = 0
+            for future in as_completed(futures):
+                try:
+                    key, value = future.result()
+                    results[key] = value
+                    completed_count += 1
+                    print(f"  ✓ {key.replace('_', ' ').title()} complete ({completed_count}/4)")
+                except Exception as e:
+                    logger.error("Parallel download failed: %s", e)
+                    httpx_logger.setLevel(original_httpx_level)  # Restore before raising
+                    raise
+        
+        # Restore httpx logging level
+        httpx_logger.setLevel(original_httpx_level)
+        
+        print("-"*60)
+        print("All downloads complete!")
+        print("="*60 + "\n")
+        
+        land_cover_grid, lc_src_effective = results['land_cover']
+        bh, bmin, bid, building_gdf_out = results['building']
+        canopy_top, canopy_bottom = results['canopy']
+        dem = results['dem']
+        
+        return land_cover_grid, bh, bmin, bid, building_gdf_out, canopy_top, canopy_bottom, dem, lc_src_effective
+
+    def _run_parallel_downloads_static_canopy(
+        self, cfg, land_strategy, build_strategy, dem_strategy,
+        building_gdf, terrain_gdf, kwargs
+    ):
+        """
+        Run land_cover, building, and dem downloads in parallel.
+        Canopy (Static mode) will be run sequentially after, as it needs land_cover_grid.
+        """
+        import logging
+        logger = get_logger(__name__)
+        
+        # Print clean header for parallel mode
+        print("\n" + "="*60)
+        print("Downloading data in parallel mode (3 concurrent + 1 deferred)")
+        print("="*60)
+        print(f"  • Land Cover:  {cfg.land_cover_source}")
+        print(f"  • Building:    {cfg.building_source}")
+        print(f"  • DEM:         {cfg.dem_source}")
+        print(f"  • Canopy:      {cfg.canopy_height_source} (deferred)")
+        print("-"*60)
+        print("Downloading... (this may take a moment)")
+        
+        results = {}
+        
+        # Disable gridvis and verbose prints in parallel mode
+        parallel_kwargs = {**kwargs, 'gridvis': False, 'print_class_info': False, 'quiet': True}
+        lc_opts = {**cfg.land_cover_options, 'gridvis': False, 'print_class_info': False, 'quiet': True}
+        bld_opts = {**cfg.building_options, 'gridvis': False, 'quiet': True}
+        dem_opts = {**cfg.dem_options, 'gridvis': False, 'quiet': True}
+        
+        # Suppress httpx verbose logging during parallel downloads
+        httpx_logger = logging.getLogger("httpx")
+        original_httpx_level = httpx_logger.level
+        httpx_logger.setLevel(logging.WARNING)
+        
+        def download_land_cover():
+            grid = land_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                **{**lc_opts, **parallel_kwargs}
+            )
+            try:
+                from .grids import get_last_effective_land_cover_source
+                effective = get_last_effective_land_cover_source() or cfg.land_cover_source
+            except Exception:
+                effective = cfg.land_cover_source
+            return ('land_cover', (grid, effective))
+        
+        def download_building():
+            bh, bmin, bid, gdf_out = build_strategy.build_grids(
+                cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+                building_gdf=building_gdf,
+                **{**bld_opts, **parallel_kwargs}
+            )
+            return ('building', (bh, bmin, bid, gdf_out))
+        
+        def download_dem():
+            dem = dem_strategy.build_grid(
+                cfg.rectangle_vertices, cfg.meshsize, None, cfg.output_dir,
+                terrain_gdf=terrain_gdf,
+                **{**dem_opts, **parallel_kwargs}
+            )
+            return ('dem', dem)
+        
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [
+                executor.submit(download_land_cover),
+                executor.submit(download_building),
+                executor.submit(download_dem),
+            ]
+            completed_count = 0
+            for future in as_completed(futures):
+                try:
+                    key, value = future.result()
+                    results[key] = value
+                    completed_count += 1
+                    print(f"  ✓ {key.replace('_', ' ').title()} complete ({completed_count}/3)")
+                except Exception as e:
+                    logger.error("Parallel download failed: %s", e)
+                    httpx_logger.setLevel(original_httpx_level)
+                    raise
+        
+        # Restore httpx logging level
+        httpx_logger.setLevel(original_httpx_level)
+        
+        print("-"*60)
+        print("Parallel downloads complete! Processing canopy...")
+        
+        land_cover_grid, lc_src_effective = results['land_cover']
+        bh, bmin, bid, building_gdf_out = results['building']
+        dem = results['dem']
+        
+        return land_cover_grid, bh, bmin, bid, building_gdf_out, dem, lc_src_effective
+
 
 class LandCoverSourceStrategy:  # ABC simplified to avoid dependency in split
     def build_grid(self, rectangle_vertices, meshsize: float, output_dir: str, **kwargs):  # pragma: no cover - interface
@@ -246,6 +536,11 @@ class DemSourceStrategy:  # ABC simplified
 
 class FlatDemStrategy(DemSourceStrategy):
     def build_grid(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):
+        # Compute shape from rectangle_vertices if land_cover_grid is None
+        if land_cover_grid is None:
+            from ..geoprocessor.raster.core import compute_grid_shape
+            grid_shape = compute_grid_shape(rectangle_vertices, meshsize)
+            return np.zeros(grid_shape, dtype=float)
         return np.zeros_like(land_cover_grid)
 
 
@@ -264,6 +559,11 @@ class SourceDemStrategy(DemSourceStrategy):
             # Fallback to flat DEM if source fails or unsupported
             logger = get_logger(__name__)
             logger.warning("DEM source '%s' failed (%s). Falling back to flat DEM.", self.source, e)
+            # Compute shape from rectangle_vertices if land_cover_grid is None
+            if land_cover_grid is None:
+                from ..geoprocessor.raster.core import compute_grid_shape
+                grid_shape = compute_grid_shape(rectangle_vertices, meshsize)
+                return np.zeros(grid_shape, dtype=float)
             return np.zeros_like(land_cover_grid)
 
 

voxcity/geoprocessor/draw.py

@@ -337,23 +337,29 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
             print(f"Point drawn at Longitude: {lon}, Latitude: {lat}")
             
             # Calculate corner points using geopy's distance calculator
-            # Each point is calculated as a destination from center point using bearing
+            # First calculate north/south latitudes from center
             north = distance.distance(meters=north_south_length/2).destination((lat, lon), bearing=0)
             south = distance.distance(meters=north_south_length/2).destination((lat, lon), bearing=180)
-            east = distance.distance(meters=east_west_length/2).destination((lat, lon), bearing=90)
-            west = distance.distance(meters=east_west_length/2).destination((lat, lon), bearing=270)
+            
+            # Calculate east/west at the SOUTH latitude to ensure correct grid dimensions
+            # The grid size calculation uses the SW corner (vertex_0) as reference,
+            # measuring E-W distance along the south edge. By calculating east/west
+            # at the south latitude, we ensure the E-W distance matches the requested length.
+            east_at_south = distance.distance(meters=east_west_length/2).destination((south.latitude, lon), bearing=90)
+            west_at_south = distance.distance(meters=east_west_length/2).destination((south.latitude, lon), bearing=270)
 
             # Create rectangle vertices in counter-clockwise order (lon,lat)
+            # Using the east/west longitudes calculated at south latitude for all corners
             rectangle_vertices.extend([
-                (west.longitude, south.latitude),
-                (west.longitude, north.latitude),
-                (east.longitude, north.latitude),
-                (east.longitude, south.latitude)                
+                (west_at_south.longitude, south.latitude),
+                (west_at_south.longitude, north.latitude),
+                (east_at_south.longitude, north.latitude),
+                (east_at_south.longitude, south.latitude)                
             ])
 
             # Create and add new rectangle to map (ipyleaflet expects lat,lon)
             rectangle = Rectangle(
-                bounds=[(north.latitude, west.longitude), (south.latitude, east.longitude)],
+                bounds=[(north.latitude, west_at_south.longitude), (south.latitude, east_at_south.longitude)],
                 color="red",
                 fill_color="red",
                 fill_opacity=0.2

voxcity/geoprocessor/raster/__init__.py

@@ -19,6 +19,7 @@ from .core import (
     calculate_grid_size,
     create_coordinate_mesh,
     create_cell_polygon,
+    compute_grid_shape,
 )
 
 from .landcover import (
@@ -58,6 +59,7 @@ __all__ = [
     "calculate_grid_size",
     "create_coordinate_mesh",
     "create_cell_polygon",
+    "compute_grid_shape",
     # landcover
     "tree_height_grid_from_land_cover",
     "create_land_cover_grid_from_geotiff_polygon",

voxcity/geoprocessor/raster/core.py

@@ -2,6 +2,8 @@ import numpy as np
 from typing import Tuple, Dict, Any
 from shapely.geometry import Polygon
 
+from ..utils import initialize_geod, calculate_distance, normalize_to_one_meter
+
 
 def apply_operation(arr: np.ndarray, meshsize: float) -> np.ndarray:
     """
@@ -146,5 +148,34 @@ def create_cell_polygon(
     return Polygon([bottom_left, bottom_right, top_right, top_left])
 
 
+def compute_grid_shape(rectangle_vertices, meshsize: float) -> Tuple[int, int]:
+    """
+    Compute the grid dimensions (rows, cols) for a given rectangle and mesh size.
+    
+    This is useful when you need to know the output grid shape without
+    actually creating the grid (e.g., for pre-allocating arrays or fallback shapes).
+    
+    Args:
+        rectangle_vertices: List of 4 vertices [(lon, lat), ...] defining the rectangle.
+        meshsize: Grid cell size in meters.
+        
+    Returns:
+        Tuple of (grid_size_0, grid_size_1) representing grid dimensions.
+    """
+    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)
+    
+    grid_size, _ = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    return grid_size
+
+