| """ |
| reconstruct_frames.py - rebuild per-frame point clouds from the SpineDepth raw data. |
| |
| Usage (run from anywhere; paths default to the folder that contains this script): |
| |
| python reconstruct_frames.py # specimen 2 (default) |
| python reconstruct_frames.py --specimen 5 # one specimen |
| python reconstruct_frames.py --specimen all # all ten specimens |
| python reconstruct_frames.py --specimen 3 --workers 8 --out-root D:/somewhere |
| |
| Requirements: Python >= 3.8, numpy, open3d >= 0.15 (pip install -r requirements.txt) |
| Tested on Windows 10 (Python 3.x); uses only os.path, so Linux/macOS work the same. |
| |
| Raw input layout (shipped in ./raw): |
| raw/Specimen_N/STL/L1.stl ... L5.stl |
| raw/Specimen_N/recordings/recordingR/Poses_0.txt, Poses_1.txt |
| raw/Specimen_N/recordings/recordingR/Specimen_N_recording_R_cam_C_frame_F.npz |
| |
| Each npz holds an (M, 7) float64 array: x, y, z, r, g, b, label |
| (label 0 = background, 1..5 = L1..L5; xyz in millimetres, camera space; rgb in [0, 1]). |
| Poses_C.txt has 5 rows per video frame (L1..L5); each row is a flattened 4x4 |
| matrix T (row-major, 16 comma-separated values) with p_camera = T @ p_ct. |
| Frame F of an npz uses pose rows F*5 .. F*5+4. |
| |
| Output layout (written to ./reconstructed by default; every point-cloud file |
| name states its coordinate space): |
| reconstructed/ |
| index.csv all reconstructed specimens |
| Specimen_N/ |
| index.csv this specimen only |
| CT/L1.stl ... L5.stl CT vertebra meshes, each in its own CT space |
| camera_C/recording_RR/frame_F/ |
| frame_camera_space.ply full raw frame, camera space, RGB |
| frame_camera_space_labels.npy int8 label per point of the file above |
| poses_ct_to_camera.txt 5 rows L1..L5, flattened 4x4, p_camera = T @ p_ct |
| L1_camera_space.ply ... L5_camera_space.ply points labelled Lk, camera space, RGB |
| L1_ct_space.ply ... L5_ct_space.ply same points moved into CT space of Lk |
| |
| Nothing is filtered or downsampled; the label column is used as-is. |
| """ |
| import argparse |
| import csv |
| import os |
| import re |
| import shutil |
| import sys |
| from concurrent.futures import ProcessPoolExecutor |
|
|
| import numpy as np |
| import open3d as o3d |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| LEVELS = [1, 2, 3, 4, 5] |
| ALL_SPECIMENS = list(range(1, 11)) |
| FRAME_RE = re.compile(r"Specimen_(\d+)_recording_(\d+)_cam_(\d+)_frame_(\d+)\.npz$") |
| INDEX_HEADER = ["specimen", "camera", "recording", "frame", "level", "num_points_level", |
| "num_points_frame", "camera_space_ply", "ct_space_ply", "ct_mesh"] |
|
|
|
|
| def read_transformation_matrices(file_path): |
| """Each line = 16 comma-separated floats = one 4x4 matrix (row-major).""" |
| matrices = [] |
| with open(file_path, "r") as f: |
| for line in f: |
| line = line.strip() |
| if not line: |
| continue |
| values = list(map(float, line.split(","))) |
| if len(values) != 16: |
| raise ValueError(f"{file_path}: expected 16 values per line, got {len(values)}") |
| matrices.append(np.array(values).reshape(4, 4)) |
| return matrices |
|
|
|
|
| def make_pcd(xyz, rgb=None): |
| pcd = o3d.geometry.PointCloud() |
| pcd.points = o3d.utility.Vector3dVector(xyz) |
| if rgb is not None and len(rgb): |
| pcd.colors = o3d.utility.Vector3dVector(rgb) |
| return pcd |
|
|
|
|
| def process_frame(task): |
| """Worker: convert one npz frame. Returns index rows.""" |
| specimen, cam, rec_idx, frame, npz_path, frame_poses, frame_out, out_root = task |
| os.makedirs(frame_out, exist_ok=True) |
|
|
| data = np.load(npz_path)["arr_0"] |
| if data.ndim != 2 or data.shape[1] < 7: |
| raise ValueError(f"{npz_path}: expected an (N, 7) array [x y z r g b label], got shape {data.shape}") |
| xyz = data[:, :3] |
| rgb = data[:, 3:6] |
| labels = data[:, 6].astype(np.int8) |
|
|
| o3d.io.write_point_cloud(os.path.join(frame_out, "frame_camera_space.ply"), make_pcd(xyz, rgb)) |
| np.save(os.path.join(frame_out, "frame_camera_space_labels.npy"), labels) |
| np.savetxt(os.path.join(frame_out, "poses_ct_to_camera.txt"), |
| np.array([T.reshape(-1) for T in frame_poses]), fmt="%.9f", delimiter=",") |
|
|
| rows = [] |
| for lv, T_ct_to_cam in zip(LEVELS, frame_poses): |
| sel = labels == lv |
| pcd_cam = make_pcd(xyz[sel], rgb[sel]) |
| cam_ply = os.path.join(frame_out, f"L{lv}_camera_space.ply") |
| o3d.io.write_point_cloud(cam_ply, pcd_cam) |
|
|
| pcd_ct = make_pcd(xyz[sel], rgb[sel]) |
| pcd_ct.transform(np.linalg.inv(T_ct_to_cam)) |
| ct_ply = os.path.join(frame_out, f"L{lv}_ct_space.ply") |
| o3d.io.write_point_cloud(ct_ply, pcd_ct) |
|
|
| rows.append([specimen, cam, rec_idx, frame, lv, int(sel.sum()), len(xyz), |
| os.path.relpath(cam_ply, out_root).replace(os.sep, "/"), |
| os.path.relpath(ct_ply, out_root).replace(os.sep, "/"), |
| f"Specimen_{specimen}/CT/L{lv}.stl"]) |
| return rows |
|
|
|
|
| def build_tasks(raw_root, out_root, specimen): |
| spec_in = os.path.join(raw_root, f"Specimen_{specimen}") |
| spec_out = os.path.join(out_root, f"Specimen_{specimen}") |
| rec_dir = os.path.join(spec_in, "recordings") |
| if not os.path.isdir(rec_dir): |
| print(f"[skip] {spec_in}: no recordings folder") |
| return [] |
|
|
| ct_out = os.path.join(spec_out, "CT") |
| os.makedirs(ct_out, exist_ok=True) |
| for lv in LEVELS: |
| shutil.copy2(os.path.join(spec_in, "STL", f"L{lv}.stl"), os.path.join(ct_out, f"L{lv}.stl")) |
|
|
| tasks = [] |
| recordings = sorted((d for d in os.listdir(rec_dir) if d.startswith("recording")), |
| key=lambda d: int(d[len("recording"):])) |
| for rec_name in recordings: |
| rec_path = os.path.join(rec_dir, rec_name) |
| rec_idx = int(rec_name[len("recording"):]) |
| frame_files = sorted(f for f in os.listdir(rec_path) if FRAME_RE.match(f)) |
| if not frame_files: |
| continue |
| poses = {} |
| for f in frame_files: |
| m = FRAME_RE.match(f) |
| cam, frame = int(m.group(3)), int(m.group(4)) |
| if cam not in poses: |
| poses[cam] = read_transformation_matrices(os.path.join(rec_path, f"Poses_{cam}.txt")) |
| first = frame * 5 |
| if first + 5 > len(poses[cam]): |
| print(f"[warn] {f}: pose rows {first}..{first + 4} missing, frame skipped") |
| continue |
| frame_poses = poses[cam][first:first + 5] |
| frame_out = os.path.join(spec_out, f"camera_{cam}", f"recording_{rec_idx:02d}", f"frame_{frame}") |
| tasks.append((specimen, cam, rec_idx, frame, os.path.join(rec_path, f), frame_poses, frame_out, out_root)) |
| return tasks |
|
|
|
|
| def write_index(path, rows): |
| with open(path, "w", newline="") as fh: |
| w = csv.writer(fh) |
| w.writerow(INDEX_HEADER) |
| w.writerows(rows) |
|
|
|
|
| def parse_specimen(value): |
| if value.lower() == "all": |
| return ALL_SPECIMENS |
| try: |
| s = int(value) |
| except ValueError: |
| raise argparse.ArgumentTypeError(f"--specimen must be 'all' or an integer 1..10, got {value!r}") |
| if s not in ALL_SPECIMENS: |
| raise argparse.ArgumentTypeError(f"--specimen must be 'all' or an integer 1..10, got {s}") |
| return [s] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--specimen", type=parse_specimen, default="2", |
| help="'all' or a specimen index 1..10 (default: 2)") |
| ap.add_argument("--raw-root", default=os.path.join(HERE, "raw"), help="folder with Specimen_N/ raw data") |
| ap.add_argument("--out-root", default=os.path.join(HERE, "reconstructed"), help="output folder") |
| ap.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) // 2), |
| help="parallel worker processes (default: half the CPU cores)") |
| args = ap.parse_args() |
| specimens = args.specimen if isinstance(args.specimen, list) else parse_specimen(args.specimen) |
|
|
| if not os.path.isdir(args.raw_root): |
| sys.exit(f"raw root not found: {args.raw_root}") |
| os.makedirs(args.out_root, exist_ok=True) |
| print(f"raw: {args.raw_root}\nout: {args.out_root}\nspecimens: {specimens}\nworkers: {args.workers}", flush=True) |
|
|
| with ProcessPoolExecutor(max_workers=args.workers) as pool: |
| for s in specimens: |
| tasks = build_tasks(args.raw_root, args.out_root, s) |
| if not tasks: |
| continue |
| rows = [] |
| for i, r in enumerate(pool.map(process_frame, tasks, chunksize=2), 1): |
| rows += r |
| if i % 40 == 0 or i == len(tasks): |
| print(f"Specimen_{s}: {i}/{len(tasks)} frames", flush=True) |
| rows.sort(key=lambda r: r[:5]) |
| write_index(os.path.join(args.out_root, f"Specimen_{s}", "index.csv"), rows) |
| print(f"Specimen_{s}: wrote {len(rows)} vertebra clouds", flush=True) |
|
|
| |
| all_rows = [] |
| for d in sorted(os.listdir(args.out_root), |
| key=lambda d: int(d.split("_")[1]) if d.startswith("Specimen_") else -1): |
| p = os.path.join(args.out_root, d, "index.csv") |
| if d.startswith("Specimen_") and os.path.isfile(p): |
| with open(p, newline="") as fh: |
| all_rows += list(csv.reader(fh))[1:] |
| write_index(os.path.join(args.out_root, "index.csv"), all_rows) |
| print(f"Done: root index has {len(all_rows)} vertebra clouds.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
