| |
| |
| """ |
| UE4-Stereo -- example loader. |
| |
| Reads one sequence and shows how to work with each of its components: the |
| stereo pair, the metric depth map, the ground-truth trajectory and the camera |
| parameters. Run it from anywhere, passing the path to a sequence directory: |
| |
| python load_sequence.py --sequence path/to/scene_1/sequence01 |
| python load_sequence.py --sequence . --show 0 # from inside one |
| |
| Pass --baseline 0.32 for sequences 05 and 06, which use the wider rig. |
| See README.md for the camera model and the reference-frame conventions. |
| |
| Requires numpy and opencv-python; matplotlib only for --show. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
|
|
| import cv2 |
| import numpy as np |
|
|
| |
| IMAGE_WIDTH = 640 |
| IMAGE_HEIGHT = 480 |
| HFOV_DEG = 90.0 |
|
|
| FX = FY = (IMAGE_WIDTH / 2.0) / np.tan(np.radians(HFOV_DEG) / 2.0) |
| CX, CY = IMAGE_WIDTH / 2.0, IMAGE_HEIGHT / 2.0 |
|
|
| |
| CAMERA_FORWARD_M = 1.00 |
| CAMERA_DOWN_M = 0.10 |
| CAMERA_PITCH_DEG = -23.0 |
|
|
|
|
| def intrinsic_matrix() -> np.ndarray: |
| return np.array([[FX, 0.0, CX], |
| [0.0, FY, CY], |
| [0.0, 0.0, 1.0]], dtype=np.float64) |
|
|
|
|
| def read_associations(path: str) -> list[tuple[str, str, str, str]]: |
| """Parse an associate_*.txt file, skipping the comment header.""" |
| rows = [] |
| with open(path, encoding="utf-8") as fh: |
| for line in fh: |
| line = line.strip() |
| if not line or line.startswith("#"): |
| continue |
| parts = line.split() |
| if len(parts) == 4: |
| rows.append(tuple(parts)) |
| return rows |
|
|
|
|
| def read_trajectory(path: str) -> np.ndarray: |
| return np.loadtxt(path) |
|
|
|
|
| def load_frame(sequence: str, index: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]: |
|
|
| stereo = read_associations(os.path.join(sequence, "associate_rgb.txt")) |
| rgbd = read_associations(os.path.join(sequence, "associate_rgbd.txt")) |
|
|
| _, rel_left, _, rel_right = stereo[index] |
| _, _, _, rel_depth = rgbd[index] |
|
|
| left = cv2.imread(os.path.join(sequence, rel_left), cv2.IMREAD_COLOR) |
| right = cv2.imread(os.path.join(sequence, rel_right), cv2.IMREAD_COLOR) |
| depth = np.load(os.path.join(sequence, rel_depth)) |
| return left, right, depth |
|
|
|
|
| def depth_to_disparity(depth_m: np.ndarray, baseline_m: float) -> np.ndarray: |
| disparity = np.zeros_like(depth_m, dtype=np.float32) |
| valid = depth_m > 0.0 |
| disparity[valid] = (FX * baseline_m) / depth_m[valid] |
| return disparity |
|
|
|
|
| def summarize(sequence: str, baseline_m: float) -> None: |
| stereo = read_associations(os.path.join(sequence, "associate_rgb.txt")) |
| traj = read_trajectory(os.path.join(sequence, "groundtruth.txt")) |
| _, _, depth = load_frame(sequence, 0) |
| valid = depth > 0.0 |
|
|
| duration = traj[-1, 0] - traj[0, 0] |
| distance = np.linalg.norm(np.diff(traj[:, 1:4], axis=0), axis=1).sum() |
|
|
| print(f"Sequence: {sequence}") |
| print(f"Stereo pairs: {len(stereo)}") |
| print(f"Poses: {len(traj)}") |
| print(f"Duration: {duration:.1f} s ({len(traj) / duration:.2f} Hz)") |
| print(f"Path length: {distance:.1f} m") |
| print(f"Altitude: {-traj[:, 3].mean():.2f} m above spawn (mean)") |
| print(f"Image size: {IMAGE_WIDTH} x {IMAGE_HEIGHT}") |
| print(f"fx = fy: {FX:.1f} px cx, cy = {CX:.1f}, {CY:.1f} px") |
| print(f"Baseline: {baseline_m:.2f} m fx*B = {FX * baseline_m:.1f} m.px") |
| print(f"Depth (frame 0): {depth[valid].min():.2f} to {depth[valid].max():.2f} m, " |
| f"{100 * valid.mean():.1f}% valid") |
|
|
|
|
| def show_frame(sequence: str, index: int, baseline_m: float) -> None: |
| import matplotlib.pyplot as plt |
|
|
| left, right, depth = load_frame(sequence, index) |
| disparity = depth_to_disparity(depth, baseline_m) |
|
|
| fig, axes = plt.subplots(2, 2, figsize=(11, 7)) |
| for ax, img, title in ( |
| (axes[0, 0], cv2.cvtColor(left, cv2.COLOR_BGR2RGB), "left"), |
| (axes[0, 1], cv2.cvtColor(right, cv2.COLOR_BGR2RGB), "right"), |
| ): |
| ax.imshow(img) |
| ax.set_title(title) |
| ax.axis("off") |
|
|
| im = axes[1, 0].imshow(np.where(depth > 0, depth, np.nan), cmap="viridis") |
| axes[1, 0].set_title("depth [m]") |
| axes[1, 0].axis("off") |
| fig.colorbar(im, ax=axes[1, 0], fraction=0.046) |
|
|
| im = axes[1, 1].imshow(np.where(disparity > 0, disparity, np.nan), cmap="magma") |
| axes[1, 1].set_title(f"disparity [px], B = {baseline_m:.2f} m") |
| axes[1, 1].axis("off") |
| fig.colorbar(im, ax=axes[1, 1], fraction=0.046) |
|
|
| fig.suptitle(f"{sequence} -- frame {index}") |
| fig.tight_layout() |
| plt.show() |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--sequence", required=True, |
| help="path to a sequence directory, e.g. scene_1/sequence01") |
| ap.add_argument("--baseline", type=float, default=0.24, |
| help="stereo baseline of this sequence in metres (default: 0.24)") |
| ap.add_argument("--show", type=int, metavar="N", |
| help="display frame N instead of only printing a summary") |
| args = ap.parse_args() |
|
|
| summarize(args.sequence, args.baseline) |
| if args.show is not None: |
| show_frame(args.sequence, args.show, args.baseline) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
