geoai-py 0.5.5__py2.py3-none-any.whl → 0.6.0__py2.py3-none-any.whl

geoai/utils.py

@@ -2112,7 +2112,7 @@ def raster_to_vector(
         return gdf
 
 
-def batch_raster_to_vector(
+def raster_to_vector_batch(
     input_dir,
     output_dir,
     pattern="*.tif",
@@ -6080,6 +6080,7 @@ def mosaic_geotiffs(input_dir, output_file, mask_file=None):
         True
     """
     import glob
+
     from osgeo import gdal
 
     gdal.UseExceptions()
@@ -6345,3 +6346,331 @@ def regularize(
         gdf.to_file(output_path, **kwargs)
 
     return gdf
+
+
+def vector_to_geojson(filename, output=None, **kwargs):
+    """Converts a vector file to a geojson file.
+
+    Args:
+        filename (str): The vector file path.
+        output (str, optional): The output geojson file path. Defaults to None.
+
+    Returns:
+        dict: The geojson dictionary.
+    """
+
+    if filename.startswith("http"):
+        filename = download_file(filename)
+
+    gdf = gpd.read_file(filename, **kwargs)
+    if output is None:
+        return gdf.__geo_interface__
+    else:
+        gdf.to_file(output, driver="GeoJSON")
+
+
+def geojson_to_coords(
+    geojson: str, src_crs: str = "epsg:4326", dst_crs: str = "epsg:4326"
+) -> list:
+    """Converts a geojson file or a dictionary of feature collection to a list of centroid coordinates.
+
+    Args:
+        geojson (str | dict): The geojson file path or a dictionary of feature collection.
+        src_crs (str, optional): The source CRS. Defaults to "epsg:4326".
+        dst_crs (str, optional): The destination CRS. Defaults to "epsg:4326".
+
+    Returns:
+        list: A list of centroid coordinates in the format of [[x1, y1], [x2, y2], ...]
+    """
+
+    import json
+    import warnings
+
+    warnings.filterwarnings("ignore")
+
+    if isinstance(geojson, dict):
+        geojson = json.dumps(geojson)
+    gdf = gpd.read_file(geojson, driver="GeoJSON")
+    centroids = gdf.geometry.centroid
+    centroid_list = [[point.x, point.y] for point in centroids]
+    if src_crs != dst_crs:
+        centroid_list = transform_coords(
+            [x[0] for x in centroid_list],
+            [x[1] for x in centroid_list],
+            src_crs,
+            dst_crs,
+        )
+        centroid_list = [[x, y] for x, y in zip(centroid_list[0], centroid_list[1])]
+    return centroid_list
+
+
+def coords_to_xy(
+    src_fp: str,
+    coords: np.ndarray,
+    coord_crs: str = "epsg:4326",
+    return_out_of_bounds=False,
+    **kwargs,
+) -> np.ndarray:
+    """Converts a list or array of coordinates to pixel coordinates, i.e., (col, row) coordinates.
+
+    Args:
+        src_fp: The source raster file path.
+        coords: A 2D or 3D array of coordinates. Can be of shape [[x1, y1], [x2, y2], ...]
+                or [[[x1, y1]], [[x2, y2]], ...].
+        coord_crs: The coordinate CRS of the input coordinates. Defaults to "epsg:4326".
+        return_out_of_bounds: Whether to return out-of-bounds coordinates. Defaults to False.
+        **kwargs: Additional keyword arguments to pass to rasterio.transform.rowcol.
+
+    Returns:
+        A 2D or 3D array of pixel coordinates in the same format as the input.
+    """
+    from rasterio.warp import transform as transform_coords
+
+    out_of_bounds = []
+    if isinstance(coords, np.ndarray):
+        input_is_3d = coords.ndim == 3  # Check if the input is a 3D array
+    else:
+        input_is_3d = False
+
+    # Flatten the 3D array to 2D if necessary
+    if input_is_3d:
+        original_shape = coords.shape  # Store the original shape
+        coords = coords.reshape(-1, 2)  # Flatten to 2D
+
+    # Convert ndarray to a list if necessary
+    if isinstance(coords, np.ndarray):
+        coords = coords.tolist()
+
+    xs, ys = zip(*coords)
+    with rasterio.open(src_fp) as src:
+        width = src.width
+        height = src.height
+        if coord_crs != src.crs:
+            xs, ys = transform_coords(coord_crs, src.crs, xs, ys, **kwargs)
+        rows, cols = rasterio.transform.rowcol(src.transform, xs, ys, **kwargs)
+
+    result = [[col, row] for col, row in zip(cols, rows)]
+
+    output = []
+
+    for i, (x, y) in enumerate(result):
+        if x >= 0 and y >= 0 and x < width and y < height:
+            output.append([x, y])
+        else:
+            out_of_bounds.append(i)
+
+    # Convert the output back to the original shape if input was 3D
+    output = np.array(output)
+    if input_is_3d:
+        output = output.reshape(original_shape)
+
+    # Handle cases where no valid pixel coordinates are found
+    if len(output) == 0:
+        print("No valid pixel coordinates found.")
+    elif len(output) < len(coords):
+        print("Some coordinates are out of the image boundary.")
+
+    if return_out_of_bounds:
+        return output, out_of_bounds
+    else:
+        return output
+
+
+def boxes_to_vector(coords, src_crs, dst_crs="EPSG:4326", output=None, **kwargs):
+    """
+    Convert a list of bounding box coordinates to vector data.
+
+    Args:
+        coords (list): A list of bounding box coordinates in the format [[left, top, right, bottom], [left, top, right, bottom], ...].
+        src_crs (int or str): The EPSG code or proj4 string representing the source coordinate reference system (CRS) of the input coordinates.
+        dst_crs (int or str, optional): The EPSG code or proj4 string representing the destination CRS to reproject the data (default is "EPSG:4326").
+        output (str or None, optional): The full file path (including the directory and filename without the extension) where the vector data should be saved.
+                                       If None (default), the function returns the GeoDataFrame without saving it to a file.
+        **kwargs: Additional keyword arguments to pass to geopandas.GeoDataFrame.to_file() when saving the vector data.
+
+    Returns:
+        geopandas.GeoDataFrame or None: The GeoDataFrame with the converted vector data if output is None, otherwise None if the data is saved to a file.
+    """
+
+    from shapely.geometry import box
+
+    # Create a list of Shapely Polygon objects based on the provided coordinates
+    polygons = [box(*coord) for coord in coords]
+
+    # Create a GeoDataFrame with the Shapely Polygon objects
+    gdf = gpd.GeoDataFrame({"geometry": polygons}, crs=src_crs)
+
+    # Reproject the GeoDataFrame to the specified EPSG code
+    gdf_reprojected = gdf.to_crs(dst_crs)
+
+    if output is not None:
+        gdf_reprojected.to_file(output, **kwargs)
+    else:
+        return gdf_reprojected
+
+
+def rowcol_to_xy(
+    src_fp,
+    rows=None,
+    cols=None,
+    boxes=None,
+    zs=None,
+    offset="center",
+    output=None,
+    dst_crs="EPSG:4326",
+    **kwargs,
+):
+    """Converts a list of (row, col) coordinates to (x, y) coordinates.
+
+    Args:
+        src_fp (str): The source raster file path.
+        rows (list, optional): A list of row coordinates. Defaults to None.
+        cols (list, optional): A list of col coordinates. Defaults to None.
+        boxes (list, optional): A list of (row, col) coordinates in the format of [[left, top, right, bottom], [left, top, right, bottom], ...]
+        zs: zs (list or float, optional): Height associated with coordinates. Primarily used for RPC based coordinate transformations.
+        offset (str, optional): Determines if the returned coordinates are for the center of the pixel or for a corner.
+        output (str, optional): The output vector file path. Defaults to None.
+        dst_crs (str, optional): The destination CRS. Defaults to "EPSG:4326".
+        **kwargs: Additional keyword arguments to pass to rasterio.transform.xy.
+
+    Returns:
+        A list of (x, y) coordinates.
+    """
+
+    if boxes is not None:
+        rows = []
+        cols = []
+
+        for box in boxes:
+            rows.append(box[1])
+            rows.append(box[3])
+            cols.append(box[0])
+            cols.append(box[2])
+
+    if rows is None or cols is None:
+        raise ValueError("rows and cols must be provided.")
+
+    with rasterio.open(src_fp) as src:
+        xs, ys = rasterio.transform.xy(src.transform, rows, cols, zs, offset, **kwargs)
+        src_crs = src.crs
+
+    if boxes is None:
+        return [[x, y] for x, y in zip(xs, ys)]
+    else:
+        result = [[xs[i], ys[i + 1], xs[i + 1], ys[i]] for i in range(0, len(xs), 2)]
+
+        if output is not None:
+            boxes_to_vector(result, src_crs, dst_crs, output)
+        else:
+            return result
+
+
+def bbox_to_xy(
+    src_fp: str, coords: list, coord_crs: str = "epsg:4326", **kwargs
+) -> list:
+    """Converts a list of coordinates to pixel coordinates, i.e., (col, row) coordinates.
+        Note that map bbox coords is [minx, miny, maxx, maxy] from bottomleft to topright
+        While rasterio bbox coords is [minx, max, maxx, min] from topleft to bottomright
+
+    Args:
+        src_fp (str): The source raster file path.
+        coords (list): A list of coordinates in the format of [[minx, miny, maxx, maxy], [minx, miny, maxx, maxy], ...]
+        coord_crs (str, optional): The coordinate CRS of the input coordinates. Defaults to "epsg:4326".
+
+    Returns:
+        list: A list of pixel coordinates in the format of [[minx, maxy, maxx, miny], ...] from top left to bottom right.
+    """
+
+    if isinstance(coords, str):
+        gdf = gpd.read_file(coords)
+        coords = gdf.geometry.bounds.values.tolist()
+        if gdf.crs is not None:
+            coord_crs = f"epsg:{gdf.crs.to_epsg()}"
+    elif isinstance(coords, np.ndarray):
+        coords = coords.tolist()
+    if isinstance(coords, dict):
+        import json
+
+        geojson = json.dumps(coords)
+        gdf = gpd.read_file(geojson, driver="GeoJSON")
+        coords = gdf.geometry.bounds.values.tolist()
+
+    elif not isinstance(coords, list):
+        raise ValueError("coords must be a list of coordinates.")
+
+    if not isinstance(coords[0], list):
+        coords = [coords]
+
+    new_coords = []
+
+    with rasterio.open(src_fp) as src:
+        width = src.width
+        height = src.height
+
+        for coord in coords:
+            minx, miny, maxx, maxy = coord
+
+            if coord_crs != src.crs:
+                minx, miny = transform_coords(minx, miny, coord_crs, src.crs, **kwargs)
+                maxx, maxy = transform_coords(maxx, maxy, coord_crs, src.crs, **kwargs)
+
+                rows1, cols1 = rasterio.transform.rowcol(
+                    src.transform, minx, miny, **kwargs
+                )
+                rows2, cols2 = rasterio.transform.rowcol(
+                    src.transform, maxx, maxy, **kwargs
+                )
+
+                new_coords.append([cols1, rows1, cols2, rows2])
+
+            else:
+                new_coords.append([minx, miny, maxx, maxy])
+
+    result = []
+
+    for coord in new_coords:
+        minx, miny, maxx, maxy = coord
+
+        if (
+            minx >= 0
+            and miny >= 0
+            and maxx >= 0
+            and maxy >= 0
+            and minx < width
+            and miny < height
+            and maxx < width
+            and maxy < height
+        ):
+            # Note that map bbox coords is [minx, miny, maxx, maxy] from bottomleft to topright
+            # While rasterio bbox coords is [minx, max, maxx, min] from topleft to bottomright
+            result.append([minx, maxy, maxx, miny])
+
+    if len(result) == 0:
+        print("No valid pixel coordinates found.")
+        return None
+    elif len(result) == 1:
+        return result[0]
+    elif len(result) < len(coords):
+        print("Some coordinates are out of the image boundary.")
+
+    return result
+
+
+def geojson_to_xy(
+    src_fp: str, geojson: str, coord_crs: str = "epsg:4326", **kwargs
+) -> list:
+    """Converts a geojson file or a dictionary of feature collection to a list of pixel coordinates.
+
+    Args:
+        src_fp: The source raster file path.
+        geojson: The geojson file path or a dictionary of feature collection.
+        coord_crs: The coordinate CRS of the input coordinates. Defaults to "epsg:4326".
+        **kwargs: Additional keyword arguments to pass to rasterio.transform.rowcol.
+
+    Returns:
+        A list of pixel coordinates in the format of [[x1, y1], [x2, y2], ...]
+    """
+    with rasterio.open(src_fp) as src:
+        src_crs = src.crs
+    coords = geojson_to_coords(geojson, coord_crs, src_crs)
+    return coords_to_xy(src_fp, coords, src_crs, **kwargs)

{geoai_py-0.5.5.dist-info → geoai_py-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.5.5
+Version: 0.6.0
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -26,6 +26,7 @@ Requires-Dist: leafmap
 Requires-Dist: localtileserver
 Requires-Dist: mapclassify
 Requires-Dist: maplibre
+Requires-Dist: opencv-python-headless
 Requires-Dist: overturemaps
 Requires-Dist: planetary-computer
 Requires-Dist: pystac-client

geoai_py-0.6.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+geoai/__init__.py,sha256=rmYcVF2DPBAO_lOf6gIVqvT6U0BcdzDbAF9sLqkXuyE,3765
+geoai/classify.py,sha256=O8fah3DOBDMZW7V_qfDYsUnjB-9Wo5fjA-0e4wvUeAE,35054
+geoai/download.py,sha256=EQpcrcqMsYhDpd7bpjf4hGS5xL2oO-jsjngLgjjP3cE,46599
+geoai/extract.py,sha256=vyHH1k5zaXiy1SLdCLXxbWiNLp8XKdu_MXZoREMtAOQ,119102
+geoai/geoai.py,sha256=WljRN1KlFJ3rlBeSwXs7OXa14xYFR66Yp-rqsTzskv8,9340
+geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
+geoai/sam.py,sha256=O6S-kGiFn7YEcFbfWFItZZQOhnsm6-GlunxQLY0daEs,34345
+geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
+geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
+geoai/train.py,sha256=mQXat2yuddT-2rME4xnX_m3SkY23E_-zdxLnBIKxw8o,44091
+geoai/utils.py,sha256=3l4ft_qTJm90q9oQUkFKz1f87_xKkuun237m6_DDVAY,256085
+geoai_py-0.6.0.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.6.0.dist-info/METADATA,sha256=trRCYv82UZHfAZDMZyMY8-38Db6Cb1ys7H6SeVrwECc,6661
+geoai_py-0.6.0.dist-info/WHEEL,sha256=oSJJyWjO7Z2XSScFQUpXG1HL-N0sFMqqeKVVbZTPkWc,109
+geoai_py-0.6.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.6.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.6.0.dist-info/RECORD,,

{geoai_py-0.5.5.dist-info → geoai_py-0.6.0.dist-info}/WHEEL

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

geoai_py-0.5.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-geoai/__init__.py,sha256=IOmIEHpwSXTIcrja0XC9W8ltKl6LfHEFUHSaFedMhAI,3765
-geoai/classify.py,sha256=_e-193QzAx3pIxUflPIsIs1qZevQx5ADu7i3bOL1G70,35055
-geoai/download.py,sha256=PjGiPP8Q37_3XU1R4aWxu8iDIHVOBpHoJGGdrPDWchw,40892
-geoai/extract.py,sha256=GocJufMmrwEWxNBL1J91EXXHL8AKcO8m_lmtUF5AKPw,119102
-geoai/geoai.py,sha256=qstOl2BKlvaVndrldUN3v-t--v0qMEFkKKvmH0FhGuc,9321
-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=mQXat2yuddT-2rME4xnX_m3SkY23E_-zdxLnBIKxw8o,44091
-geoai/utils.py,sha256=dzoOOI30JK8Moj-ygKLtx-dOW2_b7MIKRXQ__gzfg9o,244383
-geoai_py-0.5.5.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.5.5.dist-info/METADATA,sha256=vVU3bp2QtxizALztaVnOZtECUtCzlegOojAgR4zigtQ,6623
-geoai_py-0.5.5.dist-info/WHEEL,sha256=MAQBAzGbXNI3bUmkDsiV_duv8i-gcdnLzw7cfUFwqhU,109
-geoai_py-0.5.5.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.5.5.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.5.5.dist-info/RECORD,,