opencropphenotyping 0.2.0__py3-none-any.whl

opencropphenotyping/batch_processing.py

@@ -0,0 +1,128 @@
+from pathlib import Path
+
+from opencropphenotyping.pipeline import export_results, export_uav_results, process_sentinel2, process_uav_segmentation
+
+
+def process_batch(
+    input_dir: Path,
+    output_dir: Path,
+    processed_dir: Path,
+    indices: list[str] | None = None,
+    ndvi_threshold: float = 0.3,
+    resolution: int = 10,
+) -> None:
+    product_dirs = [
+        path for path in input_dir.iterdir()
+        if path.is_dir()
+    ]
+
+    for product_dir in product_dirs:
+        product_output_dir = output_dir / product_dir.name
+        product_processed_dir = processed_dir / product_dir.name
+
+        print(f"Processing product: {product_dir.name}")
+
+        try:
+            result_product = process_sentinel2(
+                input_dir=product_dir,
+                output_dir=product_processed_dir,
+                indices=indices,
+                ndvi_threshold=ndvi_threshold,
+                resolution=resolution,
+            )
+
+            export_results(
+                result_product,
+                product_output_dir,
+            )
+
+            print(f"Successfully processed: {product_dir.name}")
+
+        except Exception as error:
+            print(
+                f"Error processing product '{product_dir.name}': {error}"
+            )
+
+def process_uav_batch(
+    input_dir: Path,
+    output_dir: Path,
+    threshold: float = 25,
+    vegetation_fraction_threshold: float = 0.04,
+    export_intermediate: bool = False,
+) -> None:
+    """Process multiple UAV image datasets from a parent directory."""
+
+    dataset_dirs = [
+        path for path in input_dir.iterdir()
+        if path.is_dir()
+    ]
+
+    for dataset_dir in dataset_dirs:
+        dataset_output_dir = output_dir / dataset_dir.name
+
+        image_files = [
+            path for path in dataset_dir.iterdir()
+            if path.suffix.lower() in {".jpg", ".jpeg", ".png"}
+            and "georef" not in path.stem.lower()
+        ]
+
+        geotiff_files = [
+            path for path in dataset_dir.iterdir()
+            if path.suffix.lower() in {".tif", ".tiff"}
+        ]
+
+        geopackage_files = [
+            path for path in dataset_dir.iterdir()
+            if path.suffix.lower() == ".gpkg"
+        ]
+
+        if len(image_files) != 1:
+            print(
+                f"Error processing '{dataset_dir.name}': "
+                f"expected 1 RGB image, found {len(image_files)}."
+            )
+            continue
+
+        if len(geotiff_files) != 1:
+            print(
+                f"Error processing '{dataset_dir.name}': "
+                f"expected 1 GeoTIFF, found {len(geotiff_files)}."
+            )
+            continue
+
+        if len(geopackage_files) != 1:
+            print(
+                f"Error processing '{dataset_dir.name}': "
+                f"expected 1 GeoPackage, found {len(geopackage_files)}."
+            )
+            continue
+
+        image_path = image_files[0]
+        geotiff_path = geotiff_files[0]
+        geopackage_path = geopackage_files[0]
+
+        print(f"Processing UAV dataset: {dataset_dir.name}")
+
+        try:
+            result = process_uav_segmentation(
+                image_path=image_path,
+                geotiff_path=geotiff_path,
+                geopackage_path=geopackage_path,
+                threshold=threshold,
+                vegetation_fraction_threshold=vegetation_fraction_threshold,
+                export_intermediate=export_intermediate,
+            )
+
+            export_uav_results(
+                result,
+                dataset_output_dir,
+                export_intermediate=export_intermediate
+            )
+
+            print(f"Successfully processed: {dataset_dir.name}")
+
+        except Exception as error:
+            print(
+                f"Error processing UAV dataset "
+                f"'{dataset_dir.name}': {error}"
+            )

opencropphenotyping/cli.py

@@ -0,0 +1,218 @@
+from pathlib import Path
+
+import typer
+
+from opencropphenotyping.batch_processing import process_batch, process_uav_batch
+from opencropphenotyping.pipeline import export_results, export_uav_results, process_sentinel2, process_uav_segmentation
+
+app = typer.Typer()
+
+
+@app.command()
+def process(
+    input_dir: Path = typer.Option(..., help="Path to the Sentinel-2 product."),
+    output_dir: Path = typer.Option(..., help="Directory where results will be saved."),
+    processed_dir: Path = typer.Option(..., help="Directory for processed files."),
+    indices: list[str] = typer.Option(
+        ["ndvi"],
+        help="Vegetation indices to compute.",
+    ),
+    ndvi_threshold: float = typer.Option(
+        0.3,
+        help="NDVI threshold used for vegetation masking.",
+    ),
+    resolution: int = typer.Option(
+        10,
+        help="Target spatial resolution in meters.",
+    ),
+):
+    """Process a single Sentinel-2 product."""
+
+    try:
+        result = process_sentinel2(
+            input_dir=input_dir,
+            output_dir=processed_dir,
+            indices=indices,
+            ndvi_threshold=ndvi_threshold,
+            resolution=resolution,
+        )
+
+        export_results(
+            result,
+            output_dir,
+        )
+    except Exception as e:
+        typer.echo(f"Error during processing: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo("Processing completed successfully.")
+
+@app.command()
+def batch(
+    input_dir: Path = typer.Option(..., help="Path to the directory containing Sentinel-2 products."),
+    output_dir: Path = typer.Option(..., help="Directory where results will be saved."),
+    processed_dir: Path = typer.Option(..., help="Directory for processed files."),
+    indices: list[str] = typer.Option(
+        ["ndvi"],
+        help="Vegetation indices to compute.",
+    ),
+    ndvi_threshold: float = typer.Option(
+        0.3,
+        help="NDVI threshold used for vegetation masking.",
+    ),
+    resolution: int = typer.Option(
+        10,
+        help="Target spatial resolution in meters.",
+    ),
+):
+    """Process multiple Sentinel-2 products from a directory."""
+    
+    try:
+        process_batch(
+            input_dir=input_dir,
+            output_dir=output_dir,
+            processed_dir=processed_dir,
+            indices=indices,
+            ndvi_threshold=ndvi_threshold,
+            resolution=resolution,
+        )
+    except Exception as e:
+        typer.echo(f"Error during processing: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo("Batch processing completed successfully.")
+
+if __name__ == "__main__":
+    app()
+
+@app.command()
+def segment_uav(
+    image: Path = typer.Option(
+        ...,
+        help="Path to the UAV RGB image.",
+    ),
+    geotiff: Path = typer.Option(
+        ...,
+        help="Path to the georeferenced GeoTIFF.",
+    ),
+    geopackage: Path = typer.Option(
+        ...,
+        help="Path to the experimental plot GeoPackage.",
+    ),
+    output_dir: Path = typer.Option(
+        ...,
+        help="Directory where UAV segmentation results will be saved.",
+    ),
+    best_angle: float | None = typer.Option(
+        None,
+        help="Crop-row orientation angle. If omitted, it is estimated automatically.",
+    ),
+    threshold: float = typer.Option(
+        25.0,
+        help="ExG threshold used for vegetation segmentation.",
+    ),
+    vegetation_fraction_threshold: float = typer.Option(
+        0.04,
+        help="Vegetation fraction threshold used to classify planting positions.",
+    ),
+    export_intermediate: bool = typer.Option(
+        False,
+        help="If True, all intermediate results will be exported.",
+    )
+):
+    """Process a UAV RGB image and detect crop plants."""
+
+    try:
+        result = process_uav_segmentation(
+            image_path=image,
+            geotiff_path=geotiff,
+            geopackage_path=geopackage,
+            best_angle=best_angle,
+            threshold=threshold,
+            vegetation_fraction_threshold=vegetation_fraction_threshold,
+            export_intermediate=export_intermediate,
+        )
+
+        export_uav_results(
+            result,
+            output_dir,
+            export_intermediate=export_intermediate
+        )
+
+    except Exception as e:
+        typer.echo(
+            f"Error during UAV segmentation: {e}",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(
+        "UAV segmentation completed successfully."
+    )
+
+    if(export_intermediate):
+        typer.echo(
+            f"Best angle: {result.best_angle:.1f}°"
+        )
+
+    typer.echo(
+        f"Detected rows: {len(result.row_positions)}"
+    )
+
+    typer.echo(
+        f"Planting positions: {len(result.plants)}"
+    )
+
+    typer.echo(
+        "Occupied positions: "
+        f"{(~result.plants['missing_candidate']).sum()}"
+    )
+
+    typer.echo(
+        "Potentially missing positions: "
+        f"{result.plants['missing_candidate'].sum()}"
+    )
+
+@app.command()
+def batch_uav(
+    input_dir: Path = typer.Option(
+        ...,
+        help="Parent directory containing UAV datasets.",
+    ),
+    output_dir: Path = typer.Option(
+        ...,
+        help="Directory where UAV results will be saved.",
+    ),
+    threshold: float = typer.Option(
+        25,
+        help="ExG threshold used for vegetation segmentation.",
+    ),
+    vegetation_fraction_threshold: float = typer.Option(
+        0.04,
+        help="Threshold used to classify missing plants.",
+    ),
+    export_intermediate: bool = typer.Option(
+        False,
+        help="If True, all intermediate results will be exported.",
+    ),
+):
+    """Process multiple UAV datasets from a parent directory."""
+    try:
+        process_uav_batch(
+            input_dir=input_dir,
+            output_dir=output_dir,
+            threshold=threshold,
+            vegetation_fraction_threshold=vegetation_fraction_threshold,
+            export_intermediate=export_intermediate,
+        )
+    except Exception as error:
+        typer.echo(
+            f"Error during UAV batch processing: {error}",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo("UAV batch processing completed successfully.")
+
+if __name__ == "__main__":
+    app()

opencropphenotyping/coco.py

@@ -0,0 +1,175 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+def load_coco_annotations(
+    json_paths: list[Path],
+) -> dict[str, dict]:
+    """
+    Load COCO annotation files from JSON files.
+
+    Parameters
+    ----------
+    json_paths : list[Path]
+        Paths to COCO annotation JSON files.
+
+    Returns
+    -------
+    dict[str, dict]
+        Dictionary mapping each JSON filename to its decoded
+        annotation data.
+    """
+    annotations = {}
+
+    for path in json_paths:
+        with open(path, encoding="utf-8") as f:
+            annotations[path.name] = json.load(f)
+
+    return annotations
+
+def build_image_annotation_index(
+    coco_datasets: dict[str, dict],
+) -> dict[str, dict]:
+    """
+    Build an index linking each image to its COCO annotations.
+
+    Parameters
+    ----------
+    coco_datasets : dict[str, dict]
+        COCO datasets loaded from JSON files.
+
+    Returns
+    -------
+    dict[str, dict]
+        Dictionary indexed by image filename. Each entry contains
+        the image metadata under ``"image"`` and the corresponding
+        annotations under ``"annotations"``.
+    """
+    image_annotations = {}
+
+    for data in coco_datasets.values():
+
+        for image in data["images"]:
+
+            image_annotations[image["file_name"]] = {
+                "image": image,
+                "annotations": [
+                    annotation
+                    for annotation in data["annotations"]
+                    if annotation["image_id"] == image["id"]
+                ],
+            }
+
+    return image_annotations
+
+def build_plant_annotations_dataframe(
+    image_annotations: dict[str, dict],
+) -> pd.DataFrame:
+    """
+    Convert indexed COCO plant annotations into a DataFrame.
+
+    Parameters
+    ----------
+    image_annotations : dict[str, dict]
+        Image annotation index produced by
+        :func:`build_image_annotation_index`.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing one row per annotated plant.
+        Bounding-box coordinates and plant centre coordinates are
+        expressed in the original image coordinate system.
+    """
+    plant_annotations = []
+
+    columns = [
+        "image_id",
+        "image_name",
+        "category_id",
+        "bbox_x",
+        "bbox_y",
+        "bbox_width",
+        "bbox_height",
+        "center_x",
+        "center_y",
+    ]
+
+    for image_name, info in image_annotations.items():
+
+        image_id = info["image"]["id"]
+
+        for annotation in info["annotations"]:
+
+            x, y, width, height = annotation["bbox"]
+
+            plant_annotations.append(
+                {
+                    "image_id": image_id,
+                    "image_name": image_name,
+                    "category_id": annotation["category_id"],
+                    "bbox_x": x,
+                    "bbox_y": y,
+                    "bbox_width": width,
+                    "bbox_height": height,
+                    "center_x": x + width / 2,
+                    "center_y": y + height / 2,
+                }
+            )
+
+    return pd.DataFrame(plant_annotations, columns=columns)
+
+def get_image_annotations(
+    plant_annotations: pd.DataFrame,
+    image_path: Path,
+) -> pd.DataFrame:
+    """
+    Return plant annotations associated with a given image.
+
+    Parameters
+    ----------
+    plant_annotations : pd.DataFrame
+        DataFrame containing plant annotations for all images.
+        Must contain an ``image_name`` column.
+    image_path : Path
+        Path to the image for which annotations are requested.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing only the annotations associated with
+        ``image_path``.
+    """
+    return plant_annotations[
+        plant_annotations["image_name"] == image_path.name
+    ].copy()
+
+def get_annotation_centers(
+    plant_annotations: pd.DataFrame,
+) -> np.ndarray:
+    """
+    Extract annotated plant centres as an array of x/y coordinates.
+
+    Parameters
+    ----------
+    plant_annotations : pd.DataFrame
+        Plant annotations containing ``center_x`` and ``center_y``.
+
+    Returns
+    -------
+    np.ndarray
+        Array of plant centres with shape ``(n_annotations, 2)``.
+        Columns correspond to x and y coordinates.
+    """
+    if len(plant_annotations) == 0:
+        return np.empty(
+            (0, 2),
+            dtype=float,
+        )
+
+    return plant_annotations[
+        ["center_x", "center_y"]
+    ].to_numpy(dtype=float)