Datasets:

weitung1121
/

SOVIS

license: cc-by-sa-4.0
pretty_name: 'SOVIS: Sonar-Visual Dataset for Cross-Modal Underwater Perception'
task_categories:
  - robotics
  - image-to-image
  - object-detection
tags:
  - underwater
  - imaging-sonar
  - multibeam-sonar
  - forward-looking-sonar
  - cross-modal
  - marine-robotics
  - rov
  - fish
size_categories:
  - 10K<n<100K
annotations_creators:
  - expert-generated
source_datasets:
  - original
configs:
  - config_name: frames
    default: true
    data_files:
      - split: train
        path: data/frames/train/*.parquet
      - split: validation
        path: data/frames/validation/*.parquet
      - split: test
        path: data/frames/test/*.parquet
  - config_name: mini
    data_files:
      - split: train
        path: data/frames/train/2024-07-09_17-35-22-*.parquet
  - config_name: fish
    data_files:
      - split: train
        path: data/fish/train.parquet
      - split: test
        path: data/fish/test.parquet
  - config_name: sessions
    data_files: data/sessions.parquet
  - config_name: highlights
    data_files: data/highlights.parquet
  - config_name: raw_pings
    data_files: data/raw_pings/*.parquet

SOVIS: a sonar–visual dataset for cross-modal underwater perception

Paper (arXiv:2606.01398) · Code and usage guide (GitHub)

SOVIS pairs camera frames with multibeam imaging-sonar frames recorded at the same time on a Blueye X3 ROV in the Trondheimfjord, Norway. It contains 69,481 synchronized pairs (2.1 h) from 17 dives at 6 sites, at depths of 0–91 m and water temperatures of 7–18 °C. The sonar is a Blueprint Oculus M750d. Its returns are released as native polar images and as the complete raw Oculus messages (106,059 pings).

The dataset is meant for learning across the two modalities: predicting sonar from camera images or the reverse, camera-to-sonar object localization, and opti-acoustic fusion. A labelled subset gives 706 camera fish boxes, of which 306 are matched to boxes in the sonar image.

15 s at Ilsvika (dive 2024-07-09_17-04-02, ~8 m deep), in real time. Left: the camera. Right: the synchronized sonar ping as a top-down fan, with range rings in metres. Green marks a labelled fish: its camera box, the bearing span of that box on the fan, and its box in the sonar image. Dashed cyan: the camera's field of view.


Pairs	69,481 (train 49,335 / validation 4,873 / test 15,273)
Camera	1725×974 RGB (JPEG q95), ~9.4 Hz (every 3rd frame of the ~28 fps video)
Sonar	Oculus M750d, 256 beams over ±65°, 750 kHz (55,917 pairs) or 1.2 MHz (13,564 pairs), 8-bit, ~14.7 pings/s
Sonar range	0.0077–0.2493 m per range bin, 1.0–119.9 m maximum range
Per frame	UTC time, depth, water temperature, heading, camera tilt, sonar settings, scene tags
Fish labels	706 camera boxes on 514 frames, 306 matched sonar boxes, 127 tracks
Size	frames 22.4 GB · raw_pings 9.5 GB · fish 0.18 GB · mini 0.43 GB
License	CC BY-SA 4.0 (data), MIT (`tools/`)

Quick start

from datasets import load_dataset

# One dive (~0.43 GB) with seabed and labelled fish: a good first download
mini = load_dataset("weitung1121/SOVIS", "mini", split="train")
row = mini[0]
row["camera"]          # PIL image, 1725x974
row["sonar"]           # PIL image, polar: rows = range bins, columns = beams

# Everything, streamed, keeping only frames with the seabed in view
frames = load_dataset("weitung1121/SOVIS", split="train", streaming=True)
seabed = frames.filter(lambda r: r["seabed_in_camera"])

# Labelled fish (camera boxes + matched sonar boxes)
fish = load_dataset("weitung1121/SOVIS", "fish")

tools/sovis.py (MIT) has the helpers. It reads calibration/, so download both: snapshot_download("weitung1121/SOVIS", repo_type="dataset", allow_patterns=["tools/*", "calibration/*"]), or clone the GitHub repository.

import numpy as np, sovis
polar = np.asarray(row["sonar"])
bearings = sovis.sonar_bearings(row["sonar_mode"])          # beam angles (deg), from calibration/
fan, valid = sovis.polar_to_fan(polar, bearings, row["sonar_range_resolution_m"])
grid, ok = sovis.to_metric_grid(polar, row["sonar_range_resolution_m"], max_range_m=7.0, bin_m=0.02)  # fixed 350x256
# PyTorch: DataLoader(ds, batch_size=16, collate_fn=sovis.collate_metric) batches pings with different settings

raw = load_dataset("weitung1121/SOVIS", "raw_pings", split="train", streaming=True)
ping = sovis.decode_ping(next(iter(raw))["oculus_message"])  # header fields, bearings, polar image

python tools/show_samples.py --repo weitung1121/SOVIS --config mini --n 6 draws camera/sonar panels like the figure above.

Where to look

The dives differ a lot: some fly over rocky seabed with kelp and fish, and some cross deep water to reach the bottom. Every frame carries tags, so you can go straight to the content you need:

seabed_in_camera (experimental) — the seabed (rock, sand, vegetation, slopes) is visible in the camera image: 12,381 pairs.
seabed_in_sonar (experimental) — the sonar sees the seabed within its range: 19,497 pairs.
fish_boxes — human-verified fish boxes: 514 frames. This field is null on frames that were never annotated, so null means "not annotated", not "no fish".

Disclaimer. seabed_in_camera and seabed_in_sonar are experimental, automated tags. They exist only to help you find seabed frames quickly; they are not ground truth. We checked them on a small set of samples, where they were more than 94 % correct.

The highlights config (data/highlights.parquet, 71 segments) lists continuous stretches of at least 5 s with the seabed in view, and groups of labelled fish frames (at most 3 s apart). Each row gives the first and last frame_id, the duration and the row number in the dataset viewer. The sessions config gives one row per dive with its site, depth and temperature range, sonar settings, tag counts and a short description:

Dive	Site	Split	Depth (m)	Frames	Seabed in camera	Fish frames	Description
`2024-07-09_15-09-42`	A Tangen	train	0–18	1,171	0		Ascent from 18 m to the surface.
`2024-07-09_15-22-33`	A Tangen	train	6–31	8,066	0		Descent to 31 m and a long stretch near 31 m; marine snow.
`2024-07-09_15-37-26`	A Tangen	train	0–31	6,533	0		Ascent from 31 m with mid-water stops; ends under the support boat with the tether in view.
`2024-07-09_15-51-01`	A Tangen	train	0–10	2,436	0		Mid-water at 6-9 m; recovery beside the support boat (last frames above water).
`2024-07-09_16-27-15`	B Munkholmen	validation	0–22	4,873	186		Mid-water at 10-21 m with a pass over sandy bottom at ~21 m; ends at the surface.
`2024-07-09_17-01-17`	C Ilsvika	train	0–1	966	0		At the surface (0-1 m) before the Ilsvika dives.
`2024-07-09_17-04-02`	C Ilsvika	train	-0–9	13,721	8,988	427	Shallow flight (to 8.5 m) over kelp, seaweed, rock and sand with many fish; most fish labels.
`2024-07-09_17-34-05`	C Ilsvika	train	7–8	469	469		7-8 m over kelp with several fish in view.
`2024-07-09_17-35-22`	C Ilsvika	train	5–8	1,560	734	72	5-8 m along a vegetated seabed with fish; fish test set.
`2024-07-10_10-52-25`	C Ilsvika	train	2–10	329	91		Short descent onto a seaweed-covered seabed at ~9 m.
`2024-07-10_11-16-02`	D Munkholmen	test	0–7	2,713	1,813		4-7 m over kelp and rock; ends at the surface.
`2024-07-10_12-15-12`	E Haugan	test	0–1	496	0		Just below the surface before the Haugan descent.
`2024-07-10_12-17-59`	E Haugan	test	0–40	1,144	0		Descent from the surface to 40 m.
`2024-07-10_12-20-22`	E Haugan	test	39–73	2,814	78		Lamp-lit descent from 40 m to a rocky, muddy seabed at ~73 m, then ascent to ~39 m.
`2024-07-10_12-37-33`	E Haugan	test	0–1	8	0		A few seconds just below the surface.
`2024-07-10_13-04-17`	F Tautra	test	0–33	8,098	22		Descent to ~31 m over a sandy slope, then mid-water at 10-19 m; recovery beside the support boat.
`2024-07-10_13-33-22`	A Tangen	train	0–91	14,084	0		Descent to 91 m with the lamps on below ~40 m; marine snow.

What is in the repository

Config	Rows	Content
`frames` (default)	69,481	every synchronized pair, with images and all per-frame fields; splits by site (below)
`mini`	1,560	one dive (`2024-07-09_17-35-22`, Ilsvika) from `frames`; no extra files
`fish`	514	every labelled frame (same columns as `frames`); train = 2024-07-09_17-04-02, test = 2024-07-09_17-35-22. 15 of them fall in short sonar gaps (no ping within ±0.1 s, see `sonar_dt_s`) and are not in `frames`
`sessions`	17	one row per dive
`highlights`	71	where the seabed or fish are in view
`raw_pings`	106,059	every sonar ping recorded during each dive, as the original Oculus network message plus parsed header

data/frames/{train,validation,test}/<dive>-NNN.parquet   (~1000 rows per file)
data/fish/{train,test}.parquet
data/raw_pings/<dive>.parquet
data/sessions.parquet, data/highlights.parquet
calibration/sensors.yaml          sensor frames (camera-to-sonar position), camera crop and lens model, sonar specs
calibration/sonar_bearings.csv    bearing of each beam
calibration/sync.csv              camera-sonar lag of each dive and how it was measured
tools/sovis.py, tools/show_samples.py
assets/                           figures on this page

Fields of `frames` and `fish`

Field	Type	Description
`frame_id`	str	`<dive>/<frame_index>`, unique
`session`, `site`, `site_name`	str	dive ID (local start time, CEST), site letter A–F and name
`frame_index`	int	index of the frame within the dive (gaps where no sonar ping was close enough)
`segment`	int	increases whenever consecutive frames are more than 0.5 s apart; frames within a segment are continuous
`timestamp_utc`	timestamp	camera time (UTC)
`camera`	image	JPEG, 1725×974
`sonar`	image	PNG, 8-bit polar image, `sonar_n_ranges` × 256 (see conventions)
`sonar_ping_id`	int	Oculus ping counter; joins `raw_pings` (with `session`)
`sonar_timestamp_utc`	timestamp	when that ping was taken (sonar clock, UTC)
`sonar_dt_s`	float	sonar time − (camera time − lag); within ±0.1 s in `frames`
`sonar_repeat`	bool	the same ping as the previous frame (the sonar briefly pinged slower than the camera)
`sync_lag_s`, `sync_measured`	float, bool	camera–sonar lag applied to this frame, and whether it was measured from the data (see "Synchronization")
`sync_quality`	str	how that lag was obtained: `seabed` (measured where both sensors see the seabed; most reliable), `yaw` (measured from yaw, mostly in open water), `assumed` (median of the day), or `manual` (set by eye)
`sonar_mode`	int	1 = 750 kHz, 2 = 1.2 MHz
`sonar_frequency_khz`	float	reported centre frequency
`sonar_range_resolution_m`, `sonar_n_ranges`, `sonar_max_range_m`		metres per range bin, number of bins, `n_ranges × resolution`
`sonar_gain_percent`	float	gain setting (50–100 %)
`sonar_speed_of_sound_mps`	float	sound speed the sonar used to convert time to range (see the caveat below)
`depth_m`, `water_temperature_c`	float	from the sonar's pressure and temperature sensors
`heading_deg`, `camera_tilt_deg`	float	Blueye compass heading, and camera tilt relative to the vehicle (+ up, −30…+30°; see "Sensor frames"), read from the video overlay
`pilot_lat`, `pilot_lon`	float	GPS of the pilot's tablet on the boat (site location, not ROV position)
`seabed_in_camera`, `seabed_in_sonar`	bool	experimental, automated seabed tags (see "Where to look")
`fish_boxes`	list or null	fish annotations, below

Each entry of fish_boxes has these fields:

track_id: boxes linked across frames.
x, y, w, h: the camera box in pixels of the 1725×974 image.
camera_box_source: manual (drawn by the annotator) or auto_accepted (a YOLOv8 proposal accepted by the annotator and matched to a sonar box).
sonar_box_source: tracked, manual or null (no sonar box).
sonar_ping_id: the ping the sonar box was drawn on.
sonar_ping_dt_s: time of that ping minus the time of the frame's synchronized ping.
sonar_bearing_min_deg, sonar_bearing_max_deg, sonar_range_min_m, sonar_range_max_m: the sonar box.
sonar_echo_contrast: mean intensity inside the sonar box minus the bands just before and after it in range. Larger values mean a clearer echo.

Sensors and conventions

Sensor frames. Both sensors are on a Blueye X3 ROV. The camera is the X3's built-in camera behind the front dome. The Oculus M750d sits under the front of the hull on Blueye's standard sonar mount, on the vehicle's centreline, facing forward.

C (body frame): origin at the camera's optical centre; x forward, y starboard, z down.
S (sonar frame): origin at the centre of the sonar's transducer face, with the same axes as C when the sonar is level. Bearing 0° points along x; positive bearings turn toward starboard (+y).

Position of S in C	x (forward)	y (starboard)	z (down)
metres	+0.01	0.00	+0.37

The sonar is 0.37 m below the camera and 1 cm ahead of it. sovis.SONAR_IN_CAMERA_M holds these values, and sovis.sonar_to_camera(bearing_deg, range_m, camera_tilt_deg, elevation_deg=0) maps a sonar return into OpenCV camera coordinates (x right, y down, z forward). A sonar return has no measured elevation; it lies somewhere within the vertical aperture (±10° at 750 kHz, ±6° at 1.2 MHz).

Camera tilt (camera_tilt_deg). The camera tilts inside the dome about the y axis through C. camera_tilt_deg is the angle of the optical axis above the x axis: 0 is level with the vehicle, positive tilts up, negative tilts down, range −30…+30°. It is relative to the vehicle, not to the horizon. A camera tilted by α sees a point (x, y, z) of C at right = y, down = x·sin α + z·cos α, forward = x·cos α − z·sin α.

Sonar tilt. Blueye's sonar mount can also tilt the sonar about its y axis (−30…+30°). That angle was not logged. The sonar's own tilt reading (pitch_deg in raw_pings: negative when the sonar points up, and it includes the vehicle's pitch) is within ±10° for about 90 % of pings. In dive 2024-07-10_13-33-22 the sonar was tilted 30° up, the mount's limit, from 11:45:46 to 11:46:52 and from 11:49:35 to 11:49:58 UTC. In the first of these stretches its strongest echo is the sea surface, at twice the depth.

Camera. This is the built-in camera of the Blueye X3, recorded at 1920×1080 and ~28 fps. The frame rate is variable. The burned-in overlay is cropped away, leaving x ∈ [0, 1725) and y ∈ [51, 1025) of the original frame. No in-water calibration target was recorded. calibration/sensors.yaml gives a horizontal lens model fitted to the fish correspondences: HFOV ≈ 80°, cx ≈ 920 px, distortion k ≈ 0.1, with a median bearing residual of ~1.6°. Use sovis.camera_x_to_bearing.

Sonar image. sonar is the 8-bit intensity exactly as the Oculus reported it, with no resampling. Its conventions:

Row i is at range i × sonar_range_resolution_m from the transducer, so row 0 is the nearest.
Column j is beam j, at the bearing given in calibration/sonar_bearings.csv (the same table is in every raw message).
Bearings run from −65° (column 0, port, which is left in the camera image) to +65° (starboard, right).
Beams are not evenly spaced: 0.40° apart at the centre and 0.95° at the edges.
sovis.polar_to_fan draws the usual top-down fan.

Range setting. The pilot changed the sonar's range during the dives, at times zooming out to the 750 kHz maximum of 120 m. All 1.2 MHz pings are at most 7 m (that mode's maximum is 40 m). Shares of pairs by maximum range: ≤5 m 2%, 5–10 m 82%, 10–20 m 12%, 20–120 m 4%. Use sonar_max_range_m to select a range, or sovis.to_metric_grid to resample every ping onto one metric grid.

Intensity is relative: it depends on sonar_gain_percent and on the sonar's gamma setting (stored in raw_pings). No per-row gain was transmitted, and the values are not calibrated backscatter.

Range and sound speed. The sonar was configured with salinity 0, so it converted echo time to range with a fresh-water sound speed (~1465 m/s, sonar_speed_of_sound_mps). In the fjord the true speed is ~1490–1505 m/s, so true ranges are about 2–3 % longer than the bins suggest. sovis.range_scale(...) returns the correction factor (Mackenzie 1981, default salinity 33 PSU).

Depth and temperature come from the sensors inside the Oculus. The ROV's own logged depth was unreliable on these dives and is not used. Depth is gauge pressure × 9.93 m/bar, accurate to about ±0.5 m near the surface.

raw_pings. oculus_message holds the complete Oculus SimplePingResult2 message as recorded in the ROS 2 bags: a 16-byte header, the ping parameters, a 256-entry int16 bearing table at byte 202, and the 8-bit image from byte image_offset (2048). timestamp_utc is when the ping was taken (the same time base as sonar_timestamp_utc), and received_utc is when the sonar computer received it. The parsed columns include the sonar's own clock (ping_start_time_s) and the pitch, roll and heading of the sonar's internal sensor. Pitch and roll give the sonar's tilt: the mount angle plus the vehicle's attitude, with accelerations adding about ±10° during manoeuvres. Pitch is negative when the sonar points up. Fewer than 0.1 % of pings carry invalid values (|angle| > 90°). The internal heading disagrees with the Blueye compass by a varying offset and includes invalid values (4095); use heading_deg from frames instead.

Synchronization

Why. The camera and the sonar run on separate clocks on separate machines: the Blueye ROV records the camera video, and a separate computer logs the sonar pings. The two clocks were not linked during the dives, so we synchronized the data afterwards. All times in SOVIS are UTC.

How.

Camera time. The Blueye burns its clock into every video frame. We read it from the image and interpolate between its one-second steps.
Sonar time. Every ping carries the sonar's own clock, which we place in UTC.
Camera–sonar offset. The sonar's clock restarts each time the sonar is switched on, so the two clocks differ by one constant offset per power-on (9 in total). We measure each offset by cross-correlating the vehicle's turning as both sensors see it: the image shift between camera frames and the shift of the sonar image between pings.
Pairing. Each camera frame is paired with the nearest ping and kept only if that ping is within ±0.1 s.

Accuracy. Re-measuring the offset on the released data in 50-s windows leaves a median of −0.04 s, with 88% of the clearly correlated windows within ±0.3 s. Each frame's sync_quality says how its offset was obtained:

seabed: both sensors see the seabed, which gives the clearest signal (19,429 pairs). Use these when you need tight camera–sonar correspondence.
yaw: measured from turning in open water; less certain.
assumed: no clear signal, so the median offset of the same day is used (sync_measured is false; error up to about ±0.4 s).
manual: set by eye.

The offset of each dive is below and in calibration/sync.csv. assets/sync_check.jpg shows synchronized examples, with the camera field of view drawn on the sonar fan.

Dive	UTC time span	Lag (s)	Quality	Evidence
`2024-07-09_15-09-42`	13:09:45–13:11:53	1.05	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-09_15-22-33`	13:22:34–13:37:19	1.27–1.31	yaw	measured from yaw: 6 yaw windows (dives 15-22-33, 15-37-26, 15-51-01)
`2024-07-09_15-37-26`	13:37:28–13:49:23	1.26–1.27	yaw	measured from yaw: 6 yaw windows (dives 15-22-33, 15-37-26, 15-51-01)
`2024-07-09_15-51-01`	13:51:02–13:55:30	1.26	yaw	measured from yaw: 6 yaw windows (dives 15-22-33, 15-37-26, 15-51-01)
`2024-07-09_16-27-15`	14:27:15–14:36:42	1.05	yaw	measured from yaw: 2 yaw windows (dives 16-27-15)
`2024-07-09_17-01-17`	15:01:20–15:03:01	0.93	seabed	measured on the seabed: 79 one-minute windows in which both sensors see the seabed (dives 17-04-02, 17-34-05, 17-35-22)
`2024-07-09_17-04-02`	15:04:02–15:22:48	0.87–0.92	seabed	measured on the seabed: 79 one-minute windows in which both sensors see the seabed (dives 17-04-02, 17-34-05, 17-35-22)
`2024-07-09_17-04-02`	15:22:48–15:33:58	0.87–0.88	seabed	measured on the seabed: 79 one-minute windows in which both sensors see the seabed (dives 17-04-02, 17-34-05, 17-35-22)
`2024-07-09_17-34-05`	15:34:05–15:35:07	0.89–0.90	seabed	measured on the seabed: 79 one-minute windows in which both sensors see the seabed (dives 17-04-02, 17-34-05, 17-35-22)
`2024-07-09_17-35-22`	15:35:22–15:38:40	0.89	seabed	measured on the seabed: 79 one-minute windows in which both sensors see the seabed (dives 17-04-02, 17-34-05, 17-35-22)
`2024-07-10_10-52-25`	08:52:25–08:53:06	1.67	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-10_11-16-02`	09:16:02–09:21:02	1.79–1.80	seabed	measured on the seabed: 15 one-minute windows in which both sensors see the seabed (dives 11-16-02)
`2024-07-10_12-15-12`	10:15:12–10:16:02	1.54	yaw	measured from yaw: whole-dive yaw correlation (dives 12-15-12)
`2024-07-10_12-17-59`	10:17:58–10:20:10	1.53	yaw	measured from yaw: whole-dive yaw correlation (dives 12-15-12)
`2024-07-10_12-20-22`	10:20:26–10:20:26	1.67	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-10_12-20-22`	10:20:26–10:25:47	1.67	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-10_12-37-33`	10:37:36–10:37:37	1.63	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-10_13-04-17`	11:04:19–11:20:07	1.67–1.68	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day
`2024-07-10_13-33-22`	11:33:22–12:00:21	1.65–1.67	assumed	assumed: no clear correlation in this sonar power-on period; median lag of the same day

Details

Sonar clock. Pings are timed by the sonar's own clock (ping_start_time_s), not by when the logging computer received them: 0.4% of pings arrived in delayed bursts, up to 3.7 s late (kept as received_utc in raw_pings). The logging computer's clock, used only to place the sonar clock in UTC, ran 2 h behind UTC and was corrected.
Camera clock. 8,882 of 8,886 one-second changes of the burned-in clock were read consistently; interpolating between them is good to ~1 frame (35 ms). In one video file (dive 17-04-02 after 15:22:50 UTC) the frames fell steadily behind the burned-in clock, by up to ~0.8 s; we measured that delay from the image's yaw against the burned-in compass and removed it. In every other video file the image yaw against the compass peaks at about 0.10 s, the compass display delay. Dive 17-04-02 was recorded as two video files and both are used.
Offset measurement. The turning signals are the image shift between camera frames, the shift of the sonar image between pings, and the sonar's internal compass. seabed offsets use one-minute windows in which both sensors see the seabed; yaw offsets use 3-minute windows with a clear correlation, or the whole dive. manual offsets, set in a side-by-side viewer (tools/release/sync_viewer.py in the build code), override the measurements.
The offset is constant within a power-on period. Measured dive by dive: in the power-on period with dives 15-22-33, 15-37-26 (3 sonar recordings), each dive's own measurements give K within 0.05 s of the period's value; in the power-on period with dives 17-04-02, 17-34-05, 17-35-22 (4 sonar recordings), each dive's own measurements give K within 0.11 s of the period's value. Buffering on either side would show up as a drifting offset.
Re-measurement. In dives with a measured offset, 156 windows had a strong correlation (r ≥ 0.6); 80 % lie within −0.27…+0.13 s. The ROV's yaw often oscillates, which gives the correlation several near-equal peaks about 0.3 s apart, so single windows scatter more than the offset itself does. By quality: seabed 134 windows, median −0.05 s, 89% within ±0.3 s; yaw 22 windows, median −0.04 s, 86% within ±0.3 s.
Assumed offsets are used for 2024-07-09_15-09-42, 2024-07-10_10-52-25, 2024-07-10_12-20-22, 2024-07-10_12-37-33, 2024-07-10_13-04-17, 2024-07-10_13-33-22.
Pairing. The median time between a frame and its ping is 0.018 s. Frames with no ping within ±0.1 s fall in short gaps of the sonar stream and are left out. sync_lag_s is the difference between the frame's camera time and the ping's sonar_timestamp_utc; it is constant within a sonar recording.

Fish annotations

The fish were annotated with the cross-modal labelling tool described in the paper:

YOLOv8 proposed fish in the camera image; annotators accepted, corrected or added boxes. The tool can accept proposals in bulk, so an accepted proposal is released only if the annotator also matched it to a sonar box; every other released camera box was drawn by hand.
A tracker propagated sonar boxes between pings; annotators drew the rest by hand.

Counts:

	Number
Camera boxes	706 on 514 frames (111 accepted proposals, 595 drawn by hand)
Matched sonar boxes	306 (230 tracker-propagated, 76 manual)

Coverage. Annotations are not exhaustive. Annotated dives: 2024-07-09_17-04-02 (634 boxes), 2024-07-09_17-35-22 (72 boxes). Only frames where the annotator found a fish were annotated. A camera box without a sonar box was not matched; it does not mean the fish was invisible to the sonar.

Timing. Each sonar box stays on the ping it was drawn on (sonar_ping_id). Annotators worked on the earlier, drifting timeline, so that ping can differ from the frame's synchronized ping. sonar_ping_dt_s gives the difference: 2024-07-09_17-04-02 245 boxes, median +0.07 s, 71% within 0.2 s; 2024-07-09_17-35-22 61 boxes, median −1.27 s, 0% within 0.2 s. A box is correct for its own ping, but where that ping is far from the frame's (about 2 s in dive 17-35-22) the camera and sonar views show the fish at different moments. If you need tight correspondence, filter on abs(sonar_ping_dt_s) and sonar_echo_contrast.

Test set size. The fish test dives have 3 distinct fish tracks, so report results per track as well as per box.

Range correction. Sonar box ranges are corrected for an image-decoding offset in the original labelling pipeline, which put ranges +8 bins too far.

Splits. Use the dive-level split of the fish config, or split by track_id. A random split over frames leaks, because consecutive frames show the same fish.

Splits

frames is split by site so that test sites are never seen in training:

train: A Tangen and C Ilsvika.
validation: B.
test: D, E Haugan and F Tautra.

The deep-water dives (to 91 m at Tangen, 73 m at Haugan) give extra variety. Sites B and D are both labelled "Munkholmen" but lie about 7 km apart (see pilot_lat/lon). To build other splits, use the site, session and segment columns, and keep whole segments together.

Do not mix the two benchmarks without care. The fish test dives (2024-07-09_17-35-22) are at site C, so they are in the frames train split. If you pretrain on frames and then evaluate on the fish test set, leave those dives out of pretraining.

Limitations and Assumptions

No robot IMU or attitude data. The ROV's IMU and attitude (roll, pitch, angular rates, accelerations) are not included, and there is no ground-truth position (no DVL or USBL). The only vehicle orientation in the release is the Blueye compass heading (heading_deg); camera_tilt_deg is the camera's tilt relative to the vehicle, not the vehicle's pitch. The pitch and roll in raw_pings come from the sonar's own tilt sensor (mount angle plus vehicle attitude), not from the vehicle.
Extrinsics. The camera–sonar transform in "Sensor frames" comes from the vehicle and mount dimensions; it was not calibrated in water. The sonar mount's tilt angle was not logged (see "Sonar tilt").
Camera model. The lens model in calibration/sensors.yaml is fitted to fish correspondences, not calibrated with a target.
Heading and camera tilt come from the Blueye overlay. The Blueye X3 burns an on-screen overlay into every recorded camera frame: date and time, camera tilt, compass heading, depth and water temperature. The released images are cropped so the overlay is not visible. We read two of its values by matching the overlay's digit shapes on every 9th video frame (~3 Hz), and give each released frame the next reading:
- heading_deg is the Blueye's compass heading, in whole degrees, as shown in the overlay (no deviation or declination correction).
- camera_tilt_deg is the angle of the Blueye's tilting camera relative to the vehicle, in whole degrees: 0 is level, positive is tilted up, negative is tilted down (range −30…+30°; see the figure in "Sensors and conventions"). The sonar does not tilt with the camera.
- Readings are at most 9 video frames (~0.3 s) after the frame they are given to. Tilt is median-filtered over 5 readings and heading over 3, which removes single misreads; quick changes are therefore smoothed by up to ~1 s.
Depth and temperature. These come from the sensors inside the sonar, not from the overlay or the Blueye logs (the logged Blueye depth was unreliable on these dives). Depth assumes sea water of 1025 kg/m³ and is accurate to about ±0.5 m near the surface.
Synchronization.
- Camera times assume the burned-in clock is exact at each second change, and that frames stay a constant time behind it except where that delay was measured to drift (one video file, corrected).
- Sonar times come from the sonar's own clock; one offset per sonar power-on period links it to the camera clock.
- Offsets measured in open water (sync_quality = yaw) are less certain than those measured on the seabed; for 6 dives the offset is assumed rather than measured.
Range and intensity.
- Ranges assume the sonar's fresh-water sound speed; true ranges are ~2–3 % longer.
- Intensities are relative (gain-dependent), not calibrated backscatter.
1.2 MHz bearings. The manufacturer lists a 70° horizontal aperture at 1.2 MHz, but this sonar reported the same ±65° bearing table in both modes. We use that table. During turns, the sonar image rotates by the same amount per degree of compass rotation in both modes, which supports it. Edge beams may be weaker at 1.2 MHz.
Fish labels. They are partial, come almost entirely from two dives at one site, and were drawn on the earlier, drifting timeline (see "Fish annotations").
Surface frames. Frames with depth_m below ~1 m are at the surface during launch and recovery, and a few show the support boat above water. No people are visible in the data.

License

Data (images, sonar, tables, annotations) is released under CC BY-SA 4.0. Commercial use is allowed if you give credit and share adapted material under the same license.
Code in tools/ is MIT.
Some camera boxes started as YOLOv8 proposals; every released box was drawn or matched by an annotator and is released under CC BY-SA 4.0.
No Kongsberg data is included. The equipment was a Blueye X3 ROV and a Blueprint Subsea Oculus M750d.

Citation

@inproceedings{chen2026sovis,
  title     = {A Sonar-Visual Dataset for Cross-Modal Underwater Robot Perception},
  author    = {Chen, Weitung and Tinn, Phil and Auran, Per Gunnar and Ludvigsen, Martin and Haro, Peter Halland},
  booktitle = {ICRA 2026 Workshop: From Sea to Space: Advancing Perception in Harsh Domains},
  year      = {2026}
}

Acknowledgements

Supported by the Research Council of Norway (project 328193). Data were collected by MIT, SINTEF and NTNU in the Trondheimfjord. Contact: Weitung Chen (weitung@mit.edu).