Implement older monocot pipeline

README.md

@@ -1,7 +1,6 @@
 # sleap-roots
 
 [![CI](https://github.com/talmolab/sleap-roots/actions/workflows/ci.yml/badge.svg)](https://github.com/talmolab/sleap-roots/actions/workflows/ci.yml)
-[![Lint](https://github.com/talmolab/sleap-roots/actions/workflows/lint.yml/badge.svg)](https://github.com/talmolab/sleap-roots/actions/workflows/lint.yml)
 [![codecov](https://codecov.io/gh/talmolab/sleap-roots/branch/main/graph/badge.svg)](https://codecov.io/gh/talmolab/sleap-roots)
 [![Release](https://img.shields.io/github/v/release/talmolab/sleap-roots?label=Latest)](https://github.com/talmolab/sleap-roots/releases/)
 [![PyPI](https://img.shields.io/pypi/v/sleap-roots?label=PyPI)](https://pypi.org/project/sleap-roots)
@@ -10,17 +9,119 @@ Analysis tools for [SLEAP](https://sleap.ai)-based plant root phenotyping.
 
 ## Installation
 ```
-pip install git+https://github.com/talmolab/sleap-roots.git@main
+pip install sleap-roots
 ```
 
-If you are using conda:
+If you are using conda (recommended):
 ```
-conda create -n sleap-roots python=3.8
+conda create -n sleap-roots python=3.9
 conda activate sleap-roots
-pip install git+https://github.com/talmolab/sleap-roots.git@main
+pip install sleap-roots
 ```
 
-### Development
+## Usage
+
+### `DicotPipeline`
+
+**1. Computing traits for a single plant:**
+
+```py
+import sleap_roots as sr
+
+plant = sr.Series.load(
+    "tests/data/canola_7do/919QDUH.h5",
+    primary_name="primary_multi_day",
+    lateral_name="lateral_3_nodes"
+)
+pipeline = sr.DicotPipeline()
+traits = pipeline.compute_plant_traits(plant, write_csv=True)
+```
+
+**2. Computing traits for a batch of plants:**
+
+```py
+import sleap_roots as sr
+
+plant_paths = sr.find_all_series("tests/data/soy_6do")
+plants = [
+    sr.Series.load(
+        plant_path,
+        primary_name="primary_multi_day",
+        lateral_name="lateral__nodes",
+    ) for plant_path in plant_paths]
+
+pipeline = sr.DicotPipeline()
+all_traits = pipeline.compute_batch_traits(plants, write_csv=True)
+```
+
+**3. Computing individual traits:**
+
+```py
+import sleap_roots as sr
+import numpy as np
+
+plant = sr.Series.load(
+    "tests/data/canola_7do/919QDUH.h5",
+    primary_name="primary_multi_day",
+    lateral_name="lateral_3_nodes"
+)
+
+primary, lateral = plant[10]
+pts = np.concatenate([primary.numpy(), lateral.numpy()], axis=0).reshape(-1, 2)
+convex_hull = sr.convhull.get_convhull(pts)
+```
+
+### `YoungerMonocotPipeline`
+
+**1. Computing traits for a single plant:**
+
+```py
+import sleap_roots as sr
+
+plant = sr.Series.load(
+    "tests/data/rice_3do/0K9E8BI.h5",
+    primary_name="longest_3do_6nodes",
+    lateral_name="main_3do_6nodes"
+)
+pipeline = sr.YoungerMonocotPipeline()
+traits = pipeline.compute_plant_traits(plant, write_csv=True)
+```
+
+**2. Computing traits for a batch of plants:**
+
+```py
+import sleap_roots as sr
+
+plant_paths = sr.find_all_series("tests/data/rice_3do")
+plants = [
+    sr.Series.load(
+        plant_path,
+        primary_name="longest_3do_6nodes",
+        lateral_name="main_3do_6nodes"
+    ) for plant_path in plant_paths]
+
+pipeline = sr.YoungerMonocotPipeline()
+all_traits = pipeline.compute_batch_traits(plants, write_csv=True)
+```
+
+**3. Computing individual traits:**
+
+```py
+import sleap_roots as sr
+import numpy as np
+
+plant = sr.Series.load(
+    "tests/data/rice_3do/0K9E8BI.h5",
+    primary_name="longest_3do_6nodes",
+    lateral_name="main_3do_6nodes"
+)
+
+primary, lateral = plant[10]
+pts = np.concatenate([primary.numpy(), lateral.numpy()], axis=0).reshape(-1, 2)
+convex_hull = sr.convhull.get_convhull(pts)
+```
+
+## Development
 For development, first clone the repository:
 ```
 git clone https://github.com/talmolab/sleap-roots && cd sleap-roots
@@ -54,13 +155,16 @@ Then run `pytest` with:
 pytest tests
 ```
 
-To **develop on M1 Macs**, you'll need to manually install SLEAP first like this:
-```
-git clone https://github.com/talmolab/sleap && cd sleap
-conda env create -f environment_m1.yml -n sleap-roots
-```
-Then, install this package in editable mode:
-```
-cd .. && git clone https://github.com/talmolab/sleap-roots
-pip install -e ".[dev]"
-```
+## Acknowledgments
+
+This repository was created by the [Talmo Lab](https://talmolab.org) and [Busch Lab](https://busch.salk.edu) at the Salk Institute for Biological Studies as part of the [Harnessing Plants Initiative](https://www.salk.edu/harnessing-plants-initiative/).
+
+### Contributors
+
+- Elizabeth Berrigan
+- Lin Wang
+- Talmo Pereira
+
+### Citation
+
+*Coming soon.*

pyproject.toml

@@ -10,10 +10,11 @@ authors = [
     {name = "Talmo Pereira", email = "[email protected]"}
 ]
 description="Analysis tools for SLEAP-based plant root phenotyping."
-requires-python = ">=3.8"
+requires-python = ">=3.7"
 keywords = ["sleap", "plants", "roots", "phenotyping"]
 license = {text = "BSD-3-Clause"}
 classifiers = [
+    "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9"
 ]
@@ -24,7 +25,7 @@ dependencies = [
     "pandas",
     "matplotlib",
     "seaborn",
-    "sleap-io>=0.0.6",
+    "sleap-io>=0.0.11",
     "scikit-image",
     "shapely"
 ]

sleap_roots/__init__.py

@@ -6,14 +6,15 @@
 import sleap_roots.convhull
 import sleap_roots.ellipse
 import sleap_roots.networklength
+import sleap_roots.lengths
 import sleap_roots.points
 import sleap_roots.scanline
 import sleap_roots.series
 import sleap_roots.summary
 import sleap_roots.trait_pipelines
-from sleap_roots.trait_pipelines import DicotPipeline, TraitDef
-from sleap_roots.series import Series
+from sleap_roots.trait_pipelines import DicotPipeline, TraitDef, YoungerMonocotPipeline
+from sleap_roots.series import Series, find_all_series
 
 # Define package version.
 # This is read dynamically by setuptools in pyproject.toml to determine the release version.
-__version__ = "0.0.1"
+__version__ = "0.0.5"

sleap_roots/angle.py

@@ -1,7 +1,6 @@
 """Get angle of each root."""
 
 import numpy as np
-import math
 
 
 def get_node_ind(pts: np.ndarray, proximal: bool = True) -> np.ndarray:
@@ -12,68 +11,46 @@ def get_node_ind(pts: np.ndarray, proximal: bool = True) -> np.ndarray:
         proximal: Boolean value, where true is proximal (default), false is distal.
 
     Returns:
-        An array of shape (instances,) of proximal or distal node index.
-    """
-    # Check if pts is a numpy array
-    if not isinstance(pts, np.ndarray):
-        raise TypeError("Input pts should be a numpy array.")
+        An array of shape (instances,) of proximal or distal node indices.
 
-    # Check if pts has 2 or 3 dimensions
-    if pts.ndim not in [2, 3]:
-        raise ValueError("Input pts should have 2 or 3 dimensions.")
+        The proximal node is the first non-NaN node in the first half of the root.
 
-    # Check if the last dimension of pts has size 2
-    if pts.shape[-1] != 2:
-        raise ValueError(
-            "The last dimension of the input pts should have size 2,"
-            "representing x and y coordinates."
-        )
+        The distal node is the last non-NaN node in the last half of the root.
 
+        If all nodes (or all nodes in the half of the root) are NaN, then zero is
+        returned.
+    """
     # Check if pts is 2D, if so, reshape to 3D
     if pts.ndim == 2:
         pts = pts[np.newaxis, ...]
 
+    n_instances, n_nodes, _ = pts.shape
+
     # Identify where NaN values exist
-    nan_mask = np.isnan(pts).any(axis=-1)
+    is_nan = np.isnan(pts).any(axis=-1)  # (n_instances, n_nodes)
 
     # If only NaN values, return NaN
-    if nan_mask.all():
-        return np.nan
+    if is_nan.all():
+        return np.zeros((n_instances,))
 
     if proximal:
-        # For proximal, we want the first non-NaN node in the first half root
-        # get the first half nan mask (exclude the base node)
-        node_proximal = nan_mask[:, 1 : int((nan_mask.shape[1] + 1) / 2)]
-        # get the nearest non-Nan node index
-        node_ind = np.argmax(~node_proximal, axis=-1)
-        # if there is no non-Nan node, set value of 99
-        node_ind[node_proximal.all(axis=1)] = 99
-        node_ind = node_ind + 1  # adjust indices by adding one (base node)
+        # Proximal nodes are in the first half of the root.
+        is_nan = is_nan[:, 1 : (n_nodes + 1) // 2]
+        node_ind = np.argmax(~is_nan, axis=-1) + 1
     else:
-        # For distal, we want the last non-NaN node in the last half root
-        # get the last half nan mask
-        node_distal = nan_mask[:, int(nan_mask.shape[1] / 2) :]
-        # get the farest non-Nan node
-        node_ind = (node_distal[:, ::-1] == False).argmax(axis=1)
-        node_ind[node_distal.all(axis=1)] = -95  # set value if no non-Nan node
-        node_ind = pts.shape[1] - node_ind - 1  # adjust indices by reversing
+        # Distal nodes are in the last half of the root.
+        is_nan = is_nan[:, (n_nodes + 1) // 2 :]
+        node_ind = np.argmax(~is_nan[:, ::-1], axis=-1)
+        node_ind = n_nodes - node_ind - 1
 
-    # reset indices of 0 (base node) if no non-Nan node
-    node_ind[node_ind == 100] = 0
-
-    # If pts was originally 2D, return a scalar instead of a single-element array
-    if pts.shape[0] == 1:
-        return node_ind[0]
-
-    # If only one root, return a scalar instead of a single-element array
-    if node_ind.shape[0] == 1:
-        return node_ind[0]
+    # If the selected index is missing originally, return 0.
+    node_ind = np.where(is_nan.all(axis=-1), 0, node_ind)
 
     return node_ind
 
 
 def get_root_angle(
-    pts: np.ndarray, node_ind: np.ndarray, proximal: bool = True, base_ind=0
+    pts: np.ndarray, node_ind: np.ndarray, proximal: bool = True, base_ind: int = 0
 ) -> np.ndarray:
     """Find angles for each root.
 
@@ -97,7 +74,8 @@ def get_root_angle(
         pts = np.expand_dims(pts, axis=0)
 
     angs_root = []
-    for i in range(len(node_ind)):
+    # Calculate the angle for each instance
+    for i in range(pts.shape[0]):
         # if the node_ind is 0, do NOT calculate angs
         if node_ind[i] == 0:
             angs = np.nan
@@ -113,3 +91,31 @@ def get_root_angle(
     if angs_root.shape[0] == 1:
         return angs_root[0]
     return angs_root
+
+
+def get_vector_angles_from_gravity(vectors: np.ndarray) -> np.ndarray:
+    """Calculate the angle of given vectors from the gravity vector, assuming the gravity
+    vector points downwards along the positive y-axis.
+
+    Args:
+        vectors: An array of vectorss with shape (instances, 2), each representing a vector
+                from start to end in an instance.
+
+    Returns:
+        An array of angles in degrees with shape (instances,), representing the angle
+        between each vector and the downward-pointing gravity vector.
+    """
+    gravity_vector = np.array([0, 1])  # Downwards along the positive y-axis
+    # Calculate the angle between the vectors and the gravity vectors
+    angles = np.arctan2(vectors[:, 1], vectors[:, 0]) - np.arctan2(
+        gravity_vector[1], gravity_vector[0]
+    )
+    angles = np.degrees(angles)
+    # Normalize angles to the range [0, 180] since direction doesn't matter
+    angles = np.abs(angles)
+    angles[angles > 180] = 360 - angles[angles > 180]
+
+    # If only one root, return a scalar instead of a single-element array
+    if angles.shape[0] == 1:
+        return angles[0]
+    return angles