Scan2CAD: Learning CAD Model Alignment in RGB-D Scans

Introduction

In recent years, the wide availability of consumer-grade RGB-D sensors, such as the Microsoft Kinect, Intel Real Sense, or Google Tango, has led to significant progress in RGB-D reconstruction. We now have 3D reconstruction frameworks, often based on volumetric fusion , that achieve impressive reconstruction quality and reliable global pose alignment . At the same time, deep learning methods for 3D object classification and semantic segmentation have emerged as a primary consumer of large-scale annotated reconstruction datasets . These developments suggest great potential in the future of 3D digitization, for instance, in applications for virtual and augmented reality.

Despite these improvements in reconstruction quality, the geometric completeness and fine-scale detail of indoor scene reconstructions remain a fundamental limitation. In contrast to artist-created computer graphics models, 3D scans are noisy and incomplete, due to sensor noise, motion blur, and scanning patterns. Learning-based approaches for object and scene completion cannot reliably recover sharp edges or planar surfaces, resulting in quality far from artist-modeled 3D content.

One direction to address this problem is to retrieve a set of CAD models from a shape database and align them to an input scan, in contrast to a bottom-up reconstruction of the scene geometry. If all objects are replaced in this way, we obtain a clean and compact scene representation, precisely serving the requirements for many applications ranging from AR/VR scenarios to architectural design. Unfortunately, matching CAD models to scan geometry is an extremely challenging problem: While high-level geometric structures might be similar, the low-level geometric features differ significantly (e.g., surface normal distributions). This severely limits the applicability of handcrafted geometric features, such as FPFH , SHOT , point-pair-features , or SDF-based feature descriptors . While learning-based approaches like random forests exist, their model capacity remains relatively low, especially in comparison to more modern methods based on deep learning, which can achieve significantly higher accuracy, but remain at their infancy. We believe this is in large part attributed to the lack of appropriate training data.

In this paper, we make the following contributions:

We introduce the Scan2CAD dataset, a large-scale dataset comprising 97607 pairwise keypoint correspondences and 9DoF alignments between 14225 instances of 3049 unique synthetic models, between ShapeNet and reconstructed scans in ScanNet , as well as oriented bounding boxes for each object.

We propose a novel 3D CNN architecture that learns a joint embedding between real and synthetic 3D objects to predict accurate correspondence heatmaps between the two domains.

We present a new variational optimization formulation to minimize the distance between scan keypoints and their correspondence heatmaps, thus obtaining robust 9DoF scan-to-CAD alignments.

Related work

The availability of low-cost RGB-D sensors has led to significant research progress in RGB-D 3D reconstruction. A very prominent line of research is based on volumetric fusion , where depth data is integrated in a volumetric signed distance function. Many modern real-time reconstruction methods, such as KinectFusion , are based on this surface representation. In order to make the representation more memory-efficient, octree or hash-based scene representations have been proposed . An alternative fusion approach is based on points ; the reconstruction quality is slightly lower, but it has more flexibility when handling scene dynamics and can be adapted on-the-fly for loop closures . Very recent RGB-D reconstruction frameworks combine efficient scene representations with global pose estimation , and can even perform online updates with global loop closures . A closely related direction to ours (and a possible application) is recognition of objects as a part of a SLAM method, and using the retrieved objects as part of a global pose graph optimization .

D Features for Shape Alignment and Retrieval

Geometric features have a long-established history in computer vision, such as Spin Images , Fast Point Feature Histograms (FPFH) , or Point-Pair Features (PPF) . Based on these descriptors or variations of them, researchers have developed shape retrieval and alignment methods. For instance, Kim et al. learn a shape prior in the form of a deformable part model from input scans to find matches at test time; or AA2h use a similar approach to PPF, where a histogram of normal distributions of sample points is used for retrieval. Li et al. propose a formulation based on a hand-crafted TSDF feature descriptor to align CAD models in real-time to RGB-D scans. While these retrieval approaches based on hand-crafted geometric features show initial promise, they struggle to generalize matching between the differing data characteristics of clean CAD models and noisy, incomplete real-world data.

An alternative direction is learned geometric feature descriptors. For example, Nan et al. use a random decision forest to classify objects on over-segmented input geometry from high-quality scans. Shao et al. introduce a semi-automatic system to resolve segmentation ambiguities, where a user first segments a scene into semantic regions, and then shape retrieval is applied. 3DMatch leverage a Siamese neural network to match keypoints in 3D scans for pose estimation. Zhou et al. is of similar nature, proposing a view consistency loss for 3D keypoint prediction network on RGB-D image data. Inspired by such approaches, we develop a 3D CNN-based approach targeting correspondences between the synthetic domain of CAD models and the real domain of RGB-D scan data.

Other approaches retrieve and align CAD models given single RGB or RGB-D images. These methods are related, but our focus is on geometric alignment independent of RGB information, rather than CAD-to-image.

Shape Retrieval Challenges and RGB-D Datasets

Shape retrieval challenges have recently been organized as part of the Eurographics 3DOR . Here, the task was formulated as matching of object instances from ScanNet and SceneNN to CAD models from the ShapeNetSem dataset . Evaluation only considered binary in-category vs out-of-category (and sub-category) match as the notion of relevance. As such, this evaluation does not address the alignment quality between scan objects and CAD models, which is our focus.

ScanNet provides aligned CAD models for a small subset of the annotated object instances (for only 200 objects out of the total 36000). Moreover, the alignment quality is low with many object category mismatches and alignment errors, as the annotation task was performed by crowdsourcing. The PASCAL 3D+ dataset annotates 13898 objects in the PASCAL VOC images with coarse 3D poses defined against representative CAD models. ObjectNet3D provides a dataset of CAD models aligned to 2D images, approximately 200K object instances in 90K images. The IKEA objects and Pix3D datasets similarly provide alignments of a small set of identifiable CAD models to 2D images of the same objects in the real world; the former has 759 images annotated with 90 models, the latter has 10069 annotated with 395 models.

No existing dataset provides fine-grained object instance alignments at the scale of our Scan2CAD dataset with 14225 CAD models (3049 unique instances) annotated to their scan counterpart distributed on 1506 3D scans.

Overview

Dataset and Benchmark

In Sec. 4, we introduce the construction of our Scan2CAD dataset. We propose an annotation pipeline designed for use by trained annotators. An annotator first inspects a 3D scan and selects a model from a CAD database that is geometrically similar to a target object in the scan. Then, for each model, the annotator defines corresponding keypoint pairs between the model and the object in the scan. From these keypoints, we compute ground truth 9DoF alignments. We annotate the entire ScanNet dataset and use the original training, validation, and test splits to establish our alignment benchmark.

Heatmap Prediction Network

In Sec. 5, we propose a 3D CNN taking as input a volume around a candidate keypoint in a scan and a volumetric representation of a CAD model. The network is trained to predict a correspondence heatmap over the CAD volume, representing the likelihood that the input keypoint in the scan is matching with each voxel. The heatmap prediction is formulated as a classification problem, which is easier to train than regression, and produces sparse correspondences needed for pose optimization.

Alignment Optimization

Sec. 6 describes our variational alignment optimization. To generate candidate correspondence points in the 3D scan, we detect Harris keypoints, and predict correspondence heatmaps for each Harris keypoint and CAD model. Using the predicted heatmaps we find optimal 9DoF transformations. False alignments are pruned via a geometric confidence metric.

Dataset

The annotation is done via a web application that allows for simple scaling and distribution of annotation jobs; see Fig. 2. The annotation process is separated into two steps. The first step is object retrieval, where the user clicks on a point on the 3D scan surface, implicitly determining an object category label from the ScanNet object instance annotations. We use the instance category label as query text in the ShapeNet database to retrieve and display all matching CAD models in a separate window as illustrated in 2(a). After selecting a CAD model the user performs alignment.

In the alignment step, the user sees two separate windows in which the CAD model (left) and the scan object (right) are shown (see 2(b)). Keypoint correspondences are defined by alternately clicking paired points on the CAD model and scan object. We require users to specify at least 6 keypoint pairs to determine a robust ground truth transformation. After keypoint pairs are specified, the alignment computation is triggered by clicking a button. This alignment (given exact 1-to-1 correspondences) is solved with the genetic algorithm CMA-ES that minimizes the point-to-point distance over 9 parameters. In comparison to gradient-based methods or Procrustes superimposition method, we found this approach to perform significantly better in reliably returning high-quality alignments regardless of initialization.

The quality of these keypoint pairs and alignments was verified in several verification passes, with re-annotations performed to ensure a high quality of the dataset. The verification passes were conducted by the authors of this work.

A subset of the ShapeNet CAD models have symmetries that play an important role in making correspondences. Hence, we annotated all ShapeNet CAD models used in our dataset with their rotational symmetries to prevent false negatives in evaluations. We defined 2-fold ($C_{2}$), 4-fold ($C_{4}$) and infinite ($C_{\infty}$) rotational symmetries around a canonical axis of the object.

2 Dataset Statistics

The annotation process yielded 97607 keypoint pairs on 14225 (3049 unique) CAD models with their respective scan counterpart distributed on a total of 1506. Approximately $28\%$ out of the 3049 CAD models have a symmetry tag (either $C_{2}$, $C_{4}$ or $C_{\infty}$).

Given the complexity of the task and to ensure high quality annotations, we employed 7 part-time annotators (in contrast to crowd-sourcing). On average, each scene has been edited $1.76$ times throughout the re-annotation cycles. The top 3 annotated model classes are chairs, tables and cabinets which arises due to the nature of indoor scenes in ScanNet. The number of objects aligned per scene ranges from $1$ to $40$ with an average of $9.3$. It took annotators on average of $2.48\text{min}$ to align each object, where the time to find an appropriate CAD model dominated the time for keypoint placement. The average annotation time for an entire scene is $20.52\text{min}$.

It is interesting to note that manually placed keypoint correspondences between scans and CAD models differ significantly from those extracted from a Harris corner detector. Here, we compare the mean distance from the annotated CAD keypoint to: (1) the corresponding annotated scan keypoint ($=3.5cm$) and (2) the nearest Harris keypoint in the scan ($=12.8cm$).

3 Benchmark

Using our annotated dataset, we designed a benchmark to evaluate scan-to-CAD alignment methods. A model alignment is considered successful only if the category of the CAD model matches that of the scan object and the pose error is within translation, rotational, and scale bounds relative to the ground truth CAD. We do not enforce strict instance matching (i.e., matching the exact CAD model of the ground truth annotation) as ShapeNet models typically do not identically match real-world scanned objects. Instead, we treat CAD models of the same category as interchangeable (according to the ShapeNetCorev2 top-level synset).

Once a CAD model is determined to be aligned correctly, the ground truth counterpart is removed from the candidate pool in order to prevent multiple alignments to the same object. Alignments are fully parameterized by 9 pose parameters. A quantitative measure based on bounding box overlap (IoU) can be readily calculated with these parameters as CAD models are defined on the unit box. The error thresholds for a successful alignment are set to $\epsilon_{t}\leq 20\text{cm}$, $\epsilon_{r}\leq 20^{\circ}$, and $\epsilon_{s}\leq 20\%$ for translation, rotation, and scale respectively (for extensive error analysis please see the supplemental). The rotation error calculation takes $C_{2}$, $C_{4}$ and $C_{\infty}$ rotated versions into account.

The Scan2CAD dataset and associated symmetry annotations is available to the community. For standardized comparison of future approaches, we operate an automated test script on a hidden test set.

Correspondence Prediction Network

Scan data is represented by its signed distance field (SDF) encoded in a volumetric grid and generated through volumetric fusion from the depth maps of the RGB-D reconstruction (voxel resolution = $3cm$, truncation = $15cm$). For the CAD models, we compute unsigned distance fields (DF) using the level-set generation toolkit by Batty .

2 Network Architecture

Our architecture takes as input a pair of voxel grids: A SDF centered at a point in the scan with a large receptive field at $64^{3}$ size, and a DF of a particular CAD model at $32^{3}$ size. We use a series of convolutional layers to separately encode each input stream (see Fig. 4). The two encoders compress the volumetric representation into compact feature volumes of $4^{3}\times 64$ (scan) and $4^{3}\times 8$ (CAD) which are then concatenated before passing to the decoder stage. The decoder stage predicts three output targets, heatmap, compatibility, and scale, described as follows:

where $w(x)=64.0\text{ if }x>0.0\text{ else }1.0,v=64$ are weighting factors to increase the signal of the few sparse positive keypoint voxels in the voxel grid ($\approx 99\%$ of the target voxels have a value equal to ). The combination of the sigmoid and softmax terms is a compromise between high recall but low precision using sigmoid, and more locally sharp keypoint predictions using softmax over all voxels. The final target heatmap, used later for alignment, is constructed with an element-wise multiplication of both heatmap variations: $H=H_{1}\circ H_{2}$.

Compatibility

The second prediction target is a single probability score $\in$ indicating semantic compatibility between scan and CAD. This category equivalence score is when the category labels are different (e.g., scan table and CAD chair) and $1$ when the category labels match (e.g., scan chair and CAD chair). The loss function for this output is a sigmoid function followed by a BCE loss:

Scale

Finally, to train our network, we use a weighted combination of the presented losses:

where the weighting of each loss component was empirically determined for balanced convergence.

3 Training Data Generation

Centered scan volumes are generated by projecting the annotated keypoint into the scan voxel grid and then cropping around it with a crop window of $63^{3}$. Ground truth heatmaps are generated by projecting annotated keypoints (and any symmetry-equivalent keypoints) into the CAD voxel grid. We then use a Gaussian blurring kernel ($\sigma=2.0$) on the voxel grid to account for small keypoint annotation errors and to avoid sparsity in the loss residuals.

Training Samples

With our annotated dataset we generate $N_{P,\text{ann.}}=97607{}$ positive training pairs where one pair consists of an annotated scan keypoint and the corresponding CAD model. Additionally, we create $N_{P,\text{aug.}}=10\cdot N_{P,\text{ann.}}$, augmented positive keypoint pairs by randomly sampling points on the CAD surface, projecting them to the scan via the ground truth transformation and rejecting if the distance to the surface in the scan $\geq 3cm$. In total we generate $N_{P}=N_{P,\text{ann.}}+N_{P,\text{aug.}}$ positive training pairs.

Negative pairs are generated in two ways: (1) Randomly choosing a voxel point in the scan and a random CAD model (likelihood of false negative is exceedingly low). (2) Taking an annotated scan keypoint and pairing it with a random CAD model of different class. We generate $N_{N}=N_{P}$ negative samples with (1) and $N_{HN}=N_{P}$ with (2).

Hence, the training set has a positives-to-negatives ratio of 1:2 ($N_{P}$ : $N_{N}+N_{HN}$). We found an over-representation of negative pairs gives satisfactory performance on the compatibility prediction.

4 Training Process

We use an SGD optimizer with a batch size of 32 and an initial learning rate of $0.01$, which is decreased by $1/2$ every $50$K iterations. We train for 250K iterations ($\approx 62.5$ hours). The weights are initialized randomly. The losses of the heatmap prediction stream and the scale prediction stream are masked such that only positive samples make up the residuals for back-propagation.

The CAD encoder is pre-trained with an auto-encoder on ShapeNet models with a reconstruction task and a $MSE$ as loss function. All models of ShapeNetCore ($\approx 55K$) are used for pre-training and the input and output dimensions are $32^{3}$ distance field grids. The network is trained with SGD until convergence ($\approx 50$ epochs).

Alignment Optimization

Since not every keypoint $p_{j}$ semantically matches to every CAD model $m_{i}$, we reject correspondences based on the compatibility prediction of our network. The threshold for rejecting $p_{j}$ is determined by the Otsu thresholding scheme . In practice this method turned out to be much more effective than a fixed threshold. After the filtering there are $N\leq N_{0}$ (usually $N\approx 0.1N_{0}$) correspondence pairs to be used for the alignment optimization.

Variational Optimization

In order to find an optimal pose we construct the following minimization problem:

where $\text{c}_{\text{vox}}$ is a voxel coordinate, $T_{\text{world}\rightarrow\text{vox}}$ denotes a transformation that maps world points into the voxel grid for look-ups, $a$ denotes the coordinates of the Lie algebra (for rotation and translation), $s$ defines the scale, and $\lambda_{s}$ defines the scale regularization strength. $a,s$ compose a transformation matrix $T_{m_{i}}=\psi(a_{m_{i}},s_{m_{i}})$:

where $\Gamma$ is the hat map, expm is the matrix exponential.

We solve Eq. 1 using the Levenberg-Marquardt (LM) algorithm. As we can suffer from zero-gradients (especially at bad initialization), we construct a scale-pyramid from the heatmaps which we solve in coarse-to-fine fashion.

In each LM step we optimize over the incremental change and update the parameters as following: $T_{m_{i}}^{k+1}\leftarrow\phi(a^{*},s^{*})\cdot T_{m_{i}}^{k}$ where $a^{*},s^{*}$ are the optimal parameters. As seen in Eq. 1, we add a regularization on the scale in order to prevent degenerate solutions which can appear for very large scales.

By restarting the optimization with different translation parameters (i.e., varying initializations), we obtain multiple alignments per CAD model $m_{i}$. We then generate as many CAD model alignments as required for a given scene in the evaluation. Note, in a ground truth scene one unique CAD model $m_{i}$ can appear in multiple locations e.g., chairs in conference rooms.

Pruning

Finally, there will be alignments of various CAD models into a scene where a subset will be misaligned. In order to select only the best alignments and prune potential misalignments we use a confidence metric similar to ; for more detail, we refer to the appendix.

Results

To quantify the performance of correspondence heatmap predictions, we evaluate the voxel-wise F1-score for a prediction and its Gaussian-blurred target. The task is challenging and by design $\frac{2}{3}$ test samples are false correspondences, $\approx 99\%$ of the target voxels are 0-valued, and only a single 1-valued voxel out of $32^{3}$ voxels exists. The F1-score will increase only by identifying true correspondences. As seen in Tab. 1, our best 3D CNN achieves $63.94\%$.

Tab. 1 additionally addressed our design choices; in particular, we evaluate the effect of using pre-training (PT), using compatibility (CP) as a proxy loss (defined in Sec. 5.2), enabling symmetry awareness (sym), and predicting scale (scale). Here, a pre-trained network reduces overfitting, enhancing generalization capability. Optimizing for compatibility strongly improves heatmap prediction as it efficiently detects false correspondences. While predicting scale only slightly influences the heatmap predictions, it becomes very effective for the later alignment stage. Additionally, incorporating symmetry enables significant improvement by explicitly disambiguating symmetric keypoint matches.

2 Alignment

In the following, we compare our approach to other handcrafted feature descriptors: FPFH , SHOT , Li et al. and a learned feature descriptor: 3DMatch (trained on our Scan2CAD dataset). We combine these descriptors with a RANSAC outlier rejection method to obtain pose estimations for an input set of CAD models. A detailed description of the baselines can be found in the appendix. As seen in Tab. 2, our best method achieves $31.68\%$ and outperforms all other methods by a significant margin. We additionally show qualitative results in Fig. 5. Compared to state-of-the-art handcrafted feature descriptors, our learned approach powered by our Scan2CAD dataset produces considerably more reliable correspondences and CAD model alignments. Even compared to the learned descriptor approach of 3DMatch, our explicit learning across the synthetic and real domains coupled with our alignment optimization produces notably improved CAD model alignment.

Fig. 6 shows the capability of our method to align in an unconstrained real-world setting where ground truth CAD models are not given, we instead provide a set of 400 random CAD models from ShapeNet .

Limitations

While the focus of this work is mainly on the alignment between 3D scans and CAD models, we only provide a basic algorithmic component for retrieval (finding the most similar model). This necessitates an exhaustive search over a set of CAD models. We believe that one of the immediate next steps in this regard would be designing a neural network architecture that is specifically trained on shape similarity between scan and CAD geometry to introduce more efficient CAD model retrieval. Additionally, we currently only consider geometric information, and it would also be intresting to introduce learned color features into the correspondence prediction, as RGB data is typically higher-resolution than depth or geometry, and could potentially improve alignment results.

Conclusion

In this work, we presented Scan2CAD, which aligns a set of CAD models to 3D scans by predicting correspondences in form of heatmaps and then optimizes over these correspondence predictions. First, we introduce a new dataset of 9DoF CAD-to-scan alignments with 97607 pairwise keypoint annotations defining the alignment of 14225 objects. Based on this new dataset, we design a 3D CNN to predict correspondence heatmaps between a CAD model and a 3D scan. From these predicted heatmaps, we formulate a variational energy minimization that then finds the optimal 9DoF pose alignments between CAD models and the scan, enabling effective transformation of noisy, incomplete RGB-D scans into a clean, complete CAD model representation. This enables us to achieve significantly more accurate results than state-of-the-art approaches, and we hope that our dataset and benchmark will inspire future work towards bringing RGB-D scans to CAD or artist-modeled quality.

Acknowledgements

We would like to thank the expert annotators Soh Yee Lee, Rinu Shaji Mariam, Suzana Spasova, Emre Taha, Sebastian Thekkekara, and Weile Weng for their efforts in building the Scan2CAD dataset. This work is supported by Occipital, the ERC Starting Grant Scan2CAD (804724), and a Google Faculty Award. We would also like to thank the support of the TUM-IAS, funded by the German Excellence Initiative and the European Union Seventh Framework Programme under grant agreement n° 291763, for the TUM-IAS Rudolf Mößbauer Fellowship and Hans-Fisher Fellowship (Focus Group Visual Computing).

References

Appendix A Dataset

A compilation of our dataset is presented in Fig. 15. As a full coverage was aimed during the annotation, we can see the variety and richness of the aligned objects.

We show the object category statistics of our dataset in Fig. 7. Since our dataset is constructed on scans of indoor environments, it contains many furniture categories (e.g., chairs, tables, and sofas). In addition, it also provides alignments for a wide range of other objects such as backpacks, keyboards, and monitors.

Timings

The annotation timings per object and per scan are illustrated in Fig. 8 (top) and Fig. 8 (bottom). On an object level, the timings are relatively consistent with little variance in time. On a scan level, however, the variation in annotation time is larger which is due to variation in scene size. Larger scenes are likely to contain more objects and hence require longer annotation times.

Symmetries

In order to take into account the natural symmetries of many object categories during our training and evaluation, we collected a set of symmetry type annotations for all instances of CAD models. Fig. 9 shows examples and total counts for all rotational symmetry annotations.

Appendix B Evaluation Metric

In this section, we describe the details of the algorithm for computing the alignment accuracy. To compute the accuracy, we do a greedy matching of aligned CAD models to the ground truth CAD models.

For a given aligned scene id-scan with $N$ aligned CAD models, we query the ground truth alignment for the given scene. The evaluation script then iterates through all aligned candidate models and checks whether there is a ground truth CAD model of the same class where the alignment error is below the given bounds; if one is found, then the counter (of positive alignments) is incremented and the respective ground truth CAD model is removed from the ground truth pool. See Alg. 1 for the pseudo-code.

Appendix C Correspondence Prediction Network

The details of the building blocks for our correspondence prediction network are depicted in Fig. 10. See Figure 4 of the main paper for the full architecture. We introduce the following blocks:

ConvBlocks are the most atomic blocks and consist of a sequence of Conv3-BatchNorm-ReLU layers as commonly found in other literature.

ResBlocks are essentially residual skip connecting layers.

BigBlocks contain two ResBlocks in succession.

Training curves

Fig. 11 shows how much data is required for training the alignment approach. The curves show predicted compatibility scores of our network. We train our 3D CNN approach with different numbers of training samples (full, half and quarter of the dataset), and show both training and validation curves for each of the three experiments. When using only a quarter or half of the dataset, we see severe overfitting. This implies that our entire dataset provides significantly better generalization.

In Fig. 12, we show the Precision-recall curve of the compatibility prediction of a our ablations (see Sec. 7.1 in the main paper). The PR-curves underline the strength of our best preforming network variation.

Correspondence predictions

Visual results of the correspondence prediction are shown in Fig. 14. One can see that our correspondence prediction network predicts as well symmetry-equivalent correspondences. The scan input with a voxel resolution of $3\text{cm}$ and a grid dimension of $64$ can cover $1.92\text{m}$ per dimension. A larger receptive field is needed for large objects in order infer correspondences from a more global semantic context (see left-hand side first and second row.).

Appendix D Alignment Algorithm Details

In order to remove misaligned objects, we prune objects after the alignment optimization based on the known free space of the given input scan. This is particularly important for the unconstrained (‘in-the-wild’) scenario where the set of ground truth CAD models to be aligned is not given as part of the input. For a given candidate transformation $T_{m}$ (as described in Sec. 6 in the main paper), we compute:

Appendix E Alignment Error Analysis

Our alignment results have different sensibility for each parameter block (translation, rotation, scale). In order to gauge the stringency of each parameter block we varied the threshold for one parameter block and held the other two constant at the default value (see Fig. 13). We observe that for the default thresholds $\epsilon_{t}=0.2\text{m},\epsilon_{r}=20^{\circ},\epsilon_{s}=20\text{\%}$ all thresholds

Appendix F Baseline Method Details

In the following, we provide additional details for the used baseline approaches. FPFH and SHOT work on point clouds and compute geometric properties between points within a support region around a keypoint. We use the implementation provided in the Point Cloud Library .

The method presented by Li et al. takes the free space around a keypoint into account to compute a descriptor distance between a keypoint in scan and another keypoint in a CAD object. Here, we use the original implementation from the authors and modified it such that it works within a consistent evaluation framework together with the other methods. However, since we are not restricted to real-time constraints, we neglect the computation of the geometric primitives around the keypoints, which helps to find good initial rotation estimations. Instead, we computed all 36 rotation variants to find the smallest distance. We also replace the original 1-point RANSAC with another RANSAC as described below.

3DMatch takes as input a 3D volumetric patch from a TDF around a keypoint and computes via a series of 3D convolutions and max-poolings a 512 dimensional feature vector. In order to train 3DMatch, we assemble a correspondence dataset as described in Sec. 5.3 in the main paper. We train the network for 25 epochs using the original contrastive loss with a margin of 1. During test time, we extract the 3D patch around a detected Harris keypoint of both CAD object and scan and separately compute their feature vector.

For each method, we compute the feature descriptors for all keypoints in the scan and the CAD objects, respectively. We then find correspondences between pairs of keypoints if their height difference is less than $0.8m$ and if the L2 distance between the descriptors is below a certain threshold. Due to potential re-occurring structures in scan and CAD we select the top-8 correspondences with the smallest descriptor distances for each keypoint in the scan.

After establishing potential correspondences between the scan and a CAD object, we use a RANSAC outlier rejection method to filter out wrong correspondences and find a suitable transformation to align the CAD object within the scene. During each RANSAC iteration, we estimate the translation parameters and the up-right rotation by selecting 3 random correspondences. If the transformation estimate gives a higher number of inliers than previous estimates, we keep this transformation. The threshold of the Euclidean distance for which a correspondence is considered as an inlier is set to $0.20m$. We use a fixed scale determined by the class average scale from our Scan2CAD train set. For a given registration for a specific CAD model, we mark off all keypoints in the scan which were considered as inliers as well as all scan keypoints which are located inside the bounding box of the aligned CAD model. These marked keypoints will be ignored for the registration of later CAD models.

To find optimal parameter for FPFH, SHOT, and Li et al., we construct an additional correspondence benchmark and ran a hyperparameter search based on the validation set.