Synthetic Data for Automated Patient Positioning

# Illustrative sketch (not from the paper)
import numpy as np
import torch
from skimage import measure
from sklearn.cluster import DBSCAN
# 1. Load CT volume (HU) and apply Marching Cubes with threshold -500 HU
ct_volume = np.load('ct.npy')  # placeholder
verts, faces, _, _ = measure.marching_cubes(ct_volume, level=-500)
# 2. Transform to patient frame and crop to upper‑ankle region (placeholder function)
pts_patient = transform_to_patient_coords(verts)
pts_ankle = crop_to_ankle(pts_patient)
# 3. Remove table and non‑surface points using DBSCAN clustering
clustering = DBSCAN(eps=2.0, min_samples=10).fit(pts_ankle)
mask = clustering.labels_ == clustering.labels_.max()  # keep largest cluster
pts_surface = pts_ankle[mask]
# 4. Compute normals (simple nearest‑neighbor estimate) and augment shape
normals = estimate_normals(pts_surface)
shift = 1.0  # mm, illustrative
pts_out = pts_surface + shift * normals  # outward shift
pts_in  = pts_surface - shift * normals  # inward shift
# 5. Place anatomy on pre‑recorded table point cloud and rotate
table_pts = np.load('table.npy')
pose_angle = torch.tensor([0.0], requires_grad=True)  # rotation about longitudinal axis
# 6. Matching step: align anatomy plane Π_P with table plane Π_T (placeholder)
T_mat = compute_alignment(pts_out, table_pts)
# 7. Optimization to keep anatomy realistic on table (simple gradient descent)
optimizer = torch.optim.Adam([pose_angle], lr=0.01)
for _ in range(100):
    optimizer.zero_grad()
    rotated = rotate_about_axis(pts_out, pose_angle)
    loss = realism_loss(rotated, table_pts)  # placeholder loss
    loss.backward()
    optimizer.step()
# 8. Project combined point clouds to depth image using camera intrinsics (placeholder)
depth_img = project_to_depth(rotated, table_pts, intrinsics, extrinsics)
# 9. Generate synthetic radiograph via Monte‑Carlo (MCGPU) – external tool call
#    simulate 2·10^10 X‑ray beam paths using MCGPU and PENELOPE material files
# 10. Apply non‑linear mapping to MC output to obtain final radiograph (placeholder)
radiograph = nonlinear_mapping(mc_output)

// Illustrative sketch (not from the paper)
const fs = require('fs');
const { MarchingCubes } = require('marching-cubes'); // hypothetical lib
const DBSCAN = require('density-clustering').DBSCAN;
// 1. Load CT volume (HU) and extract surface with threshold -500 HU
let ctVolume = JSON.parse(fs.readFileSync('ct.json'));
let { vertices } = MarchingCubes(ctVolume, { level: -500 });
// 2. Transform to patient coordinates and crop to ankle (placeholder)
let ptsPatient = transformToPatient(vertices);
let ptsAnkle = cropAnkle(ptsPatient);
// 3. Remove table and non‑surface points via DBSCAN clustering
let dbscan = new DBSCAN();
let clusters = dbscan.run(ptsAnkle, 2.0, 10);
let largest = clusters.reduce((a,b) => (a.length>b.length?a:b));
let ptsSurface = largest.map(i => ptsAnkle[i]);
// 4. Estimate normals and create augmented point clouds
let normals = estimateNormals(ptsSurface);
let shift = 1.0; // mm, illustrative
let ptsOut = ptsSurface.map((p,i) => p.map((c,j) => c + shift*normals[i][j]));
let ptsIn  = ptsSurface.map((p,i) => p.map((c,j) => c - shift*normals[i][j]));
// 5. Load table point cloud and place anatomy
let tablePts = JSON.parse(fs.readFileSync('table.json'));
let poseAngle = 0.0; // radians, will be optimized
// 6. Align anatomy plane Π_P with table plane Π_T (placeholder)
let Tmat = computeAlignment(ptsOut, tablePts);
// 7. Simple optimization loop to keep realistic placement
for (let iter=0; iter<100; iter++) {
  let rotated = rotateAboutAxis(ptsOut, poseAngle);
  let loss = realismLoss(rotated, tablePts); // placeholder
  // gradient descent step (mock gradient = loss * 0.01)
  poseAngle -= 0.01 * loss;
}
// 8. Project combined clouds to depth image using camera intrinsics (placeholder)
let depthImg = projectToDepth(rotated, tablePts, intrinsics, extrinsics);
// 9. Call external MCGPU tool for Monte‑Carlo radiograph (2·10^10 paths)
//    command line: mcgpu -i combined.ply -o mc_raw.npy --paths 2e10 --materials penelope.cfg
// 10. Apply non‑linear mapping to MC output to obtain final radiograph
let radiograph = nonlinearMapping(mcRaw);