| """Small helpers for the SOVIS dataset (MIT licence). Dependencies: numpy (+ opencv-python for drawing). |
| |
| Conventions used throughout SOVIS |
| * Polar sonar image: shape (n_ranges, n_beams) uint8. Row i is at range i * range_resolution |
| (metres, from the transducer). Column j is beam j at bearing bearings_deg[j]. Bearings |
| increase left to right; negative = port (left in the camera image), positive = starboard. |
| * Fan (Cartesian) image from polar_to_fan(): sonar at the bottom centre, forward is up and |
| starboard is right, as seen from above. |
| * Camera image: 1725x974 crop of the 1920x1080 Blueye frame (x in [0,1725), y in [51,1025)). |
| """ |
| import struct |
| from functools import lru_cache |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| _HERE = Path(__file__).resolve().parent |
|
|
|
|
| |
| def decode_ping(message): |
| """Decode one raw Oculus SimplePingResult2 message (the `oculus_message` bytes in raw_pings). |
| |
| Returns a dict with header fields, `bearings_deg` (n_beams,) and `image` (n_ranges, n_beams) uint8. |
| The image section starts at `image_offset` (2048 in SOVIS), after the header and bearing table. |
| """ |
| m = memoryview(message) |
| oid, _, _, msg_id, version, _, _ = struct.unpack_from("<HHHHHIH", m, 0) |
| if oid != 0x4F53 or msg_id != 0x23 or version != 2: |
| raise ValueError("not an Oculus SimplePingResult2 message") |
| master_mode, ping_rate, network_speed, gamma, flags = struct.unpack_from("<5B", m, 16) |
| range_setting, gain, speed_of_sound_setting, salinity = struct.unpack_from("<4d", m, 21) |
| ping_id, status = struct.unpack_from("<II", m, 89) |
| (frequency, temperature, pressure, heading, pitch, roll, speed_of_sound_used, |
| ping_start_time) = struct.unpack_from("<8d", m, 97) |
| data_size, = struct.unpack_from("<B", m, 161) |
| range_resolution, = struct.unpack_from("<d", m, 162) |
| n_ranges, n_beams = struct.unpack_from("<HH", m, 170) |
| image_offset, image_size, message_size = struct.unpack_from("<III", m, 190) |
| if data_size != 0 or flags & 0x04: |
| raise ValueError("only 8-bit images without per-row gain are handled (SOVIS uses these)") |
| bearings = np.frombuffer(message, "<i2", count=n_beams, offset=202) / 100.0 |
| image = np.frombuffer(message, np.uint8, count=n_ranges * n_beams, offset=image_offset) |
| return dict(master_mode=master_mode, ping_rate=ping_rate, gamma=gamma, flags=flags, |
| range_setting_m=range_setting, gain_percent=gain, salinity=salinity, ping_id=ping_id, |
| status=status, frequency_hz=frequency, temperature_c=temperature, pressure_bar=pressure, |
| heading_deg=heading, pitch_deg=pitch, roll_deg=roll, speed_of_sound_used=speed_of_sound_used, |
| ping_start_time=ping_start_time, range_resolution=range_resolution, n_ranges=n_ranges, |
| n_beams=n_beams, image_offset=image_offset, message_size=message_size, |
| bearings_deg=bearings, image=image.reshape(n_ranges, n_beams)) |
|
|
|
|
| @lru_cache(maxsize=None) |
| def _bearing_table(): |
| return np.genfromtxt(_HERE.parent / "calibration" / "sonar_bearings.csv", delimiter=",", names=True) |
|
|
|
|
| def sonar_bearings(mode): |
| """Bearing (deg) of each of the 256 beams for sonar_mode 1 (750 kHz) or 2 (1.2 MHz).""" |
| return np.array(_bearing_table()[f"mode{mode}_deg"], dtype=np.float64) |
|
|
|
|
| |
| def fan_width(size, max_range_m, bearings_deg): |
| """Width (pixels) of the fan image polar_to_fan() draws for these settings.""" |
| scale = (size - 1) / max_range_m |
| return int(np.ceil(2 * max_range_m * np.sin(np.radians(np.abs(bearings_deg).max())) * scale)) + 1 |
|
|
|
|
| def fan_xy(bearing_deg, range_m, size, width, max_range_m): |
| """Pixel (x, y) in a polar_to_fan() image of a point at (bearing, range).""" |
| scale = (size - 1) / max_range_m |
| a = np.radians(bearing_deg) |
| return (width - 1) / 2 + range_m * np.sin(a) * scale, size - 1 - range_m * np.cos(a) * scale |
|
|
|
|
| @lru_cache(maxsize=16) |
| def _fan_maps(bearings_bytes, range_resolution, n_ranges, size, max_range_m): |
| bearings_deg = np.frombuffer(bearings_bytes, np.float64) |
| width = fan_width(size, max_range_m, bearings_deg) |
| scale = (size - 1) / max_range_m |
| ys, xs = np.mgrid[0:size, 0:width].astype(np.float32) |
| east = (xs - (width - 1) / 2) / scale |
| north = (size - 1 - ys) / scale |
| r = np.hypot(east, north) |
| theta = np.degrees(np.arctan2(east, north)) |
| map_y = (r / range_resolution).astype(np.float32) |
| map_x = np.interp(theta, bearings_deg, np.arange(len(bearings_deg))).astype(np.float32) |
| valid = (theta >= bearings_deg[0]) & (theta <= bearings_deg[-1]) & (map_y <= n_ranges - 1) & (r <= max_range_m) |
| for a in (map_x, map_y, valid): |
| a.setflags(write=False) |
| return map_x, map_y, valid |
|
|
|
|
| def polar_to_fan(polar, bearings_deg, range_resolution, size=512, max_range_m=None): |
| """Render a polar image as a top-down fan. Returns (fan uint8 (size, width), valid mask bool). |
| |
| The remap grids are cached per (bearings, resolution, n_ranges, size, max range).""" |
| import cv2 |
| n_ranges = polar.shape[0] |
| max_range_m = max_range_m or n_ranges * range_resolution |
| map_x, map_y, valid = _fan_maps(np.asarray(bearings_deg, np.float64).tobytes(), float(range_resolution), |
| n_ranges, size, float(max_range_m)) |
| fan = cv2.remap(np.ascontiguousarray(polar), map_x, map_y, cv2.INTER_LINEAR, borderValue=0) |
| fan[~valid] = 0 |
| return fan, valid |
|
|
|
|
| def to_metric_grid(polar, range_resolution, max_range_m=7.0, bin_m=0.02): |
| """Resample the range axis to fixed metric bins so pings with different settings batch together. |
| |
| Returns (grid float32 (n_bins, n_beams), valid bool (n_bins,)); bins beyond the ping's range are 0 |
| and marked invalid. The beam axis is left as is (use sonar_bearings() for the angles). |
| """ |
| centres = (np.arange(int(round(max_range_m / bin_m))) + 0.5) * bin_m |
| src = centres / range_resolution |
| valid = src <= polar.shape[0] - 1 |
| idx = np.clip(src, 0, polar.shape[0] - 1) |
| i0 = np.floor(idx).astype(int) |
| i1 = np.minimum(i0 + 1, polar.shape[0] - 1) |
| w = (idx - i0).astype(np.float32)[:, None] |
| p = polar.astype(np.float32) |
| grid = (1 - w) * p[i0] + w * p[i1] |
| grid[~valid] = 0 |
| return grid, valid |
|
|
|
|
| def camera_x_to_bearing(x, hfov_deg=80.0, cx=920.0, k=0.1): |
| """Approximate sonar bearing (deg) of a camera column x (pixels in the 1725-wide crop). |
| |
| The model from the SOVIS annotation tool is theta = hfov/2 * xn * (1 + k (1 - xn^2)), with |
| xn = (x - cx) / cx. The defaults were fitted to the 306 fish correspondences (median residual |
| ~1.6 deg). It ignores the camera-sonar baseline (parallax) and the camera tilt, so treat it as a |
| horizontal guide rather than a calibration. |
| """ |
| xn = (np.asarray(x, dtype=np.float64) - cx) / cx |
| return hfov_deg / 2 * xn * (1 + k * (1 - xn ** 2)) |
|
|
|
|
| |
| |
| SONAR_IN_CAMERA_M = (0.01, 0.0, 0.37) |
|
|
|
|
| def sonar_to_camera(bearing_deg, range_m, camera_tilt_deg, elevation_deg=0.0, sonar_tilt_deg=0.0): |
| """Sonar return -> OpenCV camera coordinates (x right, y down, z forward; metres). |
| |
| A return is known by bearing and range only; its elevation lies somewhere within the vertical |
| aperture (about +-10 deg at 750 kHz, +-6 deg at 1.2 MHz; positive up). camera_tilt_deg and |
| sonar_tilt_deg are positive up. Project with your own intrinsics, e.g. u = fx * x / z + cx. |
| """ |
| b, e = np.radians(bearing_deg), np.radians(np.asarray(elevation_deg) + sonar_tilt_deg) |
| t = np.radians(camera_tilt_deg) |
| r = np.asarray(range_m, dtype=np.float64) |
| x = r * np.cos(e) * np.cos(b) + SONAR_IN_CAMERA_M[0] |
| y = r * np.cos(e) * np.sin(b) + SONAR_IN_CAMERA_M[1] |
| z = -r * np.sin(e) + SONAR_IN_CAMERA_M[2] |
| forward = np.cos(t) * x - np.sin(t) * z |
| down = np.sin(t) * x + np.cos(t) * z |
| return np.stack(np.broadcast_arrays(y, down, forward), axis=-1) |
|
|
|
|
| |
| def seawater_sound_speed(temperature_c, depth_m, salinity_psu=33.0): |
| """Mackenzie (1981) sound speed in sea water (m/s).""" |
| T, D, S = temperature_c, depth_m, salinity_psu |
| return (1448.96 + 4.591 * T - 5.304e-2 * T ** 2 + 2.374e-4 * T ** 3 + 1.340 * (S - 35) |
| + 1.630e-2 * D + 1.675e-7 * D ** 2 - 1.025e-2 * T * (S - 35) - 7.139e-13 * T * D ** 3) |
|
|
|
|
| def range_scale(speed_of_sound_used, temperature_c, depth_m, salinity_psu=33.0): |
| """Factor to multiply SOVIS sonar ranges by to correct for the sonar's salinity=0 setting. |
| |
| The Oculus was configured with salinity 0, so it converted echo time to range with a |
| fresh-water sound speed (`sonar_speed_of_sound_mps`, ~1465 m/s). In the fjord the true speed |
| is ~1490-1505 m/s, so true ranges are ~2-3 % longer than the stored rows suggest. |
| """ |
| return seawater_sound_speed(temperature_c, depth_m, salinity_psu) / speed_of_sound_used |
|
|
|
|
| |
| def collate_metric(batch, max_range_m=7.0, bin_m=0.02): |
| """torch DataLoader collate_fn for SOVIS rows decoded with `with_format("numpy")` or PIL. |
| |
| Stacks camera images as uint8 (B, H, W, 3) and sonar as float32 metric grids (B, n_bins, 256) |
| with a validity mask (B, n_bins). |
| """ |
| import torch |
| cams, grids, masks = [], [], [] |
| for row in batch: |
| cams.append(np.asarray(row["camera"])) |
| g, v = to_metric_grid(np.asarray(row["sonar"]), row["sonar_range_resolution_m"], max_range_m, bin_m) |
| grids.append(g); masks.append(v) |
| return {"camera": torch.from_numpy(np.stack(cams)), "sonar": torch.from_numpy(np.stack(grids)), |
| "sonar_valid": torch.from_numpy(np.stack(masks)), |
| "frame_id": [row["frame_id"] for row in batch]} |
|
|
