PPU for 3D Ultrasound Knee Imaging

• PPU is a modular unit that automatically cleans 3D point clouds, removing outliers and mislabeled points from knee ultrasound scans.
• It employs dynamic graph construction with kNN (k=20) to robustly distinguish true bone surfaces from segmentation noise.
• The DG-PPU framework achieved up to 98.2% precision, demonstrating effective real-time cleaning and improved joint tracking.

A Post-Processing Unit (PPU) in the context of medical imaging and point cloud analysis refers to a modular computational block that operates downstream of segmentation and point-cloud extraction, with the explicit goal of automatically removing outliers and mislabeled points without interfering with upstream model outputs. The DG-PPU (Dynamical Graphs-based Post-processing Unit) represents a state-of-the-art instantiation of such a system, developed for the real-time cleaning of 3D point clouds extracted from knee ultrasound scans for robust tracking of patellofemoral joint (PFJ) motion (Hwang et al., 2024).

1. Motivation for Post-Processing Units

Ultrasound-based dynamic musculoskeletal imaging enables real-time visualization of joint kinematics. However, conventional segmentation approaches—such as U-Net architectures applied to 2D ultrasound slices—often over-label soft tissue regions as bone. This segmentation error manifests in reconstructed 3D point clouds as spurious "bone" points, introducing substantial noise. Downstream processes, particularly rigid-registration pipelines relying on ICP (Iterative Closest Point), suffer degraded robustness, propagating significant pose errors in joint tracking. Manual annotation and removal of outliers, while accurate, are not real-time and are impractically labor-intensive for clinical workflows.

A PPU is introduced as an architectural solution that performs automated, real-time, modular cleaning. By learning the intrinsic geometric structure of bony anatomy from representative data, the PPU enables robust discrimination between true bone surface points and mislabeled soft-tissue outliers, slotting seamlessly into existing segmentation-registration pipelines.

2. System Pipeline and Operational Workflow

The DG-PPU system pipeline follows a structured, end-to-end process:

1. Acquisition: 2D ultrasound frames are captured at various knee flexion angles. Training leverages four thorough scans (P0–P3), while sparser partial scans (P1–P3) simulate testing/clinical data.
2. Segmentation: Each frame undergoes semantic segmentation to label "bone" versus "non-bone."
3. 3D Back-projection: Segmented bone pixels are mapped into 3D space using known probe calibration, yielding a dense, but noisy, point cloud.
4. Monte Carlo Subsampling: From each cloud, 500 random subsets of 1,024 points are sampled (with replacement) to create density-preserving mini-batches for deep learning.
5. Dynamic Graph Construction: Each subset is represented as a $k$-NN ($k=20$) Euclidean graph, where nodes are points and edges encode proximity; adjacency matrices are updated at each DGCNN layer to reflect evolving feature representations.
6. DGCNN Training: The network is trained for bone-type classification (assigning femur, patella, or tibia labels) to each point via cross-entropy loss.
7. Inference and Post-processing: Upon receiving a new partial scan, per-point bone labels and neighborhood information are predicted. The PPU’s rule deletes any point whose $k$ neighbors are not unanimously assigned the same bone class—a principle ensuring retention only of geometrically coherent bone surfaces.

3. Graph-Based Algorithmic Framework

DG-PPU formalizes point cloud processing via dynamic graphs and graph convolutions:

• Input representation: Each mini-batch is $X^{(0)}\in\mathbb{R}^{N\times 3}$, corresponding to 3D coordinates.
• Adjacency and normalization: For each batch, the binary adjacency $A$ defines edges; normalization $$\tilde{A} = \hat{D}^{-1/2}\, \hat{A}\, \hat{D}^{-1/2}$$ incorporates self-connections ($\hat{A} = A+I$) and degree matrix $\hat{D}_{ii} = \sum_j \hat{A}_{ij}$. This ensures stability and effective information propagation.
• Dynamic feature propagation: At each DGCNN layer $t$, features update as

$$X^{(t+1)} = \mathrm{ReLU}\bigl(\tilde{A} X^{(t)} W^{(t)}\bigr)$$

with learnable weights $W^{(t)}$ and batch normalization.

• Edge weighting (optional): Gaussian affinities $w_{ij} = \exp(-\|x_i-x_j\|^2/\sigma^2)$ can be applied for additional smoothness regularization, though the baseline implementation remains unweighted for efficiency.
• Bone classification head: After $T$ graph layers ($T=4$ in practice), an MLP outputs per-point class logits.
• Point deletion rule: Definitively, for each $i$, if $\exists\,j\in\mathrm{kNN}(i)$ with $\ell_j \neq \ell_i$, then point $i$ is deleted. This strict agreement criterion robustly removes mislabeled soft-tissue or outlier points.

4. Implementation Architecture and Optimization

DG-PPU is implemented in PyTorch with PyTorch Geometric for scalable and efficient graph-based deep learning:

• Backbone: Four DGCNN blocks, with features [3 → 64 → 64 → 128 → 256], each followed by ReLU and batch normalization.
• Neighborhood selection: $k=20$ guarantees coverage of even minority bone regions (e.g., patella) in all sampled mini-batches (≥96.9% empirical probability).
• Data augmentation: Gaussian jitter and random translation operations are used to double patella point samples and mitigate class imbalance.
• Optimization: Adam (lr=0.001, weight decay $1\times 10^{-4}$), with early stopping based on validation loss (patience of 10 epochs).
• Training regime: ∼2,000 dense scans (P0–P3) for fitting; evaluation on 1,500 partial, clinically realistic scans (P1–P3).

A concise summary of architectural parameters and workflow is provided below:

Stage	Method/Setting	Purpose
Backbone	4-layer DGCNN ([3→64→64→128→256])	Hierarchical representation learning
$k$-NN	$k=20$ neighbors	Robust local geometry and coverage
Data Augment	Jitter, translation (patella boost)	Class balance, invariance
Training	Adam, early stopping	Stable, generalizable optimization

5. Experimental Evaluation and Results

Evaluation of DG-PPU focused on cleaning accuracy relative to manually curated baseline data:

• Dataset: Healthy volunteers’ knees, IRB-approved. Training data from four flexion angles (P0–P3, dense coverage); test data via partial clinical-like scans (P1–P3).
• Manual ground-truth: Point removals in reconstructed 3D clouds compared to technician-marked non-bone regions in 2D inverted ultrasound frames.
• Metrics: Only precision is reported, as no absolute 3D ground truth exists. A "true-positive removal" is one where deletion matches non-bone label in original 2D.
• Performance:
  • P1: 183/186 removals correct (98.4% precision)
  • P2: 194/200 (94.0% precision)
  • P3: 247/249 (99.2% precision)
  • Mean: 98.2% precision
• Recall/F1: Not explicitly reported. By construction, the deletion rule rarely yields false negatives, as points with unanimously agreeing neighbors are retained.
• Qualitative findings: DG-PPU removes inter-cluster strays and delivers smoother bone surfaces than raw clouds; regions deleted were judged equal/superior to manual cleaning.

6. Broader Implications and Applications

DG-PPU exhibits invariance to joint flexion due to its learning of intrinsic bone geometry, enabling effective transfer from full-view to partial, unseen scans. This robustness suggests applicability to other anatomical joints (e.g., ankle, shoulder) sharing rigid bony structures, and potentially generalization to point clouds from alternative imaging modalities such as CT/MRI or depth sensors.

Its modular, "plug-and-play" architecture—analogous to post-processing units in traditional signal-processing—allows seamless integration into existing registration pipelines like CATMAUS. Immediate benefits are observable in increased ICP robustness and potential for broader adoption in automated surgical planning and dynamic joint analysis.

7. Terminology and Conceptual Position

The term "Post-Processing Unit" in DG-PPU reflects its role as a successive operator—cleaning noisy point clouds produced by upstream segmenters without modifying segmentation logic. This design encapsulates the principle of modularity and intervention minimality, distinguishing PPUs from end-to-end, fully-coupled deep learning pipelines. The approach affirms the continued value of explicit, algorithmic post-processing within hybrid computational imaging systems.

DG-PPU is the first automated, real-time post-processing algorithm for 3D ultrasound-derived point clouds of the knee, achieving state-of-the-art false positive removal and setting a precedent for similar systems in musculoskeletal imaging (Hwang et al., 2024).