opencropphenotyping 0.2.0__py3-none-any.whl

opencropphenotyping/evaluation.py

@@ -0,0 +1,352 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+from opencropphenotyping.coco import (
+    build_image_annotation_index,
+    build_plant_annotations_dataframe,
+    get_annotation_centers,
+    get_image_annotations,
+    load_coco_annotations,
+)
+
+
+def transform_original_points_to_rotated(
+    points: np.ndarray,
+    angle: float,
+    original_shape: tuple[int, int],
+    rotated_shape: tuple[int, int],
+) -> np.ndarray:
+    """
+    Transform points from the original image coordinates to the
+    rotated image coordinates.
+
+    The transformation accounts for the different image centers
+    before and after rotation. Coordinates are expected in
+    ``(x, y)`` order, while image shapes are given in
+    ``(height, width)`` order.
+
+    Parameters
+    ----------
+    points : np.ndarray
+        Array of point coordinates with shape ``(n_points, 2)``.
+        Each point is represented as ``(x, y)``.
+    angle : float
+        Rotation angle in degrees. The rotation convention follows
+        the coordinate transformation used for the image rotation.
+    original_shape : tuple[int, int]
+        Shape of the original image represented as
+        ``(height, width)``.
+    rotated_shape : tuple[int, int]
+        Shape of the rotated image represented as
+        ``(height, width)``.
+
+    Returns
+    -------
+    np.ndarray
+        Transformed point coordinates with shape ``(n_points, 2)``.
+        Coordinates are represented as ``(x, y)``.
+    """
+    original_height, original_width = original_shape
+    rotated_height, rotated_width = rotated_shape
+
+    original_center = np.array([
+        (original_width - 1) / 2,
+        (original_height - 1) / 2,
+    ])
+
+    rotated_center = np.array([
+        (rotated_width - 1) / 2,
+        (rotated_height - 1) / 2,
+    ])
+
+    shifted_points = points - original_center
+
+    theta = np.deg2rad(angle)
+
+    rotation_matrix = np.array([
+        [np.cos(theta), np.sin(theta)],
+        [-np.sin(theta), np.cos(theta)],
+    ])
+
+    rotated_points = (
+        shifted_points @ rotation_matrix.T
+        + rotated_center
+    )
+
+    return rotated_points
+
+def match_annotations_to_plant_positions(
+    plants_df: pd.DataFrame,
+    annotation_points: np.ndarray,
+    boundaries: np.ndarray,
+) -> pd.DataFrame:
+    """
+    Match annotated plant centres to theoretical planting positions.
+
+    Parameters
+    ----------
+    plants_df : pd.DataFrame
+        Plant detection table containing ``row``, ``x_start`` and
+        ``x_end`` columns.
+    annotation_points : np.ndarray
+        Annotated plant centres in rotated image coordinates.
+        Expected shape is ``(n_annotations, 2)`` with columns
+        ``x`` and ``y``.
+    boundaries : np.ndarray
+        Vertical boundaries defining the crop rows.
+
+    Returns
+    -------
+    pd.DataFrame
+        Copy of ``plants_df`` with the additional columns
+        ``annotation_count`` and ``annotation_present``.
+    """
+    plants_df = plants_df.copy()
+
+    annotation_count = []
+    annotation_present = []
+
+    for _, segment in plants_df.iterrows():
+
+        row_index = int(segment["row"])
+
+        x_start = segment["x_start"]
+        x_end = segment["x_end"]
+
+        y_start = boundaries[row_index - 1]
+        y_end = boundaries[row_index]
+
+        in_segment = (
+            (annotation_points[:, 0] >= x_start)
+            & (annotation_points[:, 0] < x_end)
+            & (annotation_points[:, 1] >= y_start)
+            & (annotation_points[:, 1] < y_end)
+        )
+
+        count = int(np.sum(in_segment))
+
+        annotation_count.append(count)
+        annotation_present.append(count > 0)
+
+    plants_df["annotation_count"] = annotation_count
+    plants_df["annotation_present"] = annotation_present
+
+    return plants_df
+
+def compute_confusion_matrix(
+    predicted_occupied: pd.Series,
+    actual_occupied: pd.Series,
+) -> dict[str, int]:
+    """
+    Compute binary classification confusion matrix.
+
+    Parameters
+    ----------
+    predicted_occupied : pd.Series
+        Boolean predictions indicating whether a planting position
+        is considered occupied.
+    actual_occupied : pd.Series
+        Boolean reference labels indicating whether an annotated plant
+        is present.
+
+    Returns
+    -------
+    dict[str, int]
+        Counts of true positives (TP), false positives (FP),
+        false negatives (FN), and true negatives (TN).
+    """
+    tp = int(
+        (predicted_occupied & actual_occupied).sum()
+    )
+
+    fp = int(
+        (predicted_occupied & ~actual_occupied).sum()
+    )
+
+    fn = int(
+        (~predicted_occupied & actual_occupied).sum()
+    )
+
+    tn = int(
+        (~predicted_occupied & ~actual_occupied).sum()
+    )
+
+    return {
+        "tp": tp,
+        "fp": fp,
+        "fn": fn,
+        "tn": tn,
+    }
+
+def compute_classification_metrics(
+    tp: int,
+    fp: int,
+    fn: int,
+) -> dict[str, float]:
+    """
+    Compute precision, recall, and F1 score.
+
+    Parameters
+    ----------
+    tp : int
+        Number of true positives.
+    fp : int
+        Number of false positives.
+    fn : int
+        Number of false negatives.
+
+    Returns
+    -------
+    dict[str, float]
+        Precision, recall, and F1 score.
+    """
+    precision = (
+        tp / (tp + fp)
+        if tp + fp > 0
+        else 0.0
+    )
+
+    recall = (
+        tp / (tp + fn)
+        if tp + fn > 0
+        else 0.0
+    )
+
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if precision + recall > 0
+        else 0.0
+    )
+
+    return {
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+    }
+
+def evaluate_plant_detection(
+    plants_df: pd.DataFrame,
+    annotation_points: np.ndarray,
+    boundaries: np.ndarray,
+) -> tuple[pd.DataFrame, dict]:
+    """
+    Evaluate plant detection against annotated plant positions.
+
+    Parameters
+    ----------
+    plants_df : pd.DataFrame
+        Plant detection results.
+    annotation_points : np.ndarray
+        Annotated plant centres in rotated image coordinates.
+    boundaries : np.ndarray
+        Vertical boundaries defining the crop rows.
+
+    Returns
+    -------
+    tuple[pd.DataFrame, dict]
+        Enriched plant detection table and evaluation metrics.
+    """
+    plants_df = match_annotations_to_plant_positions(
+        plants_df=plants_df,
+        annotation_points=annotation_points,
+        boundaries=boundaries,
+    )
+
+    predicted_occupied = ~plants_df["missing_candidate"]
+    actual_occupied = plants_df["annotation_present"]
+
+    confusion = compute_confusion_matrix(
+        predicted_occupied=predicted_occupied,
+        actual_occupied=actual_occupied,
+    )
+
+    metrics = compute_classification_metrics(
+        tp=confusion["tp"],
+        fp=confusion["fp"],
+        fn=confusion["fn"],
+    )
+
+    evaluation = {
+        **confusion,
+        **metrics,
+    }
+
+    return plants_df, evaluation
+
+def prepare_rotated_annotation_points(
+    json_paths: list[Path],
+    image_path: Path,
+    best_angle: float,
+    rotated_shape: tuple[int, int],
+) -> np.ndarray:
+    """
+    Load and transform plant annotations to rotated image coordinates.
+
+    COCO annotations are loaded from JSON files, indexed by image,
+    converted to a DataFrame, filtered for the target image, and
+    transformed from the original image coordinate system to the
+    rotated image coordinate system.
+
+    Parameters
+    ----------
+    json_paths : list[Path]
+        Paths to COCO annotation JSON files.
+    image_path : Path
+        Path to the image whose plant annotations are required.
+    best_angle : float
+        Rotation angle applied to the image.
+    rotated_shape : tuple[int, int]
+        Shape of the rotated image as ``(height, width)``.
+
+    Returns
+    -------
+    np.ndarray
+        Array of annotated plant centres in the rotated image
+        coordinate system, with shape ``(n_annotations, 2)``.
+        Columns correspond to x and y coordinates.
+    """
+    # Load COCO annotations
+    coco_datasets = load_coco_annotations(
+        json_paths=json_paths,
+    )
+
+    # Link each image to its annotations
+    image_annotations = build_image_annotation_index(
+        coco_datasets=coco_datasets,
+    )
+
+    # Build annotation DataFrame
+    plant_annotations = build_plant_annotations_dataframe(
+        image_annotations=image_annotations,
+    )
+
+    # Keep annotations for the target image
+    plant_annotations = get_image_annotations(
+        plant_annotations=plant_annotations,
+        image_path=image_path,
+    )
+
+    # Get annotation centres
+    annotation_points = get_annotation_centers(
+        plant_annotations=plant_annotations,
+    )
+
+    # Get original image shape
+    original_shape = np.array(
+        Image.open(image_path)
+    ).shape[:2]
+
+    # Transform annotation centres
+    annotation_points_rotated = (
+        transform_original_points_to_rotated(
+            points=annotation_points,
+            angle=best_angle,
+            original_shape=original_shape,
+            rotated_shape=rotated_shape,
+        )
+    )
+
+    return annotation_points_rotated

opencropphenotyping/indices.py

@@ -0,0 +1,253 @@
+import numpy as np
+
+
+def _prepare_bands(band1: np.ndarray, band2: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Prepare the input bands for index computation.
+
+    Parameters
+    ----------
+    band1 : np.ndarray
+        First band.
+    band2 : np.ndarray
+        Second band.
+
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray]
+        Prepared bands as float32 arrays.
+    """
+    # Convert inputs to float32 arrays
+    band1 = np.asarray(band1, dtype=np.float32)
+    band2 = np.asarray(band2, dtype=np.float32)
+
+    # Ensure that the input bands have the same shape
+    if band1.shape != band2.shape:
+        raise ValueError("Input bands must have the same shape.")
+
+    return band1, band2
+
+
+def compute_normalized_difference_index(band1: np.ndarray, band2: np.ndarray) -> np.ndarray:
+    """
+    Compute the Normalized Difference Index (NDI) from the given two bands.
+
+    Parameters
+    ----------
+    band1 : np.ndarray
+        First band.
+
+    band2 : np.ndarray
+        Second band.
+
+    Returns
+    -------
+    np.ndarray
+        NDI image.
+    """
+    band1, band2 = _prepare_bands(band1, band2)
+
+    # Compute NDI using the formula: (band1 - band2) / (band1 + band2)
+    denominator = band1 + band2
+    numerator = band1 - band2
+    ndi = np.divide(numerator, denominator, out=np.zeros_like(denominator), where=denominator != 0)
+
+    return ndi.astype(np.float32)
+
+
+def compute_ndvi(red_band: np.ndarray, nir_band: np.ndarray) -> np.ndarray:
+    """
+    Compute the Normalized Difference Vegetation Index (NDVI) from the given red and near-infrared (NIR) bands.
+
+    Parameters
+    ----------
+    red_band : np.ndarray
+        Red band.
+
+    nir_band : np.ndarray
+        Near infrared band.
+
+    Returns
+    -------
+    np.ndarray
+        NDVI image.
+    """
+    return compute_normalized_difference_index(nir_band, red_band)
+
+
+def compute_ndre(nir_band: np.ndarray, red_edge_band: np.ndarray) -> np.ndarray:
+    """
+    Compute the Normalized Difference Red Edge Index (NDRE) from the given red and red edge bands.
+
+    Parameters
+    ----------
+    nir_band : np.ndarray
+        Near infrared band.
+
+    red_edge_band : np.ndarray
+        Red edge band.
+
+    Returns
+    -------
+    np.ndarray
+        NDRE image.
+    """
+    return compute_normalized_difference_index(nir_band, red_edge_band)
+
+def compute_gndvi(nir_band: np.ndarray, green_band: np.ndarray) -> np.ndarray:
+    """
+    Compute the Green Normalized Difference Vegetation Index (GNDVI) from the given nir and green bands.
+
+    Parameters
+    ----------
+    nir_band : np.ndarray
+        Red band.
+
+    green_band : np.ndarray
+        Red edge band.
+
+    Returns
+    -------
+    np.ndarray
+        GNDVI image.
+    """
+    return compute_normalized_difference_index(nir_band, green_band)
+
+def compute_savi(red_band: np.ndarray, nir_band: np.ndarray, L_factor : float = 0.5) -> np.ndarray:
+    """
+    Compute the Soil Adjusted Vegetation Index (SAVI) from the given red and near-infrared (NIR) bands.
+    The L factor is typically set to 0.5 for moderate vegetation cover.
+
+    Parameters
+    ----------
+    red_band : np.ndarray
+        Red band.
+
+    nir_band : np.ndarray
+        Near infrared band.
+
+    Returns
+    -------
+    np.ndarray
+        SAVI image.
+    """
+    # Raise an error if L < 0
+    if L_factor < 0:
+        raise ValueError("L_factor must be greater than or equal to 0.")
+
+    prepared_red_band, prepared_nir_band = _prepare_bands(red_band, nir_band)
+
+    # Compute SAVI index
+    denominator = prepared_nir_band + prepared_red_band + L_factor
+    numerator = (prepared_nir_band - prepared_red_band) * (1 + L_factor)
+    savi = np.divide(numerator, denominator, out=np.zeros_like(denominator), where=denominator != 0)
+
+    return savi.astype(np.float32)
+
+VEGETATION_INDICES = {
+    "ndvi": {
+        "function": compute_ndvi,
+        "bands": ["red_band", "nir_band"],
+    },
+    "savi": {
+        "function": compute_savi,
+        "bands": ["red_band", "nir_band"],
+    },
+    "ndre": {
+        "function": compute_ndre,
+        "bands": ["nir_band", "red_edge_band"],
+    },
+    "gndvi": {
+        "function": compute_gndvi,
+        "bands": ["nir_band", "green_band"],
+    },
+}
+
+def compute_indexes(
+        red_band: np.ndarray | None = None,
+        nir_band: np.ndarray | None = None,
+        green_band: np.ndarray | None = None,
+        red_edge_band: np.ndarray | None = None,
+        indices: list[str] | None = None,
+    ) -> dict[str, np.ndarray]:
+    """Compute vegetation indices from available spectral bands.
+
+    Parameters
+    ----------
+    red_band : np.ndarray or None, optional
+        Red spectral band.
+    nir_band : np.ndarray or None, optional
+        Near-infrared (NIR) spectral band.
+    green_band : np.ndarray or None, optional
+        Green spectral band.
+    red_edge_band : np.ndarray or None, optional
+        Red-edge spectral band.
+    indices : list[str] or None, optional
+        Names of the vegetation indices to compute. If None, all
+        available vegetation indices are requested.
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        Dictionary mapping each successfully computed vegetation index
+        to its resulting array. An index is skipped when one or more
+        of its required spectral bands are unavailable.
+
+    Raises
+    ------
+    ValueError
+        If an unknown vegetation index is requested.
+    """
+    results = {}
+
+    if indices is None:
+        indices = ["ndvi", "savi", "ndre", "gndvi"]
+
+    available_bands = {
+        "red_band": red_band,
+        "nir_band": nir_band,
+        "green_band": green_band,
+        "red_edge_band": red_edge_band,
+    }
+
+    for index in indices:
+        if index not in VEGETATION_INDICES:
+            raise ValueError(f"Unknown vegetation index: {index}")
+        
+        index_config = VEGETATION_INDICES[index]
+        required_bands = index_config["bands"]
+
+        if all(
+            available_bands[band] is not None
+            for band in required_bands
+        ):
+            compute_function = index_config["function"]
+            band_arrays = [
+                available_bands[band]
+                for band in required_bands
+            ]
+
+            results[index] = compute_function(*band_arrays)
+            
+    return results
+    
+def compute_exg(
+    rgb: tuple[np.ndarray, np.ndarray, np.ndarray],
+) -> np.ndarray:
+    """Compute the Excess Green Index (ExG).
+
+    Parameters
+    ----------
+    rgb : tuple[np.ndarray, np.ndarray, np.ndarray]
+        RGB image channels as (red, green, blue).
+
+    Returns
+    -------
+    np.ndarray
+        ExG image with dtype float32.
+    """
+    red = rgb[0].astype(np.float32)
+    green = rgb[1].astype(np.float32)
+    blue = rgb[2].astype(np.float32)
+
+    return 2 * green - red - blue