ChronoRoot 2.0 is an integrated open-source platform that combines affordable hardware with advanced artificial intelligence to enable sophisticated temporal plant phenotyping. The system offers a comprehensive solution for analyzing plant development, featuring:

• Multi-organ tracking of six distinct plant structures (main root, lateral roots, seed, hypocotyl, leaves, and petiole)
• Quality control through real-time validation
• Comprehensive measurements including novel gravitropic response parameters
• Dual specialized interfaces for both detailed architectural analysis and high-throughput screening

ChronoRoot 2.0 is designed as a two-step phenotyping solution: first, the segmentation of plant structures using deep learning models, and second, the analysis of the segmented data through user-friendly interfaces. Depending on the research needs, users can choose between a detailed analysis of individual plants or a high-throughput screening of multiple plants.

ChronoRoot2
├── chronoRootApp              # Standard Root Phenotyping Interface
├── chronoRootScreeningApp     # High-throughput Screening Interface
├── segmentationApp            # AI-based segmentation tools (nnUNet)
├── environment.yml            # Conda environment specification
├── install.sh                 # Automated installation script
├── Docker                     # Dockerfile for containerized deployment
└── Documents                  # User guides and technical documentation

Each component has its own dedicated documentation:

• Standard Root Phenotyping Interface - For detailed analysis of individual plants
• High-throughput Screening Interface - For efficient analysis of multiple plants
• Segmentation Module - AI-powered plant structure identification
• Docker Guide - Complete instructions for Docker-based deployment

PDF usage tutorials were incorporated in Documents for easy access. These make use of the Demo dataset included in the Docker image.

• Standard Interface Tutorial
• Screening Interface Tutorial
• Segmentation Tutorial

ChronoRoot 2.0 can be installed and used in three ways:

1. Docker Container (Recommended): Complete environment with all dependencies pre-configured
2. Local Installation: Quick conda-based setup for Ubuntu/macOS systems
3. Singularity Container: Alternative for HPC environments without Docker access

Docker provides the most reliable installation method across all platforms, ensuring an identical environment regardless of your operating system.

docker pull ngaggion/chronoroot:latest

For Linux systems, enable X11 forwarding for the graphical user interface:

xhost +local:docker

Run the container:

MOUNT="YOUR_LOCAL_DATA_PATH"

docker run -it --gpus all \
    -v $MOUNT:/DATA/ \
    -e DISPLAY=$DISPLAY \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    --shm-size=8gb \
    ngaggion/chronoroot:latest

After use, restrict X server access:

xhost -local:docker

ChronoRoot has been tested under Windows Subsystem for Linux, version 2. Please refer to this link for information on how to set up Docker with WSL2.

Use the command below for WSL2:

MOUNT="YOUR_LOCAL_DATA_PATH"

docker run -it --gpus all \
    -v $MOUNT:/DATA/ \
    -v /tmp/.X11-unix:/tmp/.X11-unix \
    -v /mnt/wslg:/mnt/wslg \
    -e DISPLAY \
    -e WAYLAND_DISPLAY \
    -e XDG_RUNTIME_DIR \
    -e PULSE_SERVER \
    --shm-size=8gb \
    ngaggion/chronoroot:latest

Note: If you don't have a GPU, remove the --gpus all flag from the command above. For GPU support, you need to install nvidia-docker2. See the Docker documentation for detailed instructions.

To simplify usage, these aliases are pre-configured in the Docker container:

alias segmentation='conda activate ChronoRoot; cd /app/segmentationApp; python run.py'
alias chronoroot='conda activate ChronoRoot; cd /app/chronoRootApp; python run.py'
alias screening='conda activate ChronoRoot; cd /app/chronoRootScreeningApp; python run.py'

With these aliases, you can simply use segmentation, chronoroot, or screening commands instead of the full activation and navigation commands.

Platform Compatibility: Local installation has been thoroughly tested on Ubuntu. For other systems, we strongly recommend using Docker to avoid potential compatibility issues.

Clone the repository and run the automated installer:

git clone https://github.com/ngaggion/ChronoRoot2.git
cd ChronoRoot2
bash install.sh
conda activate ChronoRoot

The installer will:

1. Install required system dependencies (zbar library)
2. Create a conda environment with all necessary packages
3. Install Python dependencies via pip

If you prefer to install manually or need to customize the installation:

conda create -y -n ChronoRoot python=3.13.9 \
    networkx=3.5 \
    pyqt=5.15.11 \
    numpy=2.2 \
    scikit-image=0.25.2 \
    pandas=2.3.3 \
    seaborn=0.13.2 \
    filterpy=1.4.5 \
    lifelines=0.30.0 \
    scikit-fda=0.10.1 \
    scipy=1.16.3 \
    pyzbar=0.1.9 \
    -c conda-forge

conda activate ChronoRoot
pip install opencv-python lapx==0.9.2 nnunetv2==2.6.2

Note: This single environment handles all functionality including segmentation, analysis, and FPCA. No separate environments are needed.

For high-performance computing environments where Docker is not available:

singularity build ChronoRoot.simg docker://ngaggion/chronoroot

This creates a Singularity container from the Docker image, providing the same functionality in HPC environments.

ChronoRoot 2.0 is designed to work with an affordable custom hardware setup that includes:

• Raspberry Pi 3B computer
• Fixed-zoom cameras (RaspiCam v2)
• Infrared LED backlighting
• 3D-printed and laser-cut components

For detailed hardware specifications and assembly instructions, see the ChronoRootModuleHardware repository.

For the controller software for the Raspberry Pi 3B, see the ChronoRoot Module Controller repository.

For detailed architectural analysis of individual plants:

With Docker aliases:

chronoroot

Manual activation (local installation):

conda activate ChronoRoot
cd chronoRootApp
python run.py

For more details on using this interface, see the Standard Interface documentation.

For high-throughput analysis of multiple plants:

With Docker aliases:

screening

Manual activation (local installation):

conda activate ChronoRoot
cd chronoRootScreeningApp
python run.py

For more details on using this interface, see the Screening Interface documentation.

To run the AI-powered segmentation pipeline:

With Docker aliases:

segmentation

Manual activation (local installation):

conda activate ChronoRoot
cd segmentationApp
python run.py

For detailed instructions on the segmentation process, see the Segmentation documentation.

A typical ChronoRoot 2.0 workflow involves:

1. Data Acquisition: Collect temporal sequences of plant images using the ChronoRoot hardware setup. Images are captured at regular intervals (typically every 15 minutes) over several days.

2. Segmentation: Process raw images to identify plant structures using the nnUNet models. This step uses deep learning to automatically detect and segment different plant organs.

3. Analysis: Analyze the segmented data with either:

   • Standard Interface (chronoroot command): For detailed analysis of individual plants with manual quality control
   • Screening Interface (screening command): For high-throughput automated analysis of multiple plants

4. Report Generation: Generate comprehensive reports with statistical analysis, visualizations, and comparisons between experimental groups.

If you use ChronoRoot 2.0 in your research, please cite our paper:

@article{gaggion2025chronoroot,
  title={ChronoRoot 2.0: An Open AI-Powered Platform for 2D Temporal Plant Phenotyping},
  author={Gaggion, Nicolás and Bonazzola, Rodrigo and Legascue, María Florencia and Mammarella, María Florencia and Rodriguez, Florencia Sol and Aballay, Federico Emanuel and Catulo, Florencia Belén and Barrios, Andana and Accavallo, Franco and Villarreal, Santiago Nahuel and Crespi, Martin and Ricardi, Martiniano María and Petrillo, Ezequiel and Blein, Thomas and Ariel, Federico and Ferrante, Enzo},
  journal={arXiv preprint arXiv:2504.14736},
  year={2025}
}

ChronoRoot 2.0 is released under the GNU General Public License v3.0.

For questions or support, please open an issue on GitHub.