geoai-py 0.1.5__py2.py3-none-any.whl → 0.1.6__py2.py3-none-any.whl

geoai/__init__.py

@@ -2,4 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "0.1.5"
+__version__ = "0.1.6"
+
+
+from .geoai import *

geoai/common.py

@@ -1,6 +1,279 @@
 """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
 
-def hello_world():
-    """Prints "Hello World!" to the console."""
-    print("Hello World!")
+import torch
+import numpy as np
+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.
+    """
+    import leafmap
+
+    m = leafmap.Map(basemap=basemap)
+
+    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,
+    **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.
+        **kwargs (Any): Additional keyword arguments for plt.imshow().
+
+    Returns:
+        None
+    """
+
+    if isinstance(image, torch.Tensor):
+        image = image.cpu().numpy()
+
+    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")
+    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)

geoai/geoai.py

@@ -1 +1,3 @@
 """Main module."""
+
+from .common import viz_raster, viz_image, plot_batch, calc_stats

{geoai_py-0.1.5.dist-info → geoai_py-0.1.6.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.2
 Name: geoai-py
-Version: 0.1.5
+Version: 0.1.6
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
-Project-URL: Homepage, https://github.com/giswqs/geoai
+Project-URL: Homepage, https://github.com/opengeos/geoai
 Keywords: geoai
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -18,14 +18,14 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: albumentations
+Requires-Dist: jupyter-server-proxy
+Requires-Dist: leafmap
+Requires-Dist: localtileserver
 Requires-Dist: scikit-learn
 Requires-Dist: segment-geospatial
 Requires-Dist: torch
+Requires-Dist: torchgeo
 Requires-Dist: transformers
-Provides-Extra: all
-Requires-Dist: geoai[extra]; extra == "all"
-Provides-Extra: extra
-Requires-Dist: pandas; extra == "extra"
 
 # geoai
 

geoai_py-0.1.6.dist-info/RECORD

@@ -0,0 +1,10 @@
+geoai/__init__.py,sha256=FBqWQ-gHNvzP7beS6Vdp5upQnAVuYHa4CZLTvgpXfqA,143
+geoai/common.py,sha256=6h6mtUBO428P3IZppWyCVo04Ohzc3VhmnH0tvVh479g,9675
+geoai/geoai.py,sha256=TmR7x1uL51G5oAjw0AQWnC5VQtLWDygyFLrDIj46xNc,86
+geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
+geoai_py-0.1.6.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.1.6.dist-info/METADATA,sha256=ByO92YNy910hBcIhcHtm4_6A1fi7WEElrzldHHv-YmU,1599
+geoai_py-0.1.6.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
+geoai_py-0.1.6.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.1.6.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.1.6.dist-info/RECORD,,

geoai_py-0.1.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-geoai/__init__.py,sha256=xkyHrnU3iebQB2V0bl1Xd9s8YKI5-UTS-tMbjgnJXNY,120
-geoai/common.py,sha256=Rw6d9qmZDu3dUGTyJto1Y97S7-QA-m2p-pbCNvMDrm4,184
-geoai/geoai.py,sha256=h0hwdogXGFqerm-5ZPeT-irPn91pCcQRjiHThXsRzEk,19
-geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
-geoai_py-0.1.5.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.1.5.dist-info/METADATA,sha256=oQrREZxyg5_OgaVK4Pkn9txkaqUYcUtvigo13MfFNo0,1609
-geoai_py-0.1.5.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
-geoai_py-0.1.5.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.1.5.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.1.5.dist-info/RECORD,,