geoai-py 0.2.2__py2.py3-none-any.whl → 0.3.0__py2.py3-none-any.whl

{geoai_py-0.2.2.dist-info → geoai_py-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: geoai-py
-Version: 0.2.2
+Version: 0.3.0
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -18,11 +18,13 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: albumentations
+Requires-Dist: contextily
 Requires-Dist: geopandas
 Requires-Dist: huggingface_hub
 Requires-Dist: jupyter-server-proxy
 Requires-Dist: leafmap
 Requires-Dist: localtileserver
+Requires-Dist: mapclassify
 Requires-Dist: overturemaps
 Requires-Dist: planetary-computer
 Requires-Dist: pystac-client

geoai_py-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+geoai/__init__.py,sha256=rJod2PDa1AiRHE8ugVp0Bfiky7ZWBhqbh2kZ45WiggA,923
+geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
+geoai/extract.py,sha256=9oLbrSg_aHcimpYxfk0jLOIHQWVULRsdiAGUsPLC-qk,71708
+geoai/geoai.py,sha256=wNwKIqwOT10tU4uiWTcNp5Gd598rRFMANIfJsGdOWKM,90
+geoai/preprocess.py,sha256=teV-W7ykXnoru0Y_d0V9ANdO6jMyETeGbqr1_8H-Yh0,118523
+geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
+geoai/utils.py,sha256=3vXFDdFqZeg4kgeNt6-Hp28RfNoQcDOH7BjrlJ6L0UE,37521
+geoai_py-0.3.0.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.3.0.dist-info/METADATA,sha256=L62RHKj0Yqno8LDYVrL50YyMfO1ybRYs2NI15WHiJMQ,5754
+geoai_py-0.3.0.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+geoai_py-0.3.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.3.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.3.0.dist-info/RECORD,,

geoai/common.py

@@ -1,438 +0,0 @@
-"""The common module contains common functions and classes used by the other modules."""
-
-import os
-from collections.abc import Iterable
-from typing import Any, Dict, List, Optional, Tuple, Type, Union, Callable
-import matplotlib.pyplot as plt
-
-import leafmap
-import torch
-import numpy as np
-import xarray as xr
-import rioxarray
-import rasterio as rio
-from torch.utils.data import DataLoader
-from torchgeo.datasets import RasterDataset, stack_samples, unbind_samples, utils
-from torchgeo.samplers import RandomGeoSampler, Units
-from torchgeo.transforms import indices
-
-
-def viz_raster(
-    source: str,
-    indexes: Optional[int] = None,
-    colormap: Optional[str] = None,
-    vmin: Optional[float] = None,
-    vmax: Optional[float] = None,
-    nodata: Optional[float] = None,
-    attribution: Optional[str] = None,
-    layer_name: Optional[str] = "Raster",
-    layer_index: Optional[int] = None,
-    zoom_to_layer: Optional[bool] = True,
-    visible: Optional[bool] = True,
-    opacity: Optional[float] = 1.0,
-    array_args: Optional[Dict] = {},
-    client_args: Optional[Dict] = {"cors_all": False},
-    basemap: Optional[str] = "OpenStreetMap",
-    **kwargs,
-):
-    """
-    Visualize a raster using leafmap.
-
-    Args:
-        source (str): The source of the raster.
-        indexes (Optional[int], optional): The band indexes to visualize. Defaults to None.
-        colormap (Optional[str], optional): The colormap to apply. Defaults to None.
-        vmin (Optional[float], optional): The minimum value for colormap scaling. Defaults to None.
-        vmax (Optional[float], optional): The maximum value for colormap scaling. Defaults to None.
-        nodata (Optional[float], optional): The nodata value. Defaults to None.
-        attribution (Optional[str], optional): The attribution for the raster. Defaults to None.
-        layer_name (Optional[str], optional): The name of the layer. Defaults to "Raster".
-        layer_index (Optional[int], optional): The index of the layer. Defaults to None.
-        zoom_to_layer (Optional[bool], optional): Whether to zoom to the layer. Defaults to True.
-        visible (Optional[bool], optional): Whether the layer is visible. Defaults to True.
-        opacity (Optional[float], optional): The opacity of the layer. Defaults to 1.0.
-        array_args (Optional[Dict], optional): Additional arguments for array processing. Defaults to {}.
-        client_args (Optional[Dict], optional): Additional arguments for the client. Defaults to {"cors_all": False}.
-        basemap (Optional[str], optional): The basemap to use. Defaults to "OpenStreetMap".
-        **kwargs (Any): Additional keyword arguments.
-
-    Returns:
-        leafmap.Map: The map object with the raster layer added.
-    """
-
-    m = leafmap.Map(basemap=basemap)
-
-    if isinstance(source, dict):
-        source = dict_to_image(source)
-
-    m.add_raster(
-        source=source,
-        indexes=indexes,
-        colormap=colormap,
-        vmin=vmin,
-        vmax=vmax,
-        nodata=nodata,
-        attribution=attribution,
-        layer_name=layer_name,
-        layer_index=layer_index,
-        zoom_to_layer=zoom_to_layer,
-        visible=visible,
-        opacity=opacity,
-        array_args=array_args,
-        client_args=client_args,
-        **kwargs,
-    )
-    return m
-
-
-def viz_image(
-    image: Union[np.ndarray, torch.Tensor],
-    transpose: bool = False,
-    bdx: Optional[int] = None,
-    scale_factor: float = 1.0,
-    figsize: Tuple[int, int] = (10, 5),
-    axis_off: bool = True,
-    title: Optional[str] = None,
-    **kwargs: Any,
-) -> None:
-    """
-    Visualize an image using matplotlib.
-
-    Args:
-        image (Union[np.ndarray, torch.Tensor]): The image to visualize.
-        transpose (bool, optional): Whether to transpose the image. Defaults to False.
-        bdx (Optional[int], optional): The band index to visualize. Defaults to None.
-        scale_factor (float, optional): The scale factor to apply to the image. Defaults to 1.0.
-        figsize (Tuple[int, int], optional): The size of the figure. Defaults to (10, 5).
-        axis_off (bool, optional): Whether to turn off the axis. Defaults to True.
-        title (Optional[str], optional): The title of the plot. Defaults to None.
-        **kwargs (Any): Additional keyword arguments for plt.imshow().
-
-    Returns:
-        None
-    """
-
-    if isinstance(image, torch.Tensor):
-        image = image.cpu().numpy()
-    elif isinstance(image, str):
-        image = rio.open(image).read().transpose(1, 2, 0)
-
-    plt.figure(figsize=figsize)
-
-    if transpose:
-        image = image.transpose(1, 2, 0)
-
-    if bdx is not None:
-        image = image[:, :, bdx]
-
-    if len(image.shape) > 2 and image.shape[2] > 3:
-        image = image[:, :, 0:3]
-
-    if scale_factor != 1.0:
-        image = np.clip(image * scale_factor, 0, 1)
-
-    plt.imshow(image, **kwargs)
-    if axis_off:
-        plt.axis("off")
-    if title is not None:
-        plt.title(title)
-    plt.show()
-    plt.close()
-
-
-def plot_images(
-    images: Iterable[torch.Tensor],
-    axs: Iterable[plt.Axes],
-    chnls: List[int] = [2, 1, 0],
-    bright: float = 1.0,
-) -> None:
-    """
-    Plot a list of images.
-
-    Args:
-        images (Iterable[torch.Tensor]): The images to plot.
-        axs (Iterable[plt.Axes]): The axes to plot the images on.
-        chnls (List[int], optional): The channels to use for RGB. Defaults to [2, 1, 0].
-        bright (float, optional): The brightness factor. Defaults to 1.0.
-
-    Returns:
-        None
-    """
-    for img, ax in zip(images, axs):
-        arr = torch.clamp(bright * img, min=0, max=1).numpy()
-        rgb = arr.transpose(1, 2, 0)[:, :, chnls]
-        ax.imshow(rgb)
-        ax.axis("off")
-
-
-def plot_masks(
-    masks: Iterable[torch.Tensor], axs: Iterable[plt.Axes], cmap: str = "Blues"
-) -> None:
-    """
-    Plot a list of masks.
-
-    Args:
-        masks (Iterable[torch.Tensor]): The masks to plot.
-        axs (Iterable[plt.Axes]): The axes to plot the masks on.
-        cmap (str, optional): The colormap to use. Defaults to "Blues".
-
-    Returns:
-        None
-    """
-    for mask, ax in zip(masks, axs):
-        ax.imshow(mask.squeeze().numpy(), cmap=cmap)
-        ax.axis("off")
-
-
-def plot_batch(
-    batch: Dict[str, Any],
-    bright: float = 1.0,
-    cols: int = 4,
-    width: int = 5,
-    chnls: List[int] = [2, 1, 0],
-    cmap: str = "Blues",
-) -> None:
-    """
-    Plot a batch of images and masks. This function is adapted from the plot_batch()
-    function in the torchgeo library at
-    https://torchgeo.readthedocs.io/en/stable/tutorials/earth_surface_water.html
-    Credit to the torchgeo developers for the original implementation.
-
-    Args:
-        batch (Dict[str, Any]): The batch containing images and masks.
-        bright (float, optional): The brightness factor. Defaults to 1.0.
-        cols (int, optional): The number of columns in the plot grid. Defaults to 4.
-        width (int, optional): The width of each plot. Defaults to 5.
-        chnls (List[int], optional): The channels to use for RGB. Defaults to [2, 1, 0].
-        cmap (str, optional): The colormap to use for masks. Defaults to "Blues".
-
-    Returns:
-        None
-    """
-    # Get the samples and the number of items in the batch
-    samples = unbind_samples(batch.copy())
-
-    # if batch contains images and masks, the number of images will be doubled
-    n = 2 * len(samples) if ("image" in batch) and ("mask" in batch) else len(samples)
-
-    # calculate the number of rows in the grid
-    rows = n // cols + (1 if n % cols != 0 else 0)
-
-    # create a grid
-    _, axs = plt.subplots(rows, cols, figsize=(cols * width, rows * width))
-
-    if ("image" in batch) and ("mask" in batch):
-        # plot the images on the even axis
-        plot_images(
-            images=map(lambda x: x["image"], samples),
-            axs=axs.reshape(-1)[::2],
-            chnls=chnls,
-            bright=bright,
-        )
-
-        # plot the masks on the odd axis
-        plot_masks(masks=map(lambda x: x["mask"], samples), axs=axs.reshape(-1)[1::2])
-
-    else:
-        if "image" in batch:
-            plot_images(
-                images=map(lambda x: x["image"], samples),
-                axs=axs.reshape(-1),
-                chnls=chnls,
-                bright=bright,
-            )
-
-        elif "mask" in batch:
-            plot_masks(
-                masks=map(lambda x: x["mask"], samples), axs=axs.reshape(-1), cmap=cmap
-            )
-
-
-def calc_stats(
-    dataset: RasterDataset, divide_by: float = 1.0
-) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Calculate the statistics (mean and std) for the entire dataset.
-
-    This function is adapted from the plot_batch() function in the torchgeo library at
-    https://torchgeo.readthedocs.io/en/stable/tutorials/earth_surface_water.html.
-    Credit to the torchgeo developers for the original implementation.
-
-    Warning: This is an approximation. The correct value should take into account the
-    mean for the whole dataset for computing individual stds.
-
-    Args:
-        dataset (RasterDataset): The dataset to calculate statistics for.
-        divide_by (float, optional): The value to divide the image data by. Defaults to 1.0.
-
-    Returns:
-        Tuple[np.ndarray, np.ndarray]: The mean and standard deviation for each band.
-    """
-    import rasterio as rio
-
-    # To avoid loading the entire dataset in memory, we will loop through each img
-    # The filenames will be retrieved from the dataset's rtree index
-    files = [
-        item.object
-        for item in dataset.index.intersection(dataset.index.bounds, objects=True)
-    ]
-
-    # Resetting statistics
-    accum_mean = 0
-    accum_std = 0
-
-    for file in files:
-        img = rio.open(file).read() / divide_by  # type: ignore
-        accum_mean += img.reshape((img.shape[0], -1)).mean(axis=1)
-        accum_std += img.reshape((img.shape[0], -1)).std(axis=1)
-
-    # at the end, we shall have 2 vectors with length n=chnls
-    # we will average them considering the number of images
-    return accum_mean / len(files), accum_std / len(files)
-
-
-def dict_to_rioxarray(data_dict: Dict) -> xr.DataArray:
-    """Convert a dictionary to a xarray DataArray. The dictionary should contain the
-    following keys: "crs", "bounds", and "image". It can be generated from a TorchGeo
-    dataset sampler.
-
-    Args:
-        data_dict (Dict): The dictionary containing the data.
-
-    Returns:
-        xr.DataArray: The xarray DataArray.
-    """
-
-    from affine import Affine
-
-    # Extract components from the dictionary
-    crs = data_dict["crs"]
-    bounds = data_dict["bounds"]
-    image_tensor = data_dict["image"]
-
-    # Convert tensor to numpy array if needed
-    if hasattr(image_tensor, "numpy"):
-        # For PyTorch tensors
-        image_array = image_tensor.numpy()
-    else:
-        # If it's already a numpy array or similar
-        image_array = np.array(image_tensor)
-
-    # Calculate pixel resolution
-    width = image_array.shape[2]  # Width is the size of the last dimension
-    height = image_array.shape[1]  # Height is the size of the middle dimension
-
-    res_x = (bounds.maxx - bounds.minx) / width
-    res_y = (bounds.maxy - bounds.miny) / height
-
-    # Create the transform matrix
-    transform = Affine(res_x, 0.0, bounds.minx, 0.0, -res_y, bounds.maxy)
-
-    # Create dimensions
-    x_coords = np.linspace(bounds.minx + res_x / 2, bounds.maxx - res_x / 2, width)
-    y_coords = np.linspace(bounds.maxy - res_y / 2, bounds.miny + res_y / 2, height)
-
-    # If time dimension exists in the bounds
-    if hasattr(bounds, "mint") and hasattr(bounds, "maxt"):
-        # Create a single time value or range if needed
-        t_coords = [
-            bounds.mint
-        ]  # Or np.linspace(bounds.mint, bounds.maxt, num_time_steps)
-
-        # Create DataArray with time dimension
-        dims = (
-            ("band", "y", "x")
-            if image_array.shape[0] <= 10
-            else ("time", "band", "y", "x")
-        )
-
-        if dims[0] == "band":
-            # For multi-band single time
-            da = xr.DataArray(
-                image_array,
-                dims=dims,
-                coords={
-                    "band": np.arange(1, image_array.shape[0] + 1),
-                    "y": y_coords,
-                    "x": x_coords,
-                },
-            )
-        else:
-            # For multi-time multi-band
-            da = xr.DataArray(
-                image_array,
-                dims=dims,
-                coords={
-                    "time": t_coords,
-                    "band": np.arange(1, image_array.shape[1] + 1),
-                    "y": y_coords,
-                    "x": x_coords,
-                },
-            )
-    else:
-        # Create DataArray without time dimension
-        da = xr.DataArray(
-            image_array,
-            dims=("band", "y", "x"),
-            coords={
-                "band": np.arange(1, image_array.shape[0] + 1),
-                "y": y_coords,
-                "x": x_coords,
-            },
-        )
-
-    # Set spatial attributes
-    da.rio.write_crs(crs, inplace=True)
-    da.rio.write_transform(transform, inplace=True)
-
-    return da
-
-
-def dict_to_image(
-    data_dict: Dict[str, Any], output: Optional[str] = None, **kwargs
-) -> rio.DatasetReader:
-    """Convert a dictionary containing spatial data to a rasterio dataset or save it to
-    a file. The dictionary should contain the following keys: "crs", "bounds", and "image".
-    It can be generated from a TorchGeo dataset sampler.
-
-    This function transforms a dictionary with CRS, bounding box, and image data
-    into a rasterio DatasetReader using leafmap's array_to_image utility after
-    first converting to a rioxarray DataArray.
-
-    Args:
-        data_dict: A dictionary containing:
-            - 'crs': A pyproj CRS object
-            - 'bounds': A BoundingBox object with minx, maxx, miny, maxy attributes
-              and optionally mint, maxt for temporal bounds
-            - 'image': A tensor or array-like object with image data
-        output: Optional path to save the image to a file. If not provided, the image
-            will be returned as a rasterio DatasetReader object.
-        **kwargs: Additional keyword arguments to pass to leafmap.array_to_image.
-            Common options include:
-            - colormap: str, name of the colormap (e.g., 'viridis', 'terrain')
-            - vmin: float, minimum value for colormap scaling
-            - vmax: float, maximum value for colormap scaling
-
-    Returns:
-        A rasterio DatasetReader object that can be used for visualization or
-        further processing.
-
-    Examples:
-        >>> image = dict_to_image(
-        ...     {'crs': CRS.from_epsg(26911), 'bounds': bbox, 'image': tensor},
-        ...     colormap='terrain'
-        ... )
-        >>> fig, ax = plt.subplots(figsize=(10, 10))
-        >>> show(image, ax=ax)
-    """
-    da = dict_to_rioxarray(data_dict)
-
-    if output is not None:
-        out_dir = os.path.abspath(os.path.dirname(output))
-        if not os.path.exists(out_dir):
-            os.makedirs(out_dir, exist_ok=True)
-        da.rio.to_raster(output)
-        return output
-    else:
-        image = leafmap.array_to_image(da, **kwargs)
-        return image

geoai_py-0.2.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-geoai/__init__.py,sha256=yEbFyHPNijxgK-75tatrRELZ9TUdZVYo2uPlxCeBFDA,923
-geoai/common.py,sha256=NdfkQKMPHkwr0B5sDpH5Q_7Nt2AmYt9Gw-KE88NsQ5s,15222
-geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
-geoai/extract.py,sha256=Fh29d5Fj60YiqhMs62lzkd9T_ONTp2UZ4j98We769sg,31563
-geoai/geoai.py,sha256=BCEtHil0P5cettJdMIhblg1pRaV-vHNQFaYmBrtYP3g,68
-geoai/preprocess.py,sha256=pYtf3-eZY76SKd17MvEZ1qNUvblYW5kzQLvZ-ZM4Wwg,106833
-geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
-geoai_py-0.2.2.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.2.2.dist-info/METADATA,sha256=baREpHpvCvfktqiMSWNI-FGOVme8NAj0UkaJhS6Bkm4,5701
-geoai_py-0.2.2.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-geoai_py-0.2.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.2.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.2.2.dist-info/RECORD,,