PointDSC

https://github.com/xuyangbai/pointdsc
Admin
PointDSC is a deep learning method for robust point cloud registration that uses deep spatial...
Tokens:9,681
Snippets:69
Trust Score:8.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Train PointDSC on 3DMatch

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Run this command to start training the PointDSC model on the 3DMatch dataset. Training configurations can be modified in config.py.

```bash
python train_3dmatch.py
```

--------------------------------

### 3DMatch Dataset Structure

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Example directory structure for the 3DMatch dataset, including fragments, ground truth results, and pre-computed descriptors.

```text
.                          
├── fragments                 
│   ├── 7-scene-redkitechen/       
│   ├── sun3d-home_at-home_at_scan1_2013_jan_1/      
│   └── ...                
├── gt_result                   
│   ├── 7-scene-redkitechen-evaluation/   
│   ├── sun3d-home_at-home_at_scan1_2013_jan_1-evaluation/
│   └── ...         
├── threedmatch            
│   ├── *.npz
│   └── *.txt                            

```

--------------------------------

### Install PointDSC with Conda

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Configure PointDSC environment using Conda. This involves creating a new environment from a specified file and activating it.

```bash
conda env create -f environment.yml
conda activate pointdsc
```

--------------------------------

### Configure Evaluation Metrics and Train Model

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Sets up the loss functions and weights for training, then initializes and runs the trainer.

```python
config.evaluate_metric = {
    "ClassificationLoss": ClassificationLoss(balanced=config.balanced),
    "SpectralMatchingLoss": SpectralMatchingLoss(balanced=config.balanced),
    "TransformationLoss": TransformationLoss(re_thre=config.re_thre, te_thre=config.te_thre),
}
config.metric_weight = {
    "ClassificationLoss": config.weight_classification,    # 1.0
    "SpectralMatchingLoss": config.weight_spectralmatching, # 1.0
    "TransformationLoss": config.weight_transformation,     # 0.0
}

# Train the model
trainer = Trainer(config)
trainer.train()  # Runs for max_epoch (50) epochs, saves best model
```

--------------------------------

### Execute PointDSC Command Line Interface

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Run registration demos, training scripts, and evaluation benchmarks using the CLI.

```bash
# Demo: Register two point clouds
python demo_registration.py \
    --chosen_snapshot PointDSC_3DMatch_release \
    --pcd1 demo_data/cloud_bin_0.ply \
    --pcd2 demo_data/cloud_bin_1.ply \
    --descriptor fpfh \
    --use_gpu True

# For outdoor LiDAR data, use the KITTI model
python demo_registration.py \
    --chosen_snapshot PointDSC_KITTI_release \
    --descriptor fcgf \
    --use_gpu True

# Training on 3DMatch dataset
python train_3DMatch.py \
    --root /data/3DMatch \
    --descriptor fcgf \
    --num_layers 12 \
    --num_channels 128 \
    --batch_size 16 \
    --max_epoch 50 \
    --lr 1e-4

# Training on KITTI dataset
python train_KITTI.py \
    --root /data/KITTI \
    --descriptor fcgf \
    --inlier_threshold 0.6 \
    --sigma_d 1.2

# Evaluation on 3DMatch test set
python evaluation/test_3DMatch.py \
    --chosen_snapshot PointDSC_3DMatch_release \
    --solver SVD \
    --use_icp False \
    --save_npy True

# Evaluation with RANSAC solver and ICP refinement
python evaluation/test_3DMatch.py \
    --chosen_snapshot PointDSC_3DMatch_release \
    --solver RANSAC \
    --use_icp True

# Evaluation on KITTI test set
python evaluation/test_KITTI.py \
    --chosen_snapshot PointDSC_KITTI_release \
    --solver SVD \
    --use_icp False

# Evaluation on 3DLoMatch benchmark
python evaluation/test_3DLoMatch.py \
    --chosen_snapshot PointDSC_3DMatch_release \
    --descriptor fcgf \
    --num_points 5000
```

--------------------------------

### Configure and Initialize PointDSC Training

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Sets up the training environment, model architecture, optimizer, and data loaders for the 3DMatch dataset.

```python
import os
import json
import torch
from torch import optim
from easydict import EasyDict as edict
from config import get_config
from libs.loss import TransformationLoss, ClassificationLoss, SpectralMatchingLoss
from datasets.ThreeDMatch import ThreeDMatchTrainVal
from datasets.dataloader import get_dataloader
from libs.trainer import Trainer
from models.PointDSC import PointDSC

# Get configuration from command line arguments
config = get_config()
config = edict(vars(config))

# Create output directories
os.makedirs(config.snapshot_dir, exist_ok=True)
os.makedirs(config.tboard_dir, exist_ok=True)
os.makedirs(config.save_dir, exist_ok=True)

# Save configuration
json.dump(config, open(os.path.join(config.snapshot_dir, 'config.json'), 'w'), indent=4)

# Initialize the model
config.model = PointDSC(
    in_dim=config.in_dim,         # 6 for 3DMatch
    num_layers=config.num_layers, # 12 layers
    num_channels=config.num_channels,  # 128 channels
    num_iterations=config.num_iterations,  # 10 iterations
    inlier_threshold=config.inlier_threshold,  # 0.10m for 3DMatch
    sigma_d=config.sigma_d,       # 0.10
    ratio=config.ratio,           # 0.1
    k=config.k,                   # 40
)

# Setup optimizer with Adam
config.optimizer = optim.Adam(
    config.model.parameters(),
    lr=config.lr,                 # 1e-4
    betas=(0.9, 0.999),
    weight_decay=config.weight_decay,  # 1e-6
)

# Learning rate scheduler with exponential decay
config.scheduler = optim.lr_scheduler.ExponentialLR(
    config.optimizer,
    gamma=config.scheduler_gamma,  # 0.99
)

# Create training dataset with data augmentation
train_set = ThreeDMatchTrainVal(
    root=config.root,             # '/data/3DMatch'
    split='train',
    descriptor=config.descriptor,  # 'fcgf' or 'fpfh'
    in_dim=config.in_dim,
    inlier_threshold=config.inlier_threshold,
    num_node=config.num_node,     # 1000 correspondences per pair
    use_mutual=config.use_mutual,
    downsample=config.downsample, # 0.03m
    augment_axis=config.augment_axis,         # 3 (xyz rotation)
    augment_rotation=config.augment_rotation, # 1.0 (full rotation)
    augment_translation=config.augment_translation,  # 0.5m
)

# Create validation dataset
val_set = ThreeDMatchTrainVal(
    root=config.root,
    split='val',
    descriptor=config.descriptor,
    in_dim=config.in_dim,
    inlier_threshold=config.inlier_threshold,
    num_node=config.num_node,
    use_mutual=config.use_mutual,
    downsample=config.downsample,
    augment_axis=config.augment_axis,
    augment_rotation=config.augment_rotation,
    augment_translation=config.augment_translation,
)

# Create data loaders
config.train_loader = get_dataloader(train_set, batch_size=config.batch_size, num_workers=config.num_workers)
config.val_loader = get_dataloader(val_set, batch_size=config.batch_size, num_workers=config.num_workers)
```

--------------------------------

### Run PointDSC Demo for Registration

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Execute the demo script for point cloud registration. Specify the chosen snapshot (pretrained model) and the descriptor type (FCGF or FPFH).

```bash
python demo_registration.py --chosen_snapshot [PointDSC_3DMatch_release/PointDSC_KITTI_release] --descriptor [fcgf/fpfh]
```

--------------------------------

### Initialize and Run PointDSC Model

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Initializes the PointDSC model with specified configuration parameters, moves it to the GPU, and performs a forward pass with sample data. Ensure input data is prepared correctly, and the model is set to evaluation mode for testing.

```python
import torch
from models.PointDSC import PointDSC

# Initialize the PointDSC model with configuration parameters
model = PointDSC(
    in_dim=6,              # Input dimension (6 for concatenated src+tgt coordinates)
    num_layers=12,         # Number of nonlocal layers
    num_channels=128,      # Feature channels
    num_iterations=10,     # Power iteration steps for spectral matching
    ratio=0.1,             # Maximum ratio of seeding points
    inlier_threshold=0.10, # Inlier distance threshold (meters)
    sigma_d=0.10,          # Spatial consistency sigma
    k=40,                  # Neighborhood size in NSM module
    nms_radius=0.10,       # NMS radius for seed selection (testing only)
)

# Move to GPU and set to evaluation mode
device = torch.device('cuda')
model = model.to(device)
model.eval()

# Prepare input data dictionary
# corr_pos: concatenated source and target keypoint coordinates [bs, num_corr, 6]
# src_keypts: source keypoints [bs, num_corr, 3]
# tgt_keypts: target keypoints [bs, num_corr, 3]
data = {
    'corr_pos': torch.randn(1, 1000, 6).to(device),     # Correspondence positions
    'src_keypts': torch.randn(1, 1000, 3).to(device),   # Source keypoints
    'tgt_keypts': torch.randn(1, 1000, 3).to(device),   # Target keypoints
    'testing': True,  # Enable test mode for NMS seed selection and post-refinement
}

# Forward pass
with torch.no_grad():
    result = model(data)

# Output dictionary contains:
# - final_trans: [bs, 4, 4] predicted SE3 transformation matrix
# - final_labels: [bs, num_corr] inlier/outlier predictions (0 or 1)
# - M: [bs, num_corr, num_corr] feature similarity matrix (None during testing)
pred_transformation = result['final_trans']  # Shape: [1, 4, 4]
pred_inlier_labels = result['final_labels']  # Shape: [1, 1000]

print(f"Predicted transformation:\n{pred_transformation[0].cpu().numpy()}")
print(f"Number of predicted inliers: {(pred_inlier_labels > 0).sum().item()}")
```

--------------------------------

### Perform Multiway Registration

Source: https://github.com/xuyangbai/pointdsc/blob/master/multiway/README.md

Executes the multiway registration process using a specified snapshot. The combined point cloud is then saved and visualized.

```bash
python multiway/test_multi_ate.py --chosen_snapshot [snapshot]
```

--------------------------------

### Train PointDSC on KITTI

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Run this command to begin training the PointDSC model on the KITTI dataset.

```bash
python train_KITTI.py
```

--------------------------------

### Generate and Apply 3D Transformations

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Demonstrates creating rotation and translation matrices, integrating them into SE(3) transformations, and applying these transformations to point clouds. Supports both NumPy arrays and PyTorch tensors.

```python
R = rotation_matrix(num_axis=3, augment_rotation=1.0)
print(f"Random rotation matrix:\n{R}")

t = translation_matrix(augment_translation=0.5)
print(f"Random translation (m): {t.flatten()}")

trans = integrate_trans(R, t)
print(f"SE3 transformation matrix:\n{trans}")

R_recovered, t_recovered = decompose_trans(trans)

pts = np.random.randn(100, 3)
transformed_pts = transform(pts, trans)
print(f"Original points shape: {pts.shape}")
print(f"Transformed points shape: {transformed_pts.shape}")

batch_pts = torch.randn(4, 100, 3)
batch_trans = torch.eye(4).unsqueeze(0).repeat(4, 1, 1)
batch_trans[:, :3, :3] = torch.from_numpy(R).float()
batch_trans[:, :3, 3:4] = torch.from_numpy(t).float()
batch_transformed = transform(batch_pts, batch_trans)

trans1 = integrate_trans(rotation_matrix(3, 0.5), translation_matrix(0.3))
trans2 = integrate_trans(rotation_matrix(3, 0.5), translation_matrix(0.3))
combined_trans = concatenate(trans1, trans2)
print(f"Combined transformation:\n{combined_trans}")
```

--------------------------------

### SE3 Transformation Utilities

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Imports utility functions for handling rigid transformations.

```python
import torch
import numpy as np
from utils.SE3 import (
    rotation_matrix,
    translation_matrix,
    transform,
    decompose_trans,
    integrate_trans,
    concatenate
)

# Generate random rotation matrix
# num_axis: 0 (identity), 1 (single axis), 3 (all axes)
```

--------------------------------

### Create Point Cloud Fragments

Source: https://github.com/xuyangbai/pointdsc/blob/master/multiway/README.md

Use this script to generate point cloud fragments from RGB-D sequences. The generated ply files are saved in a 'fragments' directory.

```bash
python multiway/make_fragments.py redwood_simulated/livingroom1-simulated.json
```

--------------------------------

### Precomputed 3DMatch Descriptors

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Link to download pre-computed descriptors for the 3DMatch test set, useful for reducing training time.

```link
https://drive.google.com/file/d/1zuf6NSD3-dHtTpk34iHtxAf8DQx3Y7RH/view?usp=sharing
```

--------------------------------

### Test PointDSC on KITTI

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Execute this command to test the PointDSC model on the KITTI dataset. Replace `[exp_id]` with the snapshot folder name.

```bash
python evaluation/test_KITTI.py --chosen_snapshot [exp_id] --use_icp False
```

--------------------------------

### Extract Point Cloud Features

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Load a point cloud and extract FPFH features for registration.

```python
pcd = o3d.io.read_point_cloud('demo_data/cloud_bin_0.ply')
keypts, features = extract_fpfh(pcd, downsample=0.03)
print(f"Extracted {len(keypts)} keypoints with {features.shape[1]}-dim features")
```

--------------------------------

### PointDSC Pretrained Model (KITTI)

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Path to the pre-trained PointDSC model for KITTI dataset.

```path
snapshot/PointDSC_KITTI_release
```

--------------------------------

### Test PointDSC on 3DMatch

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Execute this command to test the PointDSC model on the 3DMatch dataset. Replace `[exp_id]` with the snapshot folder name. Testing results are saved in `logs/`.

```bash
python evaluation/test_3DMatch.py --chosen_snapshot [exp_id] --use_icp False
```

--------------------------------

### 3DMatch Training/Validation Dataset Configuration

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Configures the 3DMatch training and validation dataset. Specify root directory, split, descriptor type, input dimensions, inlier threshold, number of nodes, matching strategy, downsampling, and augmentation parameters.

```python
from datasets.ThreeDMatch import ThreeDMatchTrainVal
from datasets.dataloader import get_dataloader

# 3DMatch Training/Validation Dataset
train_dataset = ThreeDMatchTrainVal(
    root='/data/3DMatch',
    split='train',             # 'train' or 'val'
    descriptor='fcgf',         # 'fcgf' or 'fpfh'
    in_dim=6,                  # Input dimension (6 = src_xyz + tgt_xyz)
    inlier_threshold=0.10,     # Inlier distance threshold (meters)
    num_node=1000,             # Number of correspondences per sample (or 'all')
    use_mutual=False,          # Use mutual nearest neighbor matching
    downsample=0.03,           # Voxel downsampling size (meters)
    augment_axis=3,            # Rotation augmentation axes (0, 1, or 3)
    augment_rotation=1.0,      # Rotation range (fraction of 2*pi)
    augment_translation=0.5,   # Translation range (meters)
)

# Create dataloader with batching
train_loader = get_dataloader(
    dataset=train_dataset,
    batch_size=16,
    num_workers=16,
    shuffle=True,  # Shuffle for training
)

# Iterate through batches
for corr_pos, src_keypts, tgt_keypts, gt_trans, gt_labels in train_loader:
    # corr_pos: [bs, num_corr, 6] correspondence positions
    # src_keypts: [bs, num_corr, 3] source keypoints
    # tgt_keypts: [bs, num_corr, 3] target keypoints
    # gt_trans: [bs, 4, 4] ground truth transformation
    # gt_labels: [bs, num_corr] ground truth inlier labels (0 or 1)
    print(f"Batch shapes: corr={corr_pos.shape}, trans={gt_trans.shape}")
    break
```

--------------------------------

### Test 3DMatch Outlier Rejection Baselines

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Use this script to evaluate traditional outlier rejection baselines on the 3DMatch dataset.

```bash
python baseline_scripts/baseline_3DMatch.py
```

--------------------------------

### PointDSC Pretrained Model (3DMatch)

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Path to the pre-trained PointDSC model for 3DMatch dataset.

```path
snapshot/PointDSC_3DMatch_release
```

--------------------------------

### 3DLoMatch Test Dataset Configuration

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Configures the 3DLoMatch test dataset for low overlap benchmark evaluation. Specify root, descriptor, input dimensions, inlier threshold, and the number of correspondences.

```python
from datasets.ThreeDMatch import ThreeDLOMatchTest

# 3DLoMatch Dataset (low overlap benchmark)
lomatch_dataset = ThreeDLOMatchTest(
    root='/data/3DMatch',
    descriptor='fcgf',
    in_dim=6,
    inlier_threshold=0.10,
    num_node=5000,
    use_mutual=False,
)
print(f"3DLoMatch test set size: {len(lomatch_dataset)} pairs")
```

--------------------------------

### Compute FCGF Descriptors

Source: https://github.com/xuyangbai/pointdsc/blob/master/multiway/README.md

Computes FCGF local descriptors. Requires downloading a pre-trained weight file.

```bash
# python misc/cal_fcgf.py
```

--------------------------------

### Test PointDSC on 3DLoMatch

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Evaluate the PointDSC method on the 3DLoMatch benchmark. Specify the snapshot ID, descriptor type, and number of points. Feature extraction for the 'predator' descriptor requires following the OverlapPredator instructions.

```bash
python evaluation/test_3DLoMatch.py --chosen_snapshot [exp_id] --descriptor [fcgf/predator] --num_points 5000
```

--------------------------------

### Extract FCGF Descriptors

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Use this script to pre-compute FCGF descriptors for point clouds, which can reduce training time by allowing direct input correspondence using NN search.

```python
misc/cal_fcgf.py
```

--------------------------------

### Extract FPFH Descriptors

Source: https://github.com/xuyangbai/pointdsc/blob/master/README.md

Use this script to pre-compute FPFH descriptors for point clouds, which can reduce training time by allowing direct input correspondence using NN search.

```python
misc/cal_fpfh.py
```

--------------------------------

### Evaluate PointDSC on 3DMatch

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Loads a pre-trained model and evaluates it across multiple test scenes using registration recall and error metrics.

```python
import json
import logging
import sys
import torch
import numpy as np
from tqdm import tqdm
from easydict import EasyDict as edict
from models.PointDSC import PointDSC
from libs.loss import TransformationLoss, ClassificationLoss
from datasets.ThreeDMatch import ThreeDMatchTest
from datasets.dataloader import get_dataloader
from evaluation.benchmark_utils import set_seed, icp_refine

set_seed(51)  # For reproducibility

# Setup logging
chosen_snapshot = 'PointDSC_3DMatch_release'
logging.basicConfig(level=logging.INFO, filename=f'logs/{chosen_snapshot}.log', filemode='a', format="")
logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))

# Load configuration
config = json.load(open(f'snapshot/{chosen_snapshot}/config.json', 'r'))
config = edict(config)

# Load model
model = PointDSC(
    in_dim=config.in_dim,
    num_layers=config.num_layers,
    num_channels=config.num_channels,
    num_iterations=config.num_iterations,
    ratio=config.ratio,
    sigma_d=config.sigma_d,
    k=config.k,
    nms_radius=config.inlier_threshold,
)
model.load_state_dict(torch.load(f'snapshot/{chosen_snapshot}/models/model_best.pkl'))
model.eval().cuda()

# Evaluate on each test scene
scene_list = [
    '7-scenes-redkitchen',
    'sun3d-home_at-home_at_scan1_2013_jan_1',
    'sun3d-home_md-home_md_scan9_2012_sep_30',
    'sun3d-hotel_uc-scan3',
    'sun3d-hotel_umd-maryland_hotel1',
    'sun3d-hotel_umd-maryland_hotel3',
    'sun3d-mit_76_studyroom-76-1studyroom2',
    'sun3d-mit_lab_hj-lab_hj_tea_nov_2_2012_scan1_erika'
]

all_stats = {}
evaluate_metric = TransformationLoss(re_thre=config.re_thre, te_thre=config.te_thre)

for scene in scene_list:
    dset = ThreeDMatchTest(
        root='/data/3DMatch',
        descriptor=config.descriptor,
        in_dim=config.in_dim,
        inlier_threshold=config.inlier_threshold,
        num_node='all',  # Use all correspondences for testing
        use_mutual=config.use_mutual,
        augment_axis=0,
        augment_rotation=0.0,
        augment_translation=0.0,
        select_scene=scene,
    )
    dloader = get_dataloader(dset, batch_size=1, num_workers=16, shuffle=False)

    num_pair = len(dset)
    stats = np.zeros([num_pair, 12])

    with torch.no_grad():
        for i, (corr, src_keypts, tgt_keypts, gt_trans, gt_labels) in enumerate(tqdm(dloader)):
            data = {
                'corr_pos': corr.cuda(),
                'src_keypts': src_keypts.cuda(),
                'tgt_keypts': tgt_keypts.cuda(),
                'testing': True,
            }

            result = model(data)
            pred_trans = result['final_trans']
            pred_labels = result['final_labels']

            # Optionally apply ICP refinement
            # pred_trans = icp_refine(src_keypts.cuda(), tgt_keypts.cuda(), pred_trans)

            loss, recall, Re, Te, rmse = evaluate_metric(
                pred_trans, gt_trans.cuda(),
                src_keypts.cuda(), tgt_keypts.cuda(), pred_labels
            )

            stats[i, 0] = float(recall / 100.0)  # Registration recall
            stats[i, 1] = float(Re)              # Rotation error (deg)
            stats[i, 2] = float(Te)              # Translation error (cm)

    all_stats[scene] = stats
    logging.info(f"Scene {scene}: Reg Recall={stats[:, 0].mean() * 100:.2f}%")

# Overall statistics
all_pairs = np.concatenate(list(all_stats.values()), axis=0)
logging.info(f"Overall: Reg Recall={all_pairs[:, 0].mean() * 100:.2f}%, "
             f"Mean RE={all_pairs[all_pairs[:, 0] == 1, 1].mean():.2f}deg, "
             f"Mean TE={all_pairs[all_pairs[:, 0] == 1, 2].mean():.2f}cm")
```

--------------------------------

### Estimate Normals for Open3D Point Cloud

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Estimates normals for an Open3D PointCloud object using specified search radius and maximum number of neighbors. Checks if normals have been successfully computed.

```python
import open3d as o3d
from utils.pointcloud import make_point_cloud, estimate_normal

pts_numpy = np.random.randn(1000, 3)
pcd = make_point_cloud(pts_numpy)

# Estimate normals for the point cloud
# radius: search radius for normal estimation
# max_nn: maximum number of neighbors
estimate_normal(pcd, radius=0.06, max_nn=30)
print(f"Point cloud has normals: {pcd.has_normals()}")
```

--------------------------------

### 3DMatch Test Dataset Configuration

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Configures the 3DMatch test dataset for scene-specific evaluation. Set root, descriptor, input dimensions, inlier threshold, correspondence count, matching strategy, and specify a scene or None for all scenes.

```python
from datasets.ThreeDMatch import ThreeDMatchTest
from datasets.dataloader import get_dataloader

# 3DMatch Test Dataset (scene-specific)
test_dataset = ThreeDMatchTest(
    root='/data/3DMatch',
    descriptor='fcgf',
    in_dim=6,
    inlier_threshold=0.10,
    num_node='all',            # Use all correspondences for testing
    use_mutual=False,
    augment_axis=0,            # No augmentation during testing
    augment_rotation=0.0,
    augment_translation=0.0,
    select_scene='7-scenes-redkitchen',  # Specific scene or None for all
)

test_loader = get_dataloader(test_dataset, batch_size=1, num_workers=16, shuffle=False)
print(f"Test set size: {len(test_dataset)} pairs")
```

--------------------------------

### Perform Point Cloud Registration Inference

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Extracts FPFH features, matches correspondences, and uses the PointDSC model to estimate the transformation matrix between two point clouds.

```python
# Extract features from source and target point clouds
raw_src_pcd, src_pts, src_features = extract_fpfh_features('demo_data/cloud_bin_0.ply', config.downsample)
raw_tgt_pcd, tgt_pts, tgt_features = extract_fpfh_features('demo_data/cloud_bin_1.ply', config.downsample)

# Build correspondences using nearest neighbor matching
distance = np.sqrt(2 - 2 * (src_features @ tgt_features.T) + 1e-6)
source_idx = np.argmin(distance, axis=1)
corr = np.concatenate([np.arange(source_idx.shape[0])[:, None], source_idx[:, None]], axis=-1)

# Prepare keypoints and correspondence positions
src_keypts = src_pts[corr[:, 0]]
tgt_keypts = tgt_pts[corr[:, 1]]
corr_pos = np.concatenate([src_keypts, tgt_keypts], axis=-1)
corr_pos = corr_pos - corr_pos.mean(0)  # Center the coordinates

# Run PointDSC for outlier rejection and transformation estimation
data = {
    'corr_pos': torch.from_numpy(corr_pos)[None].to(device).float(),
    'src_keypts': torch.from_numpy(src_keypts)[None].to(device).float(),
    'tgt_keypts': torch.from_numpy(tgt_keypts)[None].to(device).float(),
    'testing': True,
}

with torch.no_grad():
    result = model(data)

# Get the estimated transformation
transformation = result['final_trans'][0].detach().cpu().numpy()
print(f"Estimated transformation matrix:\n{transformation}")

# Apply transformation to source point cloud
raw_src_pcd.transform(transformation)
o3d.visualization.draw_geometries([raw_src_pcd, raw_tgt_pcd])
```

--------------------------------

### Convert NumPy/Torch to Open3D Point Cloud

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Converts NumPy arrays or PyTorch tensors representing point coordinates into Open3D PointCloud objects. Useful for integrating with Open3D functionalities.

```python
import torch
import numpy as np
import open3d as o3d
from utils.pointcloud import make_point_cloud

# Convert numpy array or torch tensor to Open3D point cloud
pts_numpy = np.random.randn(1000, 3)
pcd = make_point_cloud(pts_numpy)
print(f"Point cloud has {len(pcd.points)} points")

# From torch tensor
pts_torch = torch.randn(1000, 3)
pcd_from_torch = make_point_cloud(pts_torch)
```

--------------------------------

### Perform ICP Refinement and Benchmark Evaluation

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Refine transformations using ICP and calculate AUC metrics for rotation and translation errors.

```python
import torch
import numpy as np
from evaluation.benchmark_utils import icp_refine, set_seed, exact_auc, rot_to_euler

# Set random seed for reproducibility
set_seed(51)

# ICP refinement after initial transformation estimation
src_keypts = torch.randn(1, 1000, 3).cuda()  # [1, num_corr, 3]
tgt_keypts = torch.randn(1, 1000, 3).cuda()  # [1, num_corr, 3]
initial_trans = torch.eye(4).unsqueeze(0).cuda()  # [1, 4, 4]

refined_trans = icp_refine(src_keypts, tgt_keypts, initial_trans)
print(f"Refined transformation shape: {refined_trans.shape}")

# Calculate Area Under Curve (AUC) for error metrics
rotation_errors = np.random.exponential(5, 100)  # Sample rotation errors in degrees
re_auc = exact_auc(rotation_errors, thresholds=[5, 10, 15])
print(f"Rotation Error AUC@5/10/15 deg: {re_auc}")

translation_errors = np.random.exponential(10, 100)  # Sample translation errors in cm
te_auc = exact_auc(translation_errors, thresholds=[5, 10, 15, 20, 25, 30])
print(f"Translation Error AUC@5-30 cm: {te_auc}")

# Convert rotation matrix to Euler angles
R = np.eye(3)
R[0, 0] = np.cos(np.pi/4)
R[0, 1] = -np.sin(np.pi/4)
R[1, 0] = np.sin(np.pi/4)
R[1, 1] = np.cos(np.pi/4)

euler_angles = rot_to_euler(R)  # Returns [x, y, z] angles in degrees
print(f"Euler angles (deg): x={euler_angles[0]:.2f}, y={euler_angles[1]:.2f}, z={euler_angles[2]:.2f}")
```

--------------------------------

### Convert Features to Open3D Feature Object

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Converts a NumPy array of features into an Open3D Feature object. Requires feature data, dimension, and the number of points. Used for registration tasks.

```python
import numpy as np
import open3d as o3d
from utils.pointcloud import make_feature

# Convert features to Open3D Feature object (for registration)
features = np.random.randn(1000, 33)  # FPFH has 33 dimensions
feature_o3d = make_feature(features, dim=33, npts=1000)
print(f"Feature dimension: {feature_o3d.dimension()}")
```

--------------------------------

### Extract FPFH Features using Open3D

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Extracts Fast Point Feature Histograms (FPFH) from a point cloud. Includes normal estimation, voxel downsampling, and feature computation using Open3D. Returns downsampled points and normalized features.

```python
import torch
import numpy as np
import open3d as o3d
from utils.pointcloud import estimate_normal

# Example: FPFH feature extraction using Open3D
def extract_fpfh(pcd, downsample=0.03):
    """Extract FPFH features from a point cloud."""
    estimate_normal(pcd, radius=downsample * 2)
    pcd_down = pcd.voxel_down_sample(downsample)
    fpfh = o3d.registration.compute_fpfh_feature(
        pcd_down,
        o3d.geometry.KDTreeSearchParamHybrid(radius=downsample * 5, max_nn=100)
    )
    features = np.array(fpfh.data).T
    features = features / (np.linalg.norm(features, axis=1, keepdims=True) + 1e-6)
    return np.array(pcd_down.points), features
```

--------------------------------

### Rigid Transform 3D with Weighted SVD

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Computes the optimal rigid transformation between two point sets using weighted Singular Value Decomposition (SVD). Supports optional correspondence weights and a weight threshold to ignore low-confidence matches.

```python
import torch
from models.common import rigid_transform_3d, knn

batch_size = 2
num_points = 100

src_keypts = torch.randn(batch_size, num_points, 3).cuda()

gt_R = torch.eye(3).unsqueeze(0).repeat(batch_size, 1, 1).cuda()
gt_t = torch.tensor([1.0, 2.0, 3.0]).view(1, 3, 1).repeat(batch_size, 1, 1).cuda()
tgt_keypts = (gt_R @ src_keypts.permute(0, 2, 1) + gt_t).permute(0, 2, 1)

tgt_keypts += torch.randn_like(tgt_keypts) * 0.01

trans = rigid_transform_3d(src_keypts, tgt_keypts, weights=None)
print(f"Estimated transformation shape: {trans.shape}")

weights = torch.rand(batch_size, num_points).cuda()
weights = weights / weights.sum(dim=1, keepdim=True)

trans_weighted = rigid_transform_3d(src_keypts, tgt_keypts, weights=weights)
print(f"Weighted transformation:\n{trans_weighted[0].cpu().numpy()}")

trans_thresholded = rigid_transform_3d(
    src_keypts,
    tgt_keypts,
    weights=weights,
    weight_threshold=0.001
)

features = torch.randn(batch_size, num_points, 128).cuda()
knn_idx = knn(features, k=40, ignore_self=True, normalized=True)
print(f"KNN indices shape: {knn_idx.shape}")
```

--------------------------------

### PointDSC Loss Functions

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Implements specialized loss functions for training PointDSC: ClassificationLoss for inlier confidence, SpectralMatchingLoss for feature similarity, and TransformationLoss for registration accuracy. These losses help supervise feature learning and registration refinement.

```python
import torch
from libs.loss import ClassificationLoss, SpectralMatchingLoss, TransformationLoss

batch_size = 4
num_corr = 1000

gt_labels = (torch.rand(batch_size, num_corr) > 0.7).float().cuda()
pred_logits = torch.randn(batch_size, num_corr).cuda()

class_loss_fn = ClassificationLoss(balanced=True)
class_stats = class_loss_fn(pred_logits, gt_labels)

print(f"Classification Loss: {class_stats['loss'].item():.4f}")
print(f"Precision: {class_stats['precision']:.4f}")
print(f"Recall: {class_stats['recall']:.4f}")
print(f"F1 Score: {class_stats['f1']:.4f}")

M = torch.rand(batch_size, num_corr, num_corr).cuda()
M = (M + M.permute(0, 2, 1)) / 2

sm_loss_fn = SpectralMatchingLoss(balanced=True)
sm_loss = sm_loss_fn(M, gt_labels)
print(f"Spectral Matching Loss: {sm_loss.item():.4f}")

trans_loss_fn = TransformationLoss(re_thre=15, te_thre=30)
```

--------------------------------

### Compute FPFH Descriptors

Source: https://github.com/xuyangbai/pointdsc/blob/master/multiway/README.md

Computes FPFH local descriptors for ply files, which are used to construct putative correspondences for the network.

```bash
python misc/cal_fpfh.py
```

--------------------------------

### Calculate Transformation Loss

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Computes transformation loss, recall, rotation error, translation error, and RMSE. Requires predicted and ground truth transformations, source and target keypoints, and predicted inliers.

```python
pred_trans = torch.eye(4).unsqueeze(0).repeat(batch_size, 1, 1).cuda()
gt_trans = torch.eye(4).unsqueeze(0).repeat(batch_size, 1, 1).cuda()
gt_trans[:, :3, 3] = torch.randn(batch_size, 3).cuda() * 0.1

# Source and target keypoints
src_keypts = torch.randn(batch_size, num_corr, 3).cuda()
tgt_keypts = torch.randn(batch_size, num_corr, 3).cuda()
pred_inliers = pred_logits > 0

loss, recall, re, te, rmse = trans_loss_fn(
    pred_trans, gt_trans, src_keypts, tgt_keypts, pred_inliers.float()
)
print(f"Transformation Loss: {loss.item():.4f}")
print(f"Registration Recall: {recall:.2f}%")
print(f"Rotation Error: {re.item():.2f} deg")
print(f"Translation Error: {te.item():.2f} cm")
```

--------------------------------

### Extract FPFH Features for Point Cloud Registration

Source: https://context7.com/xuyangbai/pointdsc/llms.txt

Extracts Fast Point Feature Histograms (FPFH) from a point cloud file, including normal estimation and downsampling. Features are normalized for consistency. This function is part of the complete registration workflow.

```python
import json
import torch
import numpy as np
import open3d as o3d
from easydict import EasyDict as edict
from models.PointDSC import PointDSC
from utils.pointcloud import estimate_normal

def extract_fpfh_features(pcd_path, downsample):
    """Extract FPFH features from a point cloud file."""
    raw_pcd = o3d.io.read_point_cloud(pcd_path)
    estimate_normal(raw_pcd, radius=downsample * 2)
    pcd = raw_pcd.voxel_down_sample(downsample)
    features = o3d.registration.compute_fpfh_feature(
        pcd,
        o3d.geometry.KDTreeSearchParamHybrid(radius=downsample * 5, max_nn=100)
    )
    features = np.array(features.data).T
    features = features / (np.linalg.norm(features, axis=1, keepdims=True) + 1e-6)
    return raw_pcd, np.array(pcd.points), features

# Load configuration and model
config = json.load(open('snapshot/PointDSC_3DMatch_release/config.json', 'r'))
config = edict(config)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = PointDSC(
    in_dim=config.in_dim,
    num_layers=config.num_layers,
    num_channels=config.num_channels,
    num_iterations=config.num_iterations,
    ratio=config.ratio,
    sigma_d=config.sigma_d,
    k=config.k,
    nms_radius=config.inlier_threshold,
).to(device)
model.load_state_dict(torch.load('snapshot/PointDSC_3DMatch_release/models/model_best.pkl', map_location=device), strict=False)
model.eval()

```
Tokens:
Raw