File size: 9,768 Bytes
642910b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 | """
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)
# Root index = union of every per-specimen index present on disk.
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()
|