geoai-py 0.4.2__py2.py3-none-any.whl → 0.5.0__py2.py3-none-any.whl

geoai/extract.py

@@ -19,6 +19,7 @@ from torchvision.models.detection import (
     maskrcnn_resnet50_fpn,
 )
 from tqdm import tqdm
+import time
 
 # Local Imports
 from .utils import get_raster_stats
@@ -2117,6 +2118,7 @@ class ObjectDetector:
         confidence_threshold=0.5,
         min_object_area=100,
         max_object_area=None,
+        n_workers=None,
         **kwargs,
     ):
         """
@@ -2128,14 +2130,103 @@ class ObjectDetector:
             confidence_threshold: Minimum confidence score (0.0-1.0). Default: 0.5
             min_object_area: Minimum area in pixels to keep an object. Default: 100
             max_object_area: Maximum area in pixels to keep an object. Default: None
+            n_workers: int, default=None
+                The number of worker threads to use.
+                "None" means single-threaded processing.
+                "-1"   means using all available CPU processors.
+                Positive integer means using that specific number of threads.
             **kwargs: Additional parameters
 
         Returns:
             GeoDataFrame with car detections and confidence values
         """
 
+        def _process_single_component(
+            component_mask,
+            conf_data,
+            transform,
+            confidence_threshold,
+            min_object_area,
+            max_object_area,
+        ):
+            # Get confidence value
+            conf_region = conf_data[component_mask > 0]
+            if len(conf_region) > 0:
+                confidence = np.mean(conf_region) / 255.0
+            else:
+                confidence = 0.0
+
+            # Skip if confidence is below threshold
+            if confidence < confidence_threshold:
+                return None
+
+            # Find contours
+            contours, _ = cv2.findContours(
+                component_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            results = []
+
+            for contour in contours:
+                # Filter by size
+                area = cv2.contourArea(contour)
+                if area < min_object_area:
+                    continue
+
+                if max_object_area is not None and area > max_object_area:
+                    continue
+
+                # Get minimum area rectangle
+                rect = cv2.minAreaRect(contour)
+                box_points = cv2.boxPoints(rect)
+
+                # Convert to geographic coordinates
+                geo_points = []
+                for x, y in box_points:
+                    gx, gy = transform * (x, y)
+                    geo_points.append((gx, gy))
+
+                # Create polygon
+                poly = Polygon(geo_points)
+                results.append((poly, confidence, area))
+
+            return results
+
+        import concurrent.futures
+        from functools import partial
+
+        def process_component(args):
+            """
+            Helper function to process a single component
+            """
+            (
+                label,
+                labeled_mask,
+                conf_data,
+                transform,
+                confidence_threshold,
+                min_object_area,
+                max_object_area,
+            ) = args
+
+            # Create mask for this component
+            component_mask = (labeled_mask == label).astype(np.uint8)
+
+            return _process_single_component(
+                component_mask,
+                conf_data,
+                transform,
+                confidence_threshold,
+                min_object_area,
+                max_object_area,
+            )
+
+        start_time = time.time()
         print(f"Processing masks from: {masks_path}")
 
+        if n_workers == -1:
+            n_workers = os.cpu_count()
+
         with rasterio.open(masks_path) as src:
             # Read mask and confidence bands
             mask_data = src.read(1)
@@ -2155,56 +2246,68 @@ class ObjectDetector:
             confidences = []
             pixels = []
 
-            # Add progress bar
-            for label in tqdm(range(1, num_features + 1), desc="Processing components"):
-                # Create mask for this component
-                component_mask = (labeled_mask == label).astype(np.uint8)
-
-                # Get confidence value (mean of non-zero values in this region)
-                conf_region = conf_data[component_mask > 0]
-                if len(conf_region) > 0:
-                    confidence = (
-                        np.mean(conf_region) / 255.0
-                    )  # Convert back to 0-1 range
-                else:
-                    confidence = 0.0
-
-                # Skip if confidence is below threshold
-                if confidence < confidence_threshold:
-                    continue
-
-                # Find contours
-                contours, _ = cv2.findContours(
-                    component_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            if n_workers is None or n_workers == 1:
+                print(
+                    "Using single-threaded processing, you can speed up processing by setting n_workers > 1"
                 )
+                # Add progress bar
+                for label in tqdm(
+                    range(1, num_features + 1), desc="Processing components"
+                ):
+                    # Create mask for this component
+                    component_mask = (labeled_mask == label).astype(np.uint8)
+
+                    result = _process_single_component(
+                        component_mask,
+                        conf_data,
+                        transform,
+                        confidence_threshold,
+                        min_object_area,
+                        max_object_area,
+                    )
 
-                for contour in contours:
-                    # Filter by size
-                    area = cv2.contourArea(contour)
-                    if area < min_object_area:
-                        continue
-
-                    if max_object_area is not None:
-                        if area > max_object_area:
-                            continue
-
-                    # Get minimum area rectangle
-                    rect = cv2.minAreaRect(contour)
-                    box_points = cv2.boxPoints(rect)
+                    if result:
+                        for poly, confidence, area in result:
+                            # Add to lists
+                            polygons.append(poly)
+                            confidences.append(confidence)
+                            pixels.append(area)
 
-                    # Convert to geographic coordinates
-                    geo_points = []
-                    for x, y in box_points:
-                        gx, gy = transform * (x, y)
-                        geo_points.append((gx, gy))
-
-                    # Create polygon
-                    poly = Polygon(geo_points)
+            else:
+                # Process components in parallel
+                print(f"Using {n_workers} workers for parallel processing")
+
+                process_args = [
+                    (
+                        label,
+                        labeled_mask,
+                        conf_data,
+                        transform,
+                        confidence_threshold,
+                        min_object_area,
+                        max_object_area,
+                    )
+                    for label in range(1, num_features + 1)
+                ]
+
+                with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=n_workers
+                ) as executor:
+                    results = list(
+                        tqdm(
+                            executor.map(process_component, process_args),
+                            total=num_features,
+                            desc="Processing components",
+                        )
+                    )
 
-                    # Add to lists
-                    polygons.append(poly)
-                    confidences.append(confidence)
-                    pixels.append(area)
+                    for result in results:
+                        if result:
+                            for poly, confidence, area in result:
+                                # Add to lists
+                                polygons.append(poly)
+                                confidences.append(confidence)
+                                pixels.append(area)
 
             # Create GeoDataFrame
             if polygons:
@@ -2223,8 +2326,12 @@ class ObjectDetector:
                     gdf.to_file(output_path, driver="GeoJSON")
                     print(f"Saved {len(gdf)} objects with confidence to {output_path}")
 
+                end_time = time.time()
+                print(f"Total processing time: {end_time - start_time:.2f} seconds")
                 return gdf
             else:
+                end_time = time.time()
+                print(f"Total processing time: {end_time - start_time:.2f} seconds")
                 print("No valid polygons found")
                 return None
 

geoai/geoai.py

@@ -1,15 +1,29 @@
 """Main module."""
 
+import leafmap
+
 from .download import (
     download_naip,
     download_overture_buildings,
     download_pc_stac_item,
     pc_collection_list,
+    pc_item_asset_list,
     pc_stac_search,
     pc_stac_download,
+    read_pc_item_asset,
+    view_pc_item,
 )
+from .classify import train_classifier, classify_image, classify_images
 from .extract import *
 from .hf import *
 from .segment import *
 from .train import object_detection, train_MaskRCNN_model
 from .utils import *
+
+
+class Map(leafmap.Map):
+    """A subclass of leafmap.Map for GeoAI applications."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the Map class."""
+        super().__init__(*args, **kwargs)

geoai/utils.py

@@ -6053,3 +6053,165 @@ def try_common_architectures(state_dict):
 
         except Exception as e:
             print(f"- {name}: Failed to load - {str(e)}")
+
+
+def mosaic_geotiffs(input_dir, output_file, mask_file=None):
+    """Create a mosaic from all GeoTIFF files as a Cloud Optimized GeoTIFF (COG).
+
+    This function identifies all GeoTIFF files in the specified directory,
+    creates a seamless mosaic with proper handling of nodata values, and saves
+    as a Cloud Optimized GeoTIFF format. If a mask file is provided, the output
+    will be clipped to the extent of the mask.
+
+    Args:
+        input_dir (str): Path to the directory containing GeoTIFF files.
+        output_file (str): Path to the output Cloud Optimized GeoTIFF file.
+        mask_file (str, optional): Path to a mask file to clip the output.
+            If provided, the output will be clipped to the extent of this mask.
+            Defaults to None.
+
+    Returns:
+        bool: True if the mosaic was created successfully, False otherwise.
+
+    Examples:
+        >>> mosaic_geotiffs('naip', 'merged_naip.tif')
+        True
+        >>> mosaic_geotiffs('naip', 'merged_naip.tif', 'boundary.tif')
+        True
+    """
+    import glob
+    from osgeo import gdal
+
+    gdal.UseExceptions()
+    # Get all tif files in the directory
+    tif_files = glob.glob(os.path.join(input_dir, "*.tif"))
+
+    if not tif_files:
+        print("No GeoTIFF files found in the specified directory.")
+        return False
+
+    # Analyze the first input file to determine compression and nodata settings
+    ds = gdal.Open(tif_files[0])
+    if ds is None:
+        print(f"Unable to open {tif_files[0]}")
+        return False
+
+    # Get driver metadata from the first file
+    driver = ds.GetDriver()
+    creation_options = []
+
+    # Check compression type
+    metadata = ds.GetMetadata("IMAGE_STRUCTURE")
+    if "COMPRESSION" in metadata:
+        compression = metadata["COMPRESSION"]
+        creation_options.append(f"COMPRESS={compression}")
+    else:
+        # Default compression if none detected
+        creation_options.append("COMPRESS=LZW")
+
+    # Add COG-specific creation options
+    creation_options.extend(["TILED=YES", "BLOCKXSIZE=512", "BLOCKYSIZE=512"])
+
+    # Check for nodata value in the first band of the first file
+    band = ds.GetRasterBand(1)
+    has_nodata = band.GetNoDataValue() is not None
+    nodata_value = band.GetNoDataValue() if has_nodata else None
+
+    # Close the dataset
+    ds = None
+
+    # Create a temporary VRT (Virtual Dataset)
+    vrt_path = os.path.join(input_dir, "temp_mosaic.vrt")
+
+    # Build VRT from input files with proper nodata handling
+    vrt_options = gdal.BuildVRTOptions(
+        resampleAlg="nearest",
+        srcNodata=nodata_value if has_nodata else None,
+        VRTNodata=nodata_value if has_nodata else None,
+    )
+    vrt_dataset = gdal.BuildVRT(vrt_path, tif_files, options=vrt_options)
+
+    # Close the VRT dataset to flush it to disk
+    vrt_dataset = None
+
+    # Create temp mosaic
+    temp_mosaic = output_file + ".temp.tif"
+
+    # Convert VRT to GeoTIFF with the same compression as input
+    translate_options = gdal.TranslateOptions(
+        format="GTiff",
+        creationOptions=creation_options,
+        noData=nodata_value if has_nodata else None,
+    )
+    gdal.Translate(temp_mosaic, vrt_path, options=translate_options)
+
+    # Apply mask if provided
+    if mask_file and os.path.exists(mask_file):
+        print(f"Clipping mosaic to mask: {mask_file}")
+
+        # Create a temporary clipped file
+        clipped_mosaic = output_file + ".clipped.tif"
+
+        # Open mask file
+        mask_ds = gdal.Open(mask_file)
+        if mask_ds is None:
+            print(f"Unable to open mask file: {mask_file}")
+            # Continue without clipping
+        else:
+            # Get mask extent
+            mask_geotransform = mask_ds.GetGeoTransform()
+            mask_projection = mask_ds.GetProjection()
+            mask_ulx = mask_geotransform[0]
+            mask_uly = mask_geotransform[3]
+            mask_lrx = mask_ulx + (mask_geotransform[1] * mask_ds.RasterXSize)
+            mask_lry = mask_uly + (mask_geotransform[5] * mask_ds.RasterYSize)
+
+            # Close mask dataset
+            mask_ds = None
+
+            # Use warp options to clip
+            warp_options = gdal.WarpOptions(
+                format="GTiff",
+                outputBounds=[mask_ulx, mask_lry, mask_lrx, mask_uly],
+                dstSRS=mask_projection,
+                creationOptions=creation_options,
+                srcNodata=nodata_value if has_nodata else None,
+                dstNodata=nodata_value if has_nodata else None,
+            )
+
+            # Apply clipping
+            gdal.Warp(clipped_mosaic, temp_mosaic, options=warp_options)
+
+            # Remove the unclipped temp mosaic and use the clipped one
+            os.remove(temp_mosaic)
+            temp_mosaic = clipped_mosaic
+
+    # Create internal overviews for the temp mosaic
+    ds = gdal.Open(temp_mosaic, gdal.GA_Update)
+    overview_list = [2, 4, 8, 16, 32]
+    ds.BuildOverviews("NEAREST", overview_list)
+    ds = None  # Close the dataset to ensure overviews are written
+
+    # Convert the temp mosaic to a proper COG
+    cog_options = gdal.TranslateOptions(
+        format="GTiff",
+        creationOptions=[
+            "TILED=YES",
+            "COPY_SRC_OVERVIEWS=YES",
+            "COMPRESS=DEFLATE",
+            "PREDICTOR=2",
+            "BLOCKXSIZE=512",
+            "BLOCKYSIZE=512",
+        ],
+        noData=nodata_value if has_nodata else None,
+    )
+    gdal.Translate(output_file, temp_mosaic, options=cog_options)
+
+    # Clean up temporary files
+    if os.path.exists(vrt_path):
+        os.remove(vrt_path)
+    if os.path.exists(temp_mosaic):
+        os.remove(temp_mosaic)
+
+    print(f"Cloud Optimized GeoTIFF mosaic created successfully: {output_file}")
+    return True

{geoai_py-0.4.2.dist-info → geoai_py-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.4.2
+Version: 0.5.0
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License

geoai_py-0.5.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+geoai/__init__.py,sha256=jGJl23LMoJDPdWTrlWAPxXK8cjwWllGQcFQ5IJOJ0s0,3765
+geoai/classify.py,sha256=_e-193QzAx3pIxUflPIsIs1qZevQx5ADu7i3bOL1G70,35055
+geoai/download.py,sha256=lJ1GsJOZsKc2i6_dQyPV-XXIXmlADOpmSBo-wha4DEU,40892
+geoai/extract.py,sha256=GocJufMmrwEWxNBL1J91EXXHL8AKcO8m_lmtUF5AKPw,119102
+geoai/geoai.py,sha256=5zXt7WQ0FbiksXKQ9fBNnfa9dhJ3QVd8LXicMxyynTg,698
+geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
+geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
+geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
+geoai/train.py,sha256=-l2j1leTxDnFDLaBslu1q6CobXjm3LEdiQwUWOU8P6M,40088
+geoai/utils.py,sha256=xxhIkNFFtv-s_tzrlAyD4qIOaxo2JtKJEzG6vFgA5y8,238737
+geoai_py-0.5.0.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.5.0.dist-info/METADATA,sha256=tzHz2Q1iTpCO25T8W3N2RtyaHdwdb9umS9YIgCciFdo,6049
+geoai_py-0.5.0.dist-info/WHEEL,sha256=MAQBAzGbXNI3bUmkDsiV_duv8i-gcdnLzw7cfUFwqhU,109
+geoai_py-0.5.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.5.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.5.0.dist-info/RECORD,,

{geoai_py-0.4.2.dist-info → geoai_py-0.5.0.dist-info}/WHEEL

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

geoai_py-0.4.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-geoai/__init__.py,sha256=kHB6b3uOdCoxMpIpfpXtPxg-KJQVsKJveb8zTw5Mxzs,3592
-geoai/download.py,sha256=SE81OrhH2XSH02xtAXQyh5ltBqA8K7ksGT1Lm6SMqx8,37593
-geoai/extract.py,sha256=bR8TkUXncW0rinsBO5oxlVFGsSVoj6xnm5xdDc-J1Xk,115490
-geoai/geoai.py,sha256=qY1HWmJQ0ZgIPtlgWd4gpuCGw6dovdg8D5pAtHqfr8U,334
-geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
-geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
-geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
-geoai/train.py,sha256=-l2j1leTxDnFDLaBslu1q6CobXjm3LEdiQwUWOU8P6M,40088
-geoai/utils.py,sha256=Wg9jbMBKUZSGUmU8Vkp6v19QcDNg5KmcyZxuHqJvgnc,233016
-geoai_py-0.4.2.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.4.2.dist-info/METADATA,sha256=Sc6m-MyCti-_Dnan5wp6GIy88LwuBAF_IYrFF34SRJE,6049
-geoai_py-0.4.2.dist-info/WHEEL,sha256=9bhjOwO--Rs91xaPcBdlYFUmIudhuXqFlPriQeYQITw,109
-geoai_py-0.4.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.4.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.4.2.dist-info/RECORD,,