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

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 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 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:

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.

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

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

@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.