CropDriveSD / README.md
Sainath001's picture
Dataset card and figures
6ea9902 verified
|
Raw History Blame Contribute Delete
19 kB
---
license: cc-by-4.0
pretty_name: "CropDriveSD: A multimodal dataset for under-canopy robot navigation and stem phenotyping in corn"
size_categories:
- 1M<n<10M
task_categories:
- robotics
- depth-estimation
tags:
- agriculture
- under-canopy
- corn
- rgb-d
- lidar
- imu
- gnss
- odometry
- world-model
- action-conditioned
configs:
- config_name: sessions
data_files: meta/sessions.parquet
- config_name: segments
data_files: meta/segments.parquet
---
# CropDriveSD
A small tracked robot driven by a person under the canopy of harvest-stage corn in South Dakota, October 2026. Two
colour and depth (RGB-D) cameras, a 360° light detection and ranging (LiDAR) sensor with its inertial measurement unit
(IMU), real-time kinematic (RTK) satellite positioning, track encoders and every steering and throttle command the
operator gave, all on one clock. 4.93 hours of driving in 9 runs on 4 fields, with people and vehicle number plates
removed from every camera frame.
The forward camera sees the row ahead, for navigation and for world models conditioned on the operator's commands. The
side camera looks across the row at the stalks, for stem detection and phenotyping.
**Authors:** Sainath Reddy Gummi, Kundana Reddy Gummi · **Questions:** the Community tab of this page ·
**Cite:** see [Citation](#citation)
## At a glance
| | |
|---|---|
| Fields | A, a variety trial near Arlington, and B, C and D, farm fields near Huron, South Dakota |
| Dates | Oct 11, 16, 17 and 18, 2026 |
| Runs | 9, cut into 97 continuous driving segments |
| Driving kept | 4.93 h (idle stretches of 10 s or more removed) |
| Camera frames | 532,436 forward and 532,372 side colour frames, each with a depth frame |
| LiDAR points | 3.55 billion rows, 1.96 billion of them returns, each with its own time |
| Download size | 167 GB (one run is 9.6 to 28.3 GB) |
| Licence | Creative Commons Attribution 4.0 (CC BY 4.0) |
| Version | 1.1, the first public release |
## Runs
| Run | Field | Driving (min) | Segments | Size (GB) |
|---|---|---|---|---|
| `2026-10-11_fieldA_run1` | A | 39.5 | 18 | 25.0 |
| `2026-10-11_fieldA_run2` | A | 17.0 | 13 | 9.9 |
| `2026-10-16_fieldB_run1` | B | 21.1 | 11 | 11.4 |
| `2026-10-16_fieldB_run2` | B | 38.1 | 19 | 20.3 |
| `2026-10-17_fieldC_run1` | C | 36.7 | 7 | 21.2 |
| `2026-10-17_fieldC_run2` | C | 49.1 | 4 | 28.3 |
| `2026-10-17_fieldC_run3` | C | 18.9 | 1 | 9.6 |
| `2026-10-17_fieldC_run5` | C | 31.8 | 10 | 18.7 |
| `2026-10-18_fieldD_run1` | D | 43.7 | 14 | 23.0 |
Field C run 4 is not released: the robot stood idle throughout.
## The robot
![The robot and its sensors](https://huggingface.co/datasets/Sainath001/CropDriveSD/resolve/main/media/robot_sensors.png)
*The robot from the front (a), the right side (b) and above (c), cut out onto black, and the sensor layout to scale (d).
The white bars mark the width over the tracks and the track length (the photos have perspective). The camera views in
(d) are the horizontal fields of view of the 640x480 colour streams.*
The base is a [Lynxmotion A4WD3 Tracked](https://wiki.lynxmotion.com/info/wiki/lynxmotion/view/rover-kits/a4wd3-tracked/)
rover kit, steered like a tank (skid steer), small enough to drive between corn rows. Lynxmotion publishes its
dimensions and CAD files. A metal ammunition box on the chassis carries the sensors: the cameras on its front and
right faces, the LiDAR and the antenna on its lid. There is no CAD model of this mount, so `meta/robot.json` and the
figure give the measured positions.
| | |
|---|---|
| Footprint | 0.406 m long, 0.447 m wide over the tracks |
| Drive | four motors through a Sabertooth motor driver, commanded directly by a FlySky radio control (RC) receiver |
| Operator | a person with an RC transmitter. There is no autonomy in these runs |
| Track travel | 0.570 m per sprocket revolution on concrete, 0.549 to 0.575 m on soil (per run in `kinematics.json`) |
| Turning | effective track width 0.44 to 0.49 m (per run in `kinematics.json`), wider than the 0.364 m between track centres, as usual for skid steer |
| Computer | NVIDIA Jetson AGX Orin 64 GB, running the recording software |
`meta/robot.json` gives the body frame, the dimensions and every sensor's position.
## Sensors
| Sensor | What is recorded | Rate |
|---|---|---|
| Intel RealSense D435i, forward | colour 640x480 and 16-bit depth 640x480 | 30 Hz |
| Intel RealSense D435i, right side | colour 640x480 and 16-bit depth 640x480 | 30 Hz |
| Livox Mid-360 | 360° LiDAR points with a time for every point, reflectivity | 10 Hz scans |
| Livox Mid-360 IMU | gyroscope and accelerometer | 200 Hz |
| u-blox ZED-F9P | position in a local east-north-up frame per field, fix quality | 5 Hz |
| RC receiver (logged by an Arduino) | all six channels, ch1 steering and ch2 throttle | about 50 Hz |
| Track encoders | counts on all four motors | 20 Hz |
Every stream is timed on the Jetson's clock. The LiDAR is locked to it over the Precision Time Protocol (PTP).
## Files
```
SHA256SUMS checksum of every data file
meta/
sessions.parquet one row per run: field, date, kept seconds, segments, frame and point counts
segments.parquet the kept driving segments of each run, with start and end times
robot.json dimensions, body frame, sensor positions, track kinematics
calibration/
<serial>_factory.json each camera's factory intrinsics and depth-to-colour extrinsics
intrinsics_<serial>.json colour intrinsics solved from checkerboard views (use these)
camera_to_lidar.json rotation and translation from each camera to the LiDAR, with per-run checks
time_offsets.csv camera time minus LiDAR time per run and camera, with bootstrap bounds
depth_correction_v1.json optional depth correction per camera, with its valid range
imu_noise.json LiDAR IMU noise (Allan deviation of a 3 h still recording)
kinematics.json track scale against RTK and effective track width per run
sessions/<run>/
front/rgb.mp4 colour, H.264 (constant rate factor 12), every kept frame in time order
front/rgb_frames.parquet one row per frame: frame, segment_id, t_ns, exposure, gain, masked
front/depth.mkv depth, FFV1 lossless 16-bit
front/depth_frames.parquet one row per frame, plus depth_units_m and a CRC-32 (cyclic redundancy check) of the frame
side/... the same for the side camera (serial 902512070232, forward is 845112071331)
lidar/points_<NN>.parquet one file per kept segment: t_ns, x, y, z (m, sensor frame), reflectivity, tag
x = y = z = 0 means no return (45 % of rows), drop those rows for geometry
lidar/imu.parquet t_ns, gyro_x/y/z (rad/s), acc_x/y/z (g)
rc.parquet t_ns, ch1_us to ch6_us (pulse width in microseconds), receiver counters
encoders.parquet t_ns, counts and edge totals per track (rl, fl, fr, rr)
gnss.parquet t_ns, east_m, north_m, up_m, fix_quality, n_sats, hdop
export.json how the run was made: segments, counts, checks, code hashes
```
Every stream keeps its native rate. Nothing is resampled.
## Quick start
Download one run instead of everything:
```python
from huggingface_hub import snapshot_download
root = snapshot_download(
repo_id="Sainath001/CropDriveSD", repo_type="dataset", revision="v1.1",
allow_patterns=["meta/*", "calibration/*", "sessions/2026-10-11_fieldA_run2/*"])
run = f"{root}/sessions/2026-10-11_fieldA_run2"
```
Read the tables with pandas and the movies with PyAV (or ffmpeg). Row `i` of a frame table is frame `i` of its movie.
```python
import av
import pandas as pd
frames = pd.read_parquet(f"{run}/front/depth_frames.parquet")
with av.open(f"{run}/front/depth.mkv") as movie:
for i, frame in enumerate(movie.decode(video=0)):
if frames.masked[i]:
continue # blanked frame, see Privacy
depth_m = frame.to_ndarray() * frames.depth_units_m[i] # depth units to metres, 0 = no depth
break
# the operator's command at each forward colour frame (latest command at or before the frame)
rgb = pd.read_parquet(f"{run}/front/rgb_frames.parquet")
rc = pd.read_parquet(f"{run}/rc.parquet")
paired = pd.merge_asof(rgb, rc, on="t_ns", direction="backward")
```
Check a download with `sha256sum -c SHA256SUMS` from the dataset folder.
## Time and frames
- `t_ns` is int64 nanoseconds on the robot's clock (Coordinated Universal Time). Camera frames use the RealSense time of exposure, LiDAR
points and IMU use the Mid-360's PTP time, the other streams their arrival time.
- Colour and depth, and the two cameras, are separate streams. Join them by nearest `t_ns`.
- Each movie joins its segments end to end. Take time from the frame table's `t_ns`, not from the movie's own
timestamps. Colour and depth have slightly different frame counts, and the counts in `sessions.parquet` are colour
frames. `bag_ns` is the recording's own relative time, and `t_source` is 0 for every frame.
- Depth is the depth sensor's own image (a wider view, focal length about 383 px), not aligned to colour. Its
intrinsics and `depth_to_color` are in `calibration/<serial>_factory.json`.
- Runs have gaps between segments where idle or private stretches were cut. Do not build sequences across a
`segment_id` change.
- LiDAR frame: +y forward, +x right, +z up. Body frame (`robot.json`): x forward, y left, z up, origin on the floor
at the centre of the tracks.
- Positions are in a local east-north-up frame per field. Latitude and longitude are not released.
## Calibration
- Camera intrinsics: solved from pooled checkerboard views (forward focal length 614.9 px, side 602.3 px). The
principal point keeps the factory value. Distortion is k1, k2, p1, p2, k3 in OpenCV order, with k3 = 0. Fit errors and held-out checks are in each file.
- Camera to LiDAR: use `R` and `t_m` of each camera, `p_lidar = R @ p_camera + t_m`, in the colour camera's optical frame
(x right, y down, z forward). The other entries in the file are checks. Rotations were
solved from field data and agree between runs within about 0.2° (0.2 to 0.6° on held-out runs). Translations come
from tape measurements and photos, about 1 cm. `robot.json` gives the middle of each camera bar, about 3 cm
from the colour sensor.
- Time: camera timestamps are 11 to 22 ms earlier than LiDAR timestamps for the same motion, by run and camera
(`time_offsets.csv`). `t_ns` is not corrected: on the LiDAR clock a frame is at
`t_ns - offset_ms_camera_minus_lidar * 1e6`.
- Depth: the D435i depth reads slightly short, more so with distance. `depth_correction_v1.json` gives a correction
per camera, `Z = 1 / (s / D + c)`, fitted against the LiDAR and checked against a flat board, valid from 0.3 to
2.5 m (forward) and 0.3 to 4 m (side). The movies keep the raw depth.
- IMU: `imu_noise.json` is the Allan deviation of a 2 h still stretch recorded on Oct 23, in °/s and mg (the tables are
in rad/s and g). Gyroscope biases change between days (about 1 °/s in the field runs), so a filter must estimate them.
## Privacy and cleaning
- Idle stretches of 10 s or more are cut from every stream, so each run is a set of continuous driving segments.
- Every camera frame in which a person or a visible vehicle number plate appears is blanked: black colour, zero depth,
same timestamp, `masked = true` (3.9 % of forward and 3.7 % of side frames). People were found by a detector over
every frame, then reviewed manually with the edges checked frame by frame. The LiDAR, IMU, positions, commands and
encoders stay complete.
- A few short stretches are cut from every stream: where a vehicle or equipment stood in the rows, and about a minute
of field B run 2 where the side camera's frame times were corrupted.
- Skip masked frames when training (`masked == False`). Use the column, not pixel values: a few unmasked frames are
nearly black. At the edges of a blanked stretch, colour and depth masks can differ by one frame.
## Field conditions and failure cases
![Field conditions and failure cases](https://huggingface.co/datasets/Sainath001/CropDriveSD/resolve/main/media/conditions.png)
*Release frames, forward camera unless marked, except (d to f), which are phone photos from the field days. (a) Lodged
stalks across the row, field C run 1. (b) Volunteer corn (the green plant left of centre), field B run 1. (c) A large
weed, field C run 5. (d) A fallen tree at the field edge. (e) Brace roots beside the track. (f) Fallen ears next to the
track, which the operator steered around to keep them out of the sprockets. (g) Bright sun: colour clipped beside its
depth, field C run 2. (h) A leaf on the lens, depth lost over most of the frame, field C run 2. (i, j) Side camera,
0.33 s apart on the same plants: the stalks in view, then hidden by a leaf. Depth in metres, black where the camera
gave none.*
## Field events and interventions
Times are in Coordinated Universal Time, the clock of `t_ns`.
- Field A run 1: the motor battery faded from about 22:29, drove the robot at only about 0.07 m/s from about 22:37,
and was replaced from about 22:46 to 22:49. The sensors run on a separate battery and kept their rates. Commands
give less speed than usual in this stretch.
- Field C run 5: the screws of the front-right sprocket mount came loose some time between about 19:50 and 20:50.
The robot kept driving normally. Do not rely on the front-right encoder in this run.
- Hand help: where volunteer corn or lodged stalks left less room than the robot's 0.447 m (17.6 inch) width, the
operator lifted or nudged the robot by hand, and in some places drove it over lodged stalks. These moments are in
the data (the commands, the encoders, the IMU and the forward camera show them) but are not labelled in v1.1.
## Checks
- Depth is lossless: every depth frame that is not blanked matches the recording bit for bit (CRC-32 per frame in
`depth_frames.parquet`).
- Colour: peak signal-to-noise ratio against the recording at least 35.9 dB, median 37.9 to 39.8 dB per camera.
- Frame times increase within every stream, and every frame table has one row per movie frame.
## Known limitations
- The cameras are not hardware-synchronized with each other or with the LiDAR. Use `time_offsets.csv`.
- Encoders: the front-left (`fl`) and rear-right (`rr`) channels are reliable. Use those two. There are 1224 edges per
sprocket revolution, and RTK positions lag the encoders by about 50 ms.
- The motor driver recalibrates its stick range at power-up, so the same stick position can give a slightly different
speed in different runs.
- Track travel on soil differs from the concrete value by a few percent (`kinematics.json`), so treat wheel odometry as
approximate.
- Positioning: field A has differential corrections only (no RTK). Under the canopy the RTK fix drops to float at
times, and one field C run lost its corrections for about half an hour. Over all runs 55 % of fixes are RTK fixed and
18 % RTK float (`fix_quality` 4 and 5). A few position jumps remain (apparent speeds above 2 m/s), so filter them.
- Colour is 640x480. Some frames are overexposed in direct sun.
## Not in this release
- Latitude and longitude, the raw recordings and the calibration recordings.
- Robot poses. LiDAR-inertial reference trajectories checked against RTK are planned for a later version.
- An official train, validation and test split. A recommended split, balanced for turning, occlusion and lighting,
will follow.
## Versions
| Version | Contents |
|---|---|
| v1.1 | the 9 runs as movies and tables, metadata, solved calibration, depth correction |
| later | reference poses, recommended split, a LeRobot copy, a small sample pack and converter scripts |
Pin a version when you load the data (`revision="v1.1"`). Later versions add files.
## Related datasets
Published datasets from field robotics that are worth reading next to this one:
- Under the canopy of corn and other row crops, recorded by a small ground robot:
Cuaran, J., Baquero Velasquez, A. E., Valverde Gasparino, M., Uppalapati, N. K., Sivakumar, A. N., Wasserman, J.,
Huzaifa, M., Adve, S., & Chowdhary, G. (2024). Under-canopy dataset for advancing simultaneous localization and mapping
in agricultural robotics. *The International Journal of Robotics Research, 43*(6), 739-749.
https://doi.org/10.1177/02783649231215372
- Soybean, recorded with the same Intel RealSense D435i camera model:
Soncini, N., Cremona, J., Vidal, E., García, M., Castro, G., & Pire, T. (2026). The Rosario dataset v2: Multi-modal
dataset for agricultural robotics. *The International Journal of Robotics Research, 45*(5), 695-713.
https://doi.org/10.1177/02783649251368909
- Agricultural fields, with front and side cameras and a LiDAR on a ground robot:
Marzoa Tanco, M., Trinidad Barnech, G., Andrade, F., Baliosian, J., Llofriu, M., Di Martino, J., & Tejera, G. (2024).
MAgro dataset: A dataset for simultaneous localization and mapping in agricultural environments. *The International
Journal of Robotics Research, 43*(5), 591-601. https://doi.org/10.1177/02783649231210011
- Unstructured natural environments, including a Livox LiDAR:
Liu, Y., Fu, Y., Qin, M., Xu, Y., Xu, B., Chen, F., Goossens, B., Sun, P. Z., Yu, H., Liu, C., Chen, L., Tao, W., &
Zhao, H. (2024). BotanicGarden: A high-quality dataset for robot navigation in unstructured natural environments.
*IEEE Robotics and Automation Letters, 9*(3), 2798-2805. https://doi.org/10.1109/LRA.2024.3359548
## Citation
Gummi, S. R., & Gummi, K. R. (2026). *CropDriveSD: A multimodal dataset for under-canopy robot navigation and stem
phenotyping in corn* [Data set]. Hugging Face. https://doi.org/10.57967/hf/11324
```bibtex
@misc{gummi2026cropdrivesd,
author = {Gummi, Sainath Reddy and Gummi, Kundana Reddy},
title = {{CropDriveSD}: A multimodal dataset for under-canopy robot navigation and stem phenotyping in corn},
year = {2026},
publisher = {Hugging Face},
howpublished = {Data set},
doi = {10.57967/hf/11324},
url = {https://doi.org/10.57967/hf/11324}
}
```
## Licence
CC BY 4.0. Use it, share it and build on it, with credit.
## Acknowledgements
This research was mainly supported by funding from the Hatch (SD00H777-23) and Hatch-Multistate (SD00R730-23) projects
through the South Dakota Agricultural Experiment Station at South Dakota State University. Thank you to Jason Leyendecker
of Hefty Seed Company (fields B, C and D), Matt of Prairie Ag Partners (field A) and the farm owners and managers who let
a robot into their corn. Thank you also to Mazhar Sher and Kwanghee Won for sharing lab equipment, and to James Kemeshi
for fabricating the sensor mount.