geoai-py 0.26.0__py2.py3-none-any.whl → 0.28.0__py2.py3-none-any.whl

geoai/train.py

@@ -2131,7 +2131,7 @@ def get_smp_model(
                     "pan",
                     "upernet",
                 ]
-        except:
+        except Exception:
             available_archs = [
                 "unet",
                 "fpn",

geoai/utils.py

@@ -24,7 +24,6 @@ from typing import (
 )
 
 # Third-Party Libraries
-import cv2
 import geopandas as gpd
 import leafmap
 import matplotlib.pyplot as plt
@@ -3095,6 +3094,7 @@ def export_geotiff_tiles(
     apply_augmentation=False,
     augmentation_count=3,
     augmentation_transforms=None,
+    tiling_strategy="grid",
 ):
     """
     Export georeferenced GeoTIFF tiles and labels from raster and classification data.
@@ -3123,6 +3123,10 @@ def export_geotiff_tiles(
             If None and apply_augmentation=True, uses default transforms from
             get_default_augmentation_transforms(). Should be an albumentations.Compose object.
             Defaults to None.
+        tiling_strategy (str, optional): Tiling strategy to use. Options are:
+            - "grid": Regular grid tiling with specified stride (default behavior)
+            - "flipnslide": Flip-n-Slide augmentation strategy with overlapping tiles
+            Defaults to "grid".
 
     Returns:
         None: Tiles and labels are saved to out_folder.
@@ -3145,12 +3149,50 @@ def export_geotiff_tiles(
         ...                      apply_augmentation=True,
         ...                      augmentation_count=5,
         ...                      augmentation_transforms=custom_transform)
+        >>>
+        >>> # Export with Flip-n-Slide tiling strategy
+        >>> export_geotiff_tiles('image.tif', 'output/', 'labels.tif',
+        ...                      tiling_strategy='flipnslide')
     """
 
     import logging
 
     logging.getLogger("rasterio").setLevel(logging.ERROR)
 
+    # Handle FlipnSlide tiling strategy
+    if tiling_strategy == "flipnslide":
+        if apply_augmentation:
+            warnings.warn(
+                "apply_augmentation is ignored when using tiling_strategy='flipnslide'. "
+                "FlipnSlide applies its own augmentation scheme."
+            )
+        if stride != 128:
+            warnings.warn(
+                "stride parameter is ignored when using tiling_strategy='flipnslide'. "
+                "FlipnSlide uses its own stride pattern (tile_size/2)."
+            )
+
+        # Use the dedicated FlipnSlide export function
+        stats = export_flipnslide_tiles(
+            in_raster=in_raster,
+            out_folder=out_folder,
+            in_class_data=in_class_data,
+            tile_size=tile_size,
+            quiet=quiet,
+        )
+
+        if not quiet:
+            print("Used Flip-n-Slide tiling strategy")
+            print(
+                f"Generated {stats['total_tiles']} tiles with spatial context preservation"
+            )
+
+        return
+    elif tiling_strategy != "grid":
+        raise ValueError(
+            f"Unknown tiling_strategy '{tiling_strategy}'. Must be 'grid' or 'flipnslide'."
+        )
+
     # Initialize augmentation transforms if needed
     if apply_augmentation:
         if augmentation_transforms is None:
@@ -6109,6 +6151,8 @@ def masks_to_vector(
     Returns:
         Any: GeoDataFrame with building footprints
     """
+    import cv2  # Lazy import to avoid QGIS opencv conflicts
+
     # Set default output path if not provided
     # if output_path is None:
     #     output_path = os.path.splitext(mask_path)[0] + ".geojson"
@@ -7136,6 +7180,7 @@ def orthogonalize(
     Returns:
         Any: A GeoDataFrame containing the orthogonalized features.
     """
+    import cv2  # Lazy import to avoid QGIS opencv conflicts
 
     from functools import partial
 
@@ -9465,3 +9510,507 @@ def smooth_vector(
     if output_path is not None:
         smoothed_vector_data.to_file(output_path)
     return smoothed_vector_data
+
+
+def flipnslide_augmentation(
+    image,
+    tile_size=256,
+    output_format="numpy",
+    crop_to_multiple=True,
+):
+    """
+    Apply Flip-n-Slide tiling strategy for geospatial imagery data augmentation.
+
+    This function implements the Flip-n-Slide algorithm from "A Concise Tiling
+    Strategy for Preserving Spatial Context in Earth Observation Imagery" by
+    Abrahams et al., presented at the ML4RS workshop at ICLR 2024 (best short
+    paper). The strategy generates overlapping tiles with diverse augmentations
+    while eliminating redundant pixel representations.
+
+    The algorithm produces two sets of tiles:
+
+    1. **Standard overlapping tiles** with half-stride (stride = tile_size / 2)
+       and rotational augmentations determined by grid position:
+
+       - Even row, even col: identity (no augmentation)
+       - Odd row, even col: 180 degree rotation
+       - Even row, odd col: 90 degree rotation
+       - Odd row, odd col: 270 degree rotation
+
+    2. **Inner offset tiles** extracted from the image interior (inset by
+       tile_size / 2 from each edge) with the same half-stride, applying flip
+       and rotation augmentations:
+
+       - Even row, even col: horizontal flip
+       - Even row, odd col: vertical flip
+       - Odd row, odd col: 90 degree rotation + horizontal flip
+       - Odd row, even col: 90 degree rotation + vertical flip
+
+    Args:
+        image (Union[str, numpy.ndarray]): Input image as a numpy array of
+            shape ``(channels, height, width)`` or a file path to a raster
+            readable by rasterio.
+        tile_size (int, optional): Size of each square tile in pixels.
+            Defaults to 256.
+        output_format (str, optional): ``"numpy"`` to return a
+            :class:`numpy.ndarray` or ``"torch"`` to return a
+            :class:`torch.Tensor`. Defaults to ``"numpy"``.
+        crop_to_multiple (bool, optional): If ``True``, crop the image to the
+            nearest dimensions that are multiples of *tile_size* before tiling.
+            Defaults to ``True``.
+
+    Returns:
+        Tuple[Union[numpy.ndarray, torch.Tensor], List[int]]:
+            - **tiles** -- Array of shape
+              ``(num_tiles, channels, tile_size, tile_size)``.
+            - **augmentation_indices** -- List of integers indicating the
+              augmentation applied to each tile:
+
+              - 0: Identity (no augmentation)
+              - 1: 180 degree rotation
+              - 2: 90 degree rotation
+              - 3: 270 degree rotation
+              - 4: Horizontal flip
+              - 5: Vertical flip
+              - 6: 90 degree rotation + horizontal flip
+              - 7: 90 degree rotation + vertical flip
+
+    Example:
+        >>> import numpy as np
+        >>> image = np.random.rand(3, 512, 512)
+        >>> tiles, aug_indices = flipnslide_augmentation(image, tile_size=256)
+        >>> print(f"Generated {tiles.shape[0]} tiles of shape {tiles.shape[1:]}")
+        >>> print(f"Augmentation types used: {sorted(set(aug_indices))}")
+
+    References:
+        Abrahams, E., Snow, T., Siegfried, M. R., & Perez, F. (2024).
+        *A Concise Tiling Strategy for Preserving Spatial Context in Earth
+        Observation Imagery*. ML4RS Workshop @ ICLR 2024.
+        https://doi.org/10.48550/arXiv.2404.10927
+    """
+    # Load image if path provided
+    if isinstance(image, str):
+        import rasterio
+
+        with rasterio.open(image) as src:
+            image = src.read()
+
+    # Ensure numpy array
+    if not isinstance(image, np.ndarray):
+        try:
+            image = image.cpu().numpy()
+        except AttributeError:
+            image = np.asarray(image)
+
+    # Validate input shape
+    if image.ndim != 3:
+        raise ValueError(
+            f"Image must be a 3-D array (channels, height, width), "
+            f"got shape {image.shape}"
+        )
+
+    channels, height, width = image.shape
+
+    # Crop to nearest multiple of tile_size if requested
+    if crop_to_multiple:
+        new_height = (height // tile_size) * tile_size
+        new_width = (width // tile_size) * tile_size
+        if new_height == 0 or new_width == 0:
+            raise ValueError(
+                f"Image size ({height}x{width}) is smaller than "
+                f"tile_size ({tile_size})"
+            )
+        if new_height < height or new_width < width:
+            image = image[:, :new_height, :new_width]
+            height, width = new_height, new_width
+
+    # Check if image is large enough for tiling
+    if height < tile_size or width < tile_size:
+        raise ValueError(
+            f"Image size ({height}x{width}) is smaller than " f"tile_size ({tile_size})"
+        )
+
+    tiles = []
+    augmentation_indices = []
+
+    # Half-stride for overlapping tiles
+    stride = tile_size // 2
+
+    # ------------------------------------------------------------------
+    # Stage 1: Standard overlapping tiles with rotational augmentations
+    # ------------------------------------------------------------------
+    for idx_h, row in enumerate(range(0, height - tile_size + 1, stride)):
+        for idx_w, col in enumerate(range(0, width - tile_size + 1, stride)):
+            tile = image[:, row : row + tile_size, col : col + tile_size]
+
+            if idx_h % 2 == 0 and idx_w % 2 == 0:
+                # Identity
+                aug_tile = tile.copy()
+                aug_idx = 0
+            elif idx_h % 2 == 1 and idx_w % 2 == 0:
+                # 180 degree rotation
+                aug_tile = np.rot90(tile, 2, axes=(1, 2)).copy()
+                aug_idx = 1
+            elif idx_h % 2 == 0 and idx_w % 2 == 1:
+                # 90 degree rotation
+                aug_tile = np.rot90(tile, 1, axes=(1, 2)).copy()
+                aug_idx = 2
+            else:
+                # 270 degree rotation
+                aug_tile = np.rot90(tile, 3, axes=(1, 2)).copy()
+                aug_idx = 3
+
+            tiles.append(aug_tile)
+            augmentation_indices.append(aug_idx)
+
+    # ------------------------------------------------------------------
+    # Stage 2: Inner offset tiles with flip + rotation augmentations
+    # The inner image is inset by tile_size/2 from each edge, matching the
+    # original FlipnSlide implementation.
+    # ------------------------------------------------------------------
+    inset = tile_size // 2
+    if height - 2 * inset >= tile_size and width - 2 * inset >= tile_size:
+        inner_image = image[:, inset : height - inset, inset : width - inset]
+        inner_height = inner_image.shape[1]
+        inner_width = inner_image.shape[2]
+
+        for idx_h, row in enumerate(range(0, inner_height - tile_size + 1, stride)):
+            for idx_w, col in enumerate(range(0, inner_width - tile_size + 1, stride)):
+                tile = inner_image[:, row : row + tile_size, col : col + tile_size]
+
+                if idx_h % 2 == 0 and idx_w % 2 == 0:
+                    # Horizontal flip
+                    aug_tile = tile[:, :, ::-1].copy()
+                    aug_idx = 4
+                elif idx_h % 2 == 0 and idx_w % 2 == 1:
+                    # Vertical flip
+                    aug_tile = tile[:, ::-1, :].copy()
+                    aug_idx = 5
+                elif idx_h % 2 == 1 and idx_w % 2 == 1:
+                    # 90 degree rotation + horizontal flip
+                    aug_tile = np.rot90(tile, 1, axes=(1, 2))
+                    aug_tile = aug_tile[:, :, ::-1].copy()
+                    aug_idx = 6
+                else:
+                    # 90 degree rotation + vertical flip
+                    aug_tile = np.rot90(tile, 1, axes=(1, 2))
+                    aug_tile = aug_tile[:, ::-1, :].copy()
+                    aug_idx = 7
+
+                tiles.append(aug_tile)
+                augmentation_indices.append(aug_idx)
+
+    # Stack into array
+    tiles_array = np.stack(tiles, axis=0)
+
+    # Optionally convert to torch tensor
+    if output_format == "torch":
+        tiles_array = torch.from_numpy(tiles_array)
+    elif output_format != "numpy":
+        raise ValueError(
+            f"output_format must be 'numpy' or 'torch', got '{output_format}'"
+        )
+
+    return tiles_array, augmentation_indices
+
+
+def export_flipnslide_tiles(
+    in_raster,
+    out_folder,
+    in_class_data=None,
+    tile_size=256,
+    output_format="tif",
+    crop_to_multiple=True,
+    quiet=False,
+):
+    """
+    Export georeferenced tiles using the Flip-n-Slide augmentation strategy.
+
+    This function applies the Flip-n-Slide tiling algorithm to an image raster
+    (and optionally a corresponding label/mask raster), preserving spatial
+    relationships and geospatial information. Each tile is saved as an
+    individual GeoTIFF file with proper CRS and geotransform.
+
+    Args:
+        in_raster (str): Path to the input raster image.
+        out_folder (str): Path to the output folder where tiles will be saved.
+        in_class_data (str, optional): Path to a classification/mask file.
+            Can be a raster file (GeoTIFF, etc.) or vector file (GeoJSON,
+            Shapefile, etc.). When provided, matching mask tiles are generated
+            with identical augmentations. Vector files are rasterized to match
+            the input raster dimensions and CRS. Defaults to None.
+        tile_size (int, optional): Size of each square tile in pixels.
+            Defaults to 256.
+        output_format (str, optional): File extension for the output tiles
+            (e.g., ``"tif"``). Defaults to ``"tif"``.
+        crop_to_multiple (bool, optional): If ``True``, crop the image to the
+            nearest dimensions that are multiples of *tile_size* before tiling.
+            Defaults to ``True``.
+        quiet (bool, optional): If ``True``, suppress progress output.
+            Defaults to ``False``.
+
+    Returns:
+        dict: Statistics dictionary with keys:
+
+            - ``'total_tiles'`` -- Number of tiles generated.
+            - ``'tile_size'`` -- Size of each tile.
+            - ``'augmentation_counts'`` -- Count of each augmentation type.
+            - ``'output_folder'`` -- Path to the output folder.
+            - ``'has_labels'`` -- Whether label tiles were generated.
+
+    Example:
+        >>> stats = export_flipnslide_tiles("image.tif", "output_tiles/")
+        >>> print(f"Generated {stats['total_tiles']} tiles")
+
+        >>> stats = export_flipnslide_tiles(
+        ...     "image.tif", "output_tiles/",
+        ...     in_class_data="mask.tif", tile_size=512,
+        ... )
+
+    Notes:
+        Both input raster and class data (if provided) must share the same CRS
+        and spatial extent for proper alignment.
+    """
+    import logging
+    from collections import Counter
+
+    logging.getLogger("rasterio").setLevel(logging.ERROR)
+
+    # Create output directories
+    os.makedirs(out_folder, exist_ok=True)
+    image_dir = os.path.join(out_folder, "images")
+    os.makedirs(image_dir, exist_ok=True)
+
+    has_labels = in_class_data is not None
+    if has_labels:
+        label_dir = os.path.join(out_folder, "labels")
+        os.makedirs(label_dir, exist_ok=True)
+
+    with rasterio.open(in_raster) as src:
+        if not quiet:
+            print(f"Input raster: {in_raster}")
+            print(f"  CRS: {src.crs}")
+            print(f"  Dimensions: {src.width} x {src.height}")
+            print(f"  Bands: {src.count}")
+
+        image_data = src.read()
+
+        # Read class data if provided (handle both raster and vector)
+        class_data = None
+        if has_labels:
+            # Detect if input is raster or vector
+            is_class_data_raster = False
+            file_ext = Path(in_class_data).suffix.lower()
+
+            # Common raster extensions
+            if file_ext in [".tif", ".tiff", ".img", ".jp2", ".png", ".bmp", ".gif"]:
+                try:
+                    with rasterio.open(in_class_data) as test_src:
+                        is_class_data_raster = True
+                except Exception:
+                    is_class_data_raster = False
+            else:
+                # Common vector extensions
+                vector_extensions = [
+                    ".geojson",
+                    ".json",
+                    ".shp",
+                    ".gpkg",
+                    ".fgb",
+                    ".parquet",
+                    ".geoparquet",
+                ]
+                if file_ext in vector_extensions:
+                    is_class_data_raster = False
+                else:
+                    # Unknown extension - try raster first, then vector
+                    try:
+                        with rasterio.open(in_class_data) as test_src:
+                            is_class_data_raster = True
+                    except Exception:
+                        is_class_data_raster = False
+
+            if is_class_data_raster:
+                # Handle raster class data
+                with rasterio.open(in_class_data) as class_src:
+                    if class_src.crs != src.crs:
+                        raise ValueError(
+                            f"CRS mismatch: image ({src.crs}) vs mask ({class_src.crs})"
+                        )
+                    if (class_src.width != src.width) or (
+                        class_src.height != src.height
+                    ):
+                        raise ValueError(
+                            f"Dimension mismatch: image "
+                            f"({src.width}x{src.height}) vs mask "
+                            f"({class_src.width}x{class_src.height})"
+                        )
+                    class_data = class_src.read()
+                    if not quiet:
+                        print(f"  Class data (raster): {in_class_data}")
+            else:
+                # Handle vector class data
+                try:
+                    gdf = gpd.read_file(in_class_data)
+                    if not quiet:
+                        print(f"  Class data (vector): {in_class_data}")
+                        print(f"    Loaded {len(gdf)} features")
+                        print(f"    Vector CRS: {gdf.crs}")
+
+                    # Reproject to match raster CRS if needed
+                    if gdf.crs != src.crs:
+                        if not quiet:
+                            print(f"    Reprojecting from {gdf.crs} to {src.crs}")
+                        gdf = gdf.to_crs(src.crs)
+
+                    # Rasterize vector data to match raster dimensions
+                    if len(gdf) > 0:
+                        # Create binary mask: 1 for features, 0 for background
+                        geometries = [
+                            (geom, 1) for geom in gdf.geometry if geom is not None
+                        ]
+                        if geometries:
+                            rasterized = features.rasterize(
+                                geometries,
+                                out_shape=(src.height, src.width),
+                                transform=src.transform,
+                                fill=0,
+                                all_touched=True,
+                                dtype=np.uint8,
+                            )
+                            # Reshape to match expected format (bands, height, width)
+                            class_data = rasterized.reshape(1, src.height, src.width)
+                        else:
+                            # No valid geometries, create empty mask
+                            class_data = np.zeros(
+                                (1, src.height, src.width), dtype=np.uint8
+                            )
+                    else:
+                        # Empty geodataframe, create empty mask
+                        class_data = np.zeros(
+                            (1, src.height, src.width), dtype=np.uint8
+                        )
+
+                except Exception as e:
+                    raise ValueError(
+                        f"Could not read {in_class_data} as vector file: {e}"
+                    )
+
+        # Apply FlipnSlide augmentation
+        image_tiles, aug_indices = flipnslide_augmentation(
+            image_data, tile_size=tile_size, crop_to_multiple=crop_to_multiple
+        )
+
+        class_tiles = None
+        if has_labels:
+            class_tiles, _ = flipnslide_augmentation(
+                class_data, tile_size=tile_size, crop_to_multiple=crop_to_multiple
+            )
+
+        if not quiet:
+            print(
+                f"\nGenerated {len(image_tiles)} tiles with "
+                f"Flip-n-Slide augmentation"
+            )
+
+        # Determine cropped dimensions for geo-transform calculation
+        _channels, orig_h, orig_w = image_data.shape
+        if crop_to_multiple:
+            height = (orig_h // tile_size) * tile_size
+            width = (orig_w // tile_size) * tile_size
+        else:
+            height, width = orig_h, orig_w
+
+        transform = src.transform
+        stride = tile_size // 2
+        inset = tile_size // 2
+
+        # Build tile positions mirroring flipnslide_augmentation order
+        tile_positions = []
+
+        # Stage 1 - standard overlapping tiles
+        for row in range(0, height - tile_size + 1, stride):
+            for col in range(0, width - tile_size + 1, stride):
+                tile_positions.append((row, col))
+
+        # Stage 2 - inner offset tiles
+        inner_h = height - 2 * inset
+        inner_w = width - 2 * inset
+        if inner_h >= tile_size and inner_w >= tile_size:
+            for row in range(0, inner_h - tile_size + 1, stride):
+                for col in range(0, inner_w - tile_size + 1, stride):
+                    tile_positions.append((inset + row, inset + col))
+
+        # Augmentation label names for filenames
+        aug_names = {
+            0: "identity",
+            1: "rot180",
+            2: "rot90",
+            3: "rot270",
+            4: "hflip",
+            5: "vflip",
+            6: "rot90_hflip",
+            7: "rot90_vflip",
+        }
+
+        # Save tiles
+        for i, (tile_row, tile_col) in enumerate(tile_positions):
+            tile_transform = rasterio.transform.from_bounds(
+                transform.c + tile_col * transform.a,
+                transform.f + (tile_row + tile_size) * transform.e,
+                transform.c + (tile_col + tile_size) * transform.a,
+                transform.f + tile_row * transform.e,
+                tile_size,
+                tile_size,
+            )
+
+            image_profile = src.profile.copy()
+            image_profile.update(
+                {
+                    "height": tile_size,
+                    "width": tile_size,
+                    "count": image_tiles.shape[1],
+                    "transform": tile_transform,
+                }
+            )
+
+            aug_label = aug_names.get(aug_indices[i], str(aug_indices[i]))
+            fname = f"tile_{i:06d}_{aug_label}.{output_format}"
+
+            image_path = os.path.join(image_dir, fname)
+            with rasterio.open(image_path, "w", **image_profile) as dst:
+                dst.write(image_tiles[i])
+
+            if has_labels:
+                class_profile = image_profile.copy()
+                class_profile.update(
+                    {
+                        "count": class_tiles.shape[1],
+                        "dtype": class_tiles.dtype,
+                    }
+                )
+                class_path = os.path.join(label_dir, fname)
+                with rasterio.open(class_path, "w", **class_profile) as dst:
+                    dst.write(class_tiles[i])
+
+    # Statistics
+    aug_counts = Counter(aug_indices)
+    stats = {
+        "total_tiles": len(image_tiles),
+        "tile_size": tile_size,
+        "augmentation_counts": dict(aug_counts),
+        "output_folder": out_folder,
+        "has_labels": has_labels,
+    }
+
+    if not quiet:
+        print("\n--- Flip-n-Slide Export Summary ---")
+        print(f"  Total tiles : {stats['total_tiles']}")
+        print(f"  Tile size   : {tile_size}x{tile_size}")
+        print(f"  Augmentations: {dict(aug_counts)}")
+        if has_labels:
+            print("  Exported both image and label tiles")
+        else:
+            print("  Exported image tiles only")
+
+    return stats

{geoai_py-0.26.0.dist-info → geoai_py-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.26.0
+Version: 0.28.0
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -17,10 +17,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: albumentations
-Requires-Dist: buildingregulariser
 Requires-Dist: contextily
 Requires-Dist: datasets>=3.0
-Requires-Dist: ever-beta
 Requires-Dist: geopandas
 Requires-Dist: huggingface_hub
 Requires-Dist: jupyter-server-proxy
@@ -31,7 +29,6 @@ Requires-Dist: maplibre
 Requires-Dist: opencv-python-headless
 Requires-Dist: overturemaps
 Requires-Dist: planetary-computer
-Requires-Dist: psutil
 Requires-Dist: pyarrow
 Requires-Dist: pystac-client
 Requires-Dist: rasterio
@@ -53,12 +50,17 @@ Requires-Dist: lightly-train; extra == "extra"
 Requires-Dist: multiclean; extra == "extra"
 Requires-Dist: omnicloudmask; extra == "extra"
 Requires-Dist: smoothify; extra == "extra"
+Provides-Extra: building
+Requires-Dist: buildingregulariser; extra == "building"
 Provides-Extra: agents
 Requires-Dist: strands-agents; extra == "agents"
 Requires-Dist: strands-agents-tools; extra == "agents"
 Requires-Dist: strands-agents[ollama]; extra == "agents"
 Requires-Dist: strands-agents[anthropic]; extra == "agents"
 Requires-Dist: strands-agents[openai]; extra == "agents"
+Provides-Extra: onnx
+Requires-Dist: onnx; extra == "onnx"
+Requires-Dist: onnxruntime; extra == "onnx"
 Provides-Extra: sr
 Requires-Dist: opensr-model; extra == "sr"
 Dynamic: license-file
@@ -71,7 +73,7 @@ Dynamic: license-file
 [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/geoai.svg)](https://anaconda.org/conda-forge/geoai)
 [![Conda Recipe](https://img.shields.io/badge/recipe-geoai-green.svg)](https://github.com/conda-forge/geoai-py-feedstock)
 [![image](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![image](https://img.shields.io/badge/YouTube-Tutorials-red)](https://tinyurl.com/GeoAI-Tutorials)
+[![image](https://img.shields.io/badge/YouTube-Tutorials-red)](https://www.youtube.com/playlist?list=PLAxJ4-o7ZoPcvENqwaPa_QwbbkZ5sctZE)
 [![QGIS](https://img.shields.io/badge/QGIS-plugin-orange.svg)](https://opengeoai.org/qgis_plugin)
 
 [![logo](https://raw.githubusercontent.com/opengeos/geoai/master/docs/assets/logo_rect.png)](https://github.com/opengeos/geoai/blob/master/docs/assets/logo.png)
@@ -91,7 +93,7 @@ The package provides five core capabilities:
 5. Interactive visualization through integration with [Leafmap](https://github.com/opengeos/leafmap/) and [MapLibre](https://github.com/eoda-dev/py-maplibregl).
 6. Seamless QGIS integration via a dedicated GeoAI plugin, enabling users to run AI-powered geospatial workflows directly within the QGIS desktop environment, without writing code.
 
-GeoAI addresses the growing demand for accessible AI tools in geospatial research by providing high-level APIs that abstract complex machine learning workflows while maintaining flexibility for advanced users. The package supports multiple data formats (GeoTIFF, JPEG2000,GeoJSON, Shapefile, GeoPackage) and includes automatic device management for GPU acceleration when available. With over 10 modules and extensive notebook examples, GeoAI serves as both a research tool and educational resource for the geospatial AI community.
+GeoAI addresses the growing demand for accessible AI tools in geospatial research by providing high-level APIs that abstract complex machine learning workflows while maintaining flexibility for advanced users. The package supports multiple data formats (GeoTIFF, JPEG2000, GeoJSON, Shapefile, GeoPackage) and includes automatic device management for GPU acceleration when available. With over 10 modules and extensive notebook examples, GeoAI serves as both a research tool and educational resource for the geospatial AI community.
 
 ## 📝 Statement of Need
 
@@ -130,7 +132,7 @@ If you find GeoAI useful in your research, please consider citing the following
 
 -   Integration with [PyTorch Segmentation Models](https://github.com/qubvel-org/segmentation_models.pytorch) for automatic feature extraction
 -   Specialized segmentation algorithms optimized for satellite and aerial imagery
--   Streamlined workflows for segmenting buildings, water bodies, wetlands,solar panels, etc.
+-   Streamlined workflows for segmenting buildings, water bodies, wetlands, solar panels, etc.
 -   Export capabilities to standard geospatial formats (GeoJSON, Shapefile, GeoPackage, GeoParquet)
 
 ### 🔍 Image Classification