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

geoai/download.py

@@ -207,98 +207,130 @@ def json_serializable(obj: Any) -> Any:
         return obj
 
 
+def get_overture_latest_release(patch=True) -> str:
+    """
+    Retrieves the value of the 'latest' key from the Overture Maps release JSON file.
+
+    Args:
+        patch (bool): If True, returns the full version string (e.g., "2025-02-19.0").
+
+    Returns:
+        str: The value of the 'latest' key from the releases.json file.
+
+    Raises:
+        requests.RequestException: If there's an issue with the HTTP request.
+        KeyError: If the 'latest' key is not found in the JSON data.
+        json.JSONDecodeError: If the response cannot be parsed as JSON.
+    """
+    url = "https://labs.overturemaps.org/data/releases.json"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+
+        data = response.json()
+        if patch:
+            latest_release = data.get("latest")
+        else:
+            latest_release = data.get("latest").split(".")[
+                0
+            ]  # Extract the version number
+
+        if latest_release is None:
+            raise KeyError("The 'latest' key was not found in the releases.json file")
+
+        return latest_release
+
+    except requests.RequestException as e:
+        print(f"Error making the request: {e}")
+        raise
+    except json.JSONDecodeError as e:
+        print(f"Error parsing JSON response: {e}")
+        raise
+    except KeyError as e:
+        print(f"Key error: {e}")
+        raise
+
+
+def get_all_overture_types():
+    """Get a list of all available Overture Maps data types.
+
+    Returns:
+        list: List of available Overture Maps data types.
+    """
+    from overturemaps import core
+
+    return core.get_all_overture_types()
+
+
 def download_overture_buildings(
     bbox: Tuple[float, float, float, float],
-    output_file: str,
-    output_format: str = "geojson",
-    data_type: str = "building",
-    verbose: bool = True,
+    output: str,
+    overture_type: str = "building",
+    **kwargs: Any,
 ) -> str:
     """Download building data from Overture Maps for a given bounding box using the overturemaps CLI tool.
 
     Args:
         bbox: Bounding box in the format (min_lon, min_lat, max_lon, max_lat) in WGS84 coordinates.
-        output_file: Path to save the output file.
-        output_format: Format to save the output, one of "geojson", "geojsonseq", or "geoparquet".
-        data_type: The Overture Maps data type to download (building, place, etc.).
-        verbose: Whether to print verbose output.
+        output: Path to save the output file.
+        overture_type: The Overture Maps data type to download (building, place, etc.).
 
     Returns:
         Path to the output file.
     """
-    # Create output directory if needed
-    output_dir = os.path.dirname(output_file)
-    if output_dir and not os.path.exists(output_dir):
-        os.makedirs(output_dir, exist_ok=True)
-
-    # Format the bounding box string for the command
-    west, south, east, north = bbox
-    bbox_str = f"{west},{south},{east},{north}"
-
-    # Build the command
-    cmd = [
-        "overturemaps",
-        "download",
-        "--bbox",
-        bbox_str,
-        "-f",
-        output_format,
-        "--type",
-        data_type,
-        "--output",
-        output_file,
-    ]
-
-    if verbose:
-        logger.info(f"Running command: {' '.join(cmd)}")
-        logger.info("Downloading %s data for area: %s", data_type, bbox_str)
+
+    return get_overture_data(
+        overture_type=overture_type, bbox=bbox, output=output, **kwargs
+    )
+
+
+def get_overture_data(
+    overture_type: str,
+    bbox: Tuple[float, float, float, float] = None,
+    columns: List[str] = None,
+    output: str = None,
+    **kwargs: Any,
+) -> "gpd.GeoDataFrame":
+    """Fetches overture data and returns it as a GeoDataFrame.
+
+    Args:
+        overture_type (str): The type of overture data to fetch.It can be one of the following:
+            address|building|building_part|division|division_area|division_boundary|place|
+            segment|connector|infrastructure|land|land_cover|land_use|water
+        bbox (Tuple[float, float, float, float], optional): The bounding box to
+            filter the data. Defaults to None.
+        columns (List[str], optional): The columns to include in the output.
+            Defaults to None.
+        output (str, optional): The file path to save the output GeoDataFrame.
+            Defaults to None.
+
+    Returns:
+        gpd.GeoDataFrame: The fetched overture data as a GeoDataFrame.
+
+    Raises:
+        ImportError: If the overture package is not installed.
+    """
 
     try:
-        # Run the command
-        result = subprocess.run(
-            cmd,
-            check=True,
-            stdout=subprocess.PIPE if not verbose else None,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
+        from overturemaps import core
+    except ImportError:
+        raise ImportError("The overturemaps package is required to use this function")
 
-        # Check if the file was created
-        if os.path.exists(output_file):
-            file_size = os.path.getsize(output_file) / (1024 * 1024)  # Size in MB
-            logger.info(
-                f"Successfully downloaded data to {output_file} ({file_size:.2f} MB)"
-            )
+    gdf = core.geodataframe(overture_type, bbox=bbox)
+    if columns is not None:
+        gdf = gdf[columns]
 
-            # Optionally show some stats about the downloaded data
-            if output_format == "geojson" and os.path.getsize(output_file) > 0:
-                try:
-                    gdf = gpd.read_file(output_file)
-                    logger.info(f"Downloaded {len(gdf)} features")
-
-                    if len(gdf) > 0 and verbose:
-                        # Show a sample of the attribute names
-                        attrs = list(gdf.columns)
-                        attrs.remove("geometry")
-                        logger.info(f"Available attributes: {', '.join(attrs[:10])}...")
-                except Exception as e:
-                    logger.warning(f"Could not read the GeoJSON file: {str(e)}")
+    gdf.crs = "EPSG:4326"
 
-            return output_file
-        else:
-            logger.error(f"Command completed but file {output_file} was not created")
-            if result.stderr:
-                logger.error(f"Command error output: {result.stderr}")
-            return None
-
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Error running overturemaps command: {str(e)}")
-        if e.stderr:
-            logger.error(f"Command error output: {e.stderr}")
-        raise RuntimeError(f"Failed to download Overture Maps data: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}")
-        raise
+    out_dir = os.path.dirname(os.path.abspath(output))
+    if not os.path.exists(out_dir):
+        os.makedirs(out_dir, exist_ok=True)
+
+    if output is not None:
+        gdf.to_file(output, **kwargs)
+
+    return gdf
 
 
 def convert_vector_format(
@@ -361,18 +393,23 @@ def convert_vector_format(
         raise
 
 
-def extract_building_stats(geojson_file: str) -> Dict[str, Any]:
+def extract_building_stats(data: str) -> Dict[str, Any]:
     """Extract statistics from the building data.
 
     Args:
-        geojson_file: Path to the GeoJSON file.
+        data: Path to the GeoJSON file or GeoDataFrame containing building data.
 
     Returns:
         Dictionary with statistics.
     """
     try:
         # Read the GeoJSON file
-        gdf = gpd.read_file(geojson_file)
+
+        if isinstance(data, gpd.GeoDataFrame):
+            gdf = data
+        else:
+
+            gdf = gpd.read_file(data)
 
         # Calculate statistics
         bbox = gdf.total_bounds.tolist()
@@ -903,7 +940,7 @@ def pc_stac_download(
     from concurrent.futures import ThreadPoolExecutor, as_completed
 
     # Handle single item case
-    if isinstance(items, pystac.Item):
+    if isinstance(items, pystac.Item) or isinstance(items, str):
         items = [items]
     elif not isinstance(items, list):
         raise TypeError("items must be a STAC Item or list of STAC Items")
@@ -973,6 +1010,8 @@ def pc_stac_download(
 
     for item in items:
         item_assets = {}
+        if isinstance(item, str):
+            item = pystac.Item.from_file(item)
         item_id = item.id
         print(f"Processing STAC item: {item_id}")
 

geoai/geoai.py

@@ -13,6 +13,7 @@ from .download import (
     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 *

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.3.dist-info → geoai_py-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.4.3
+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.3.dist-info → geoai_py-0.5.0.dist-info}/WHEEL

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

geoai_py-0.4.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-geoai/__init__.py,sha256=b12E2HztHEPaaKMVKpk6GPjC7ElUMxOW9pYKl4VZkmE,3592
-geoai/download.py,sha256=BvCEpcBwZlEOWieixsdyvQDiE0CXRjU7oayLmy5_Dgs,40110
-geoai/extract.py,sha256=GocJufMmrwEWxNBL1J91EXXHL8AKcO8m_lmtUF5AKPw,119102
-geoai/geoai.py,sha256=BqKdWzNruDdGqwqoyTaJzUq4lKGj-RDBZlSO3t3-GxQ,626
-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.3.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.4.3.dist-info/METADATA,sha256=geDmJ-1zHImsOdcj4gypgq8JqSy8MznnxAnICwh0EbA,6049
-geoai_py-0.4.3.dist-info/WHEEL,sha256=aoLN90hLOL0c0qxXMxWYUM3HA3WmFGZQqEJHX1V_OJE,109
-geoai_py-0.4.3.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.4.3.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.4.3.dist-info/RECORD,,