CAD Priors for Accurate and Flexible Instance Reconstruction

TL;DR

This paper introduces a novel pipeline that leverages CAD priors for automatic, accurate, and flexible 3D instance reconstruction from unorganized point clouds, even in dynamic cluttered environments.

Contribution

It proposes a fully automated method combining CAD priors, object detection, and pose graph optimization for high-fidelity 3D reconstruction in complex scenes.

Findings

Effective reconstruction of objects up to 125m^3

Automatic detection and segmentation in cluttered scenes

High accuracy close to sensor noise levels

Abstract

We present an efficient and automatic approach for accurate reconstruction of instances of big 3D objects from multiple, unorganized and unstructured point clouds, in presence of dynamic clutter and occlusions. In contrast to conventional scanning, where the background is assumed to be rather static, we aim at handling dynamic clutter where background drastically changes during the object scanning. Currently, it is tedious to solve this with available methods unless the object of interest is first segmented out from the rest of the scene. We address the problem by assuming the availability of a prior CAD model, roughly resembling the object to be reconstructed. This assumption almost always holds in applications such as industrial inspection or reverse engineering. With aid of this prior acting as a proxy, we propose a fully enhanced pipeline, capable of automatically detecting and segmenting the object of interest from scenes and creating a pose graph, online, with linear complexity. This allows initial scan alignment to the CAD model space, which is then refined without the CAD constraint to fully recover a high fidelity 3D reconstruction, accurate up to the sensor noise level. We also contribute a novel object detection method, local implicit shape models (LISM) and give a fast verification scheme. We evaluate our method on multiple datasets, demonstrating the ability to accurately reconstruct objects from small sizes up to $125m^3$.

Figures

Tables

Table 1. Table 1: Reconstruction results on Mian Dataset (in mm). Each object is compared to the model provided by [ 28 ] using [ 1 ] .

Model	w/o Opt.	with Opt.	$\#$ Scans	Clutter
Chef	2.90 $\pm$ 2.40	1.07 $\pm$ 0.65	22	0.58$\pm$0.11
Chicken	1.71 $\pm$ 1.60	0.33 $\pm$ 0.24	29	0.61$\pm$0.12
Para.	2.52 $\pm$ 2.00	0.41 $\pm$ 0.30	12	0.24$\pm$0.20
T-rex	2.36 $\pm$ 2.08	0.88 $\pm$ 0.62	27	0.14$\pm$0.22

Table 2. Table 2: Reconstruction errors on toy objects dataset (mm).

	Leo	Teddy	Bunny	Tank
KinFU	1.785$\pm$1.299	0.998$\pm$0.807	0.664$\pm$0.654	1.390 $\pm$ 1.315
Kehl	1.018$\pm$1.378	1.028$\pm$0.892	0.838$\pm$0.860	1.573$\pm$2.250
Sdf2Sdf	0.652$\pm$0.614	0.910$\pm$0.584	0.541$\pm$0.436	0.466 $\pm$ 0.416
Ours	0.481$\pm$0.519	0.517$\pm$0.572	0.415$\pm$0.501	0.451$\pm$0.322
Ours-KF.	0.536$\pm$0.411	0.519$\pm$0.582	0.502$\pm$0.529	0.468$\pm$0.474
Ours-CO.	0.651$\pm$0.628	0.544$\pm$0.601	0.698$\pm$0.506	0.475$\pm$0.433

Table 3. Table 3: Object Information, Average reconstruction errors w.r.t. Photogrammetry (in mm) and Timings.

Object	Scanner	Scan Res.	Obj. Size	No Scans	No PG Images	PG vs CAD	Surphaser	Our Accuracy	Detect	Verify	Refine
Ventil	Surph.	$0.3$ mm	$8m^3$	8	180	1.3cm	3.6$\pm$3.3	2.2$\pm$0.4	3.10s	0.27s	112.94s
Turbine	Surph.	$0.4$mm	$125m^3$	10	180	3.4cm	-	2.5$\pm$1.3	3.72s	0.54s	126.13s
Sofa	Str.Light	$1$mm	$1.7m^3$	6	68	0.85mm	-	1.4$\pm$1.2	1.44s	0.31s	68.82s

Equations

$$\mathbf{S}_{G}=\bigcup_{i=1}^{N}\big{(}\mathbf{T}_{i}^{0}\circ\mathbf{S}_{i}\big{)}$$

$$\mathbf{S}_{G}=\bigcup_{i=1}^{N}\Big{(}\mathbf{T}_{i}^{M}\circ(S_{i}|\mathbf{M})\Big{)}$$

$$E(\bm{\theta}_{h},\bm{\theta}_{k})=A(h,k)\sum_{i=1}^{N_{h}}\rho\bigg{(}\lVert d(\bm{\theta}_{h}\circ p_{i}^{h},\bm{\theta}_{k}\circ q_{i}^{h})\rVert^{2}\bigg{)}$$

$$d(p_i,q_i)=(\mathbf{R}{p}_i+\mathbf{t}-q_i{)}^T{n}_i^q$$

$$E(\bm{\theta})=\sum_{h=1}^{M}\sum_{k=1}^{M}A(h,k)\sum_{i=1}^{N_{h}}\rho\bigg{(}\lVert d(\bm{\theta}_{h}\circ p_{i}^{h},\bm{\theta}_{k}\circ q_{i}^{h})\rVert^{2}\bigg{)}$$

$${\mathbf{f}}_{ij}=(\Vert \mathbf{d}{\Vert }_2,\angle ({\mathbf{n}}_i,\mathbf{d}),\angle ({\mathbf{n}}_j,\mathbf{d}),\angle ({\mathbf{n}}_i,{\mathbf{n}}_j))$$

$$p(\mathbf{m},\alpha |{\mathbf{s}}_r,{\mathbf{s}}_i)$$

$$=\sum _{k}p(\mathbf{m},\alpha |{\bar{\mathbf{f}}}_k)p({\bar{\mathbf{f}}}_k|\mathbf{f})$$

$$V(\mathbf{m},\alpha )=\sum _{i}p(\mathbf{m},\alpha |{\mathbf{s}}_r,{\mathbf{s}}_i)$$

$$({\mathbf{m}}_r^{\ast },{\alpha }_r^{\ast })=\underset{\mathbf{m},\alpha }{\mathrm{argmax}}{V}_r(\mathbf{m},\alpha )$$

$$\Xi ({\mathbf{\theta }}_i)=\frac{1}{N_M}\sum _j^{N_M}\{\begin{array}{ll}1,& \Vert {\mathbf{\theta }}_i^{-1}\circ {\mathbf{m}}_j-{\mathbf{s}}_k(j))\Vert <{\tau }_{\theta }\\ 0,& otherwise\end{array}$$

$$=1-\frac{\text{(Model Surface Area)*(1-Occlusion)}}{\text{(Scene Surface Area)}}$$

Full text

1 Introduction

3D reconstruction involves the recovery of digitized object or scene using a 2D/3D sensor, typically through multiple acquisition steps. From reverse engineering to industrial inspection, its applications are plentiful. Due to such wide use, from the early days of vision, it attracted significant attention of both research community and industry [24, 7].

Despite the huge demand, many marker-free approaches based solely on 3D data either involve acquisition of ordered scans[31, 21], or follow the de-facto standard pipeline [19] in case of unordered scans. The former suffers from the requirements of redundant depth capture with large overlap and scenes with very little clutter or occlusions. Due to the volumetric nature of scan fusion, such techniques also do not scale well to large objects while retaining high precision. The latter exploits 3D keypoint matching of all scans to one another, alleviating the order constraint. Thanks to 3D descriptors, it could well operate in full 3D. Yet, matching of scans to each other is an $O(N^{2})$ problem and prevents the methods from scaling to an arbitrary number of scans. In addition, neither of those can handle scenes with extensive dynamic clutter or occlusions.

Nowadays, with the capability of collecting high quality, large scale and big data, it is critical to offer automated solutions for providing highly accurate reconstructions regardless of the acquisition scenarios. In this paper, we tackle the problem of 3D instance reconstruction from a handful of unorganized point clouds, where the object of interest is large in size, texture-less, surrounded by significant dynamic background clutter and is viewed under occlusions. Our method can handle scenes between which no single transformation exists, i.e. the same objects appear in different locations, such as the one in Fig. 2. We also do not impose any constraints on the order of acquisition. To solve all of these problems simultaneously, we make use of the reasonable assumption that a rough, nominal 3D CAD model prior of the object-to-reconstruct is available beforehand and propose a novel reconstruction pipeline. Such assumption of a nominal prior is valid for many applications especially in industry, where the objective is to compare the reconstruction to the designed CAD model. Even for the cases where this model does not exist, one could always generate a rough, inaccurate mesh model with existing methods, e.g. KinectFusion [31], to act as a prior. Note that, due to manufacturing errors, sensor noise, damages and environmental factors, physical instances deviate significantly from the CAD models and the end-goal is an automatic algorithm to accurately recover the particular instance of the model. With the introduction of the prior model, we re-factor the standard 3D reconstruction procedures via multi-fold contributions. We replace the scan-to-scan matching with model-to-scan matching resulting in absolute poses for each camera. Unlike the case in object instance detection where false positives (FP) are tolerable, object instance reconstruction is easily jeopardized by the inclusion of a single FP. Therefore, one of our goals is to suppress FP, even at the expense of some true negatives. To achieve this, we contribute a probabilistic Local Implicit Shape Model (LISM) formulation for the object instance detection and pose estimation, accompanied by a rigorous hypotheses verification to reject all wrong pose candidates. This matching is followed by automatically segmenting out the points belonging to the object and transforming them back onto the model coordinate frame. Doing this for multiple views results in roughly aligned partial scans in the CAD space. To fully recover the exact object, the CAD prior is then discarded (as it might cause undesired bias) and a global multi-view refinement is conducted only to optimize the camera poses.

In global scan registration, the creation of a pose graph indicating which scans can be registered to each other is required. The typical complexity of obtaining this graph is $O(N^{2})$, where all scans are matched to one another. We profit from the CAD prior and contribute by automatically computing this graph, in which only cameras sharing significant view overlap are linked. This reduces the complexity to $O(N)$, and robustifies the whole pipeline.

The entire procedure is made efficient so that large scans are handled in reasonable time. Exhaustive evaluations demonstrate high accuracy regardless of the size of the objects, clutter and occlusions.111Our suppl. video is under: https://youtu.be/KPA_8BNuOvg

2 Prior Art

Arguably, the most wide-spread 3D reconstruction methods are KinectFusion[31] and its derivatives [9, 21, 37]. These methods have been successful in reconstructing small isolated objects, but their application is not immediate when the size increases, or clutter and occlusions are introduced [32]. Due to extensive usage of signed-distance fields, they are bound to depth images and a sequential acquisition.

Abundance of works exists in multi-view global alignment from multiple 3D unorganized point clouds [2, 10, 13, 12, 43, 47, 38, 17, 40, 22, 8, 12, 46]. These methods assume the scans to be roughly initialized and reasonably well-segmented. They, in general, handle slight synthetic noise well enough, but they do not deal with cluttered and occluded data. Another track of works try to overcome the aforementioned constraints by using keypoint detectors and matching descriptors in 3D scans. These methods operate on a subset of points during matching. One of the pioneering works proposing a feature agnostic, automatic and constraint-free algorithm is the graph based in-hand scanning from D. Huber and M. Hebert [19]. The authors set a baseline for this family of methods. Novatnack and Nishino [33] developed a scale dependent descriptor for better initialization and fused it with [19] to assess the power of their descriptor. Yet both of these relied on range image data. Mian et. al. [28] proposed a tensor feature and a hashing framework operating on meshes. Fantoni et al. [14] uses 3D keypoint matching as an initial stage of multiview alignment to bring the scans to a rough alignment. Zhu et. al. [47, 49] as well as Liu and Yonghuai [27] use genetic algorithms to discover the matching scans and use this in global alignment context. These stochastic schemes are correspondence free but slow. Similar to  [28], Zhu et. al. [48] devises a local-to-global minimum spanning tree method to align the scans. A majority of these automatic alignment procedures suffer from increased worst case complexity of $O(N^{2})$, where $N$ is the number of views. Moreover, since there is no integrated segmentation, the registration procedure cannot handle clutter and occlusions.

Use of CAD models in reconstruction is not novel by itself. Savarese et. al. [45] enrich the multiview reconstruction from 2D images with a CAD prior. Guney and Geiger [18] use object knowledge to resolve the stereo ambiguities. Birdal et. al. use models in triangulation by registration [4]. Other works [26, 44, 50] use CAD prior to detect generic object classes. Our approach differs from all of those in the sense that we use proxy instance priors for initial alignment of scans and then operate directly on 3D points.

Salas et. al. [36] propose SLAM++ using object priors to constrain a SLAM system. Our work is differentiated from theirs in the sense that we perform instance reconstruction using the CAD prior, and not SLAM. In our setting, the background as well as the object is allowed to change dynamically between different acquisitions.

3 Method

Given a set of unstructured and unordered 3D scenes $\{\mathbf{S}_{i}\}\in\mathbf{S}$, we seek to find a set of transformations $\{\mathbf{T}_{i}\}\in SE(3)$ so as to stitch and reconstruct a global model $\mathbf{S}_{G}$:

[TABLE]

$\mathbf{T}\circ\mathbf{S}$ applies transformation $\mathbf{T}$ to the scene $\mathbf{S}$. In this setting, both the transformations $\{\mathbf{T}_{i}^{0}\}\in SE(3)$ and the global model $\mathbf{S}_{G}$ are unknown and we do not assume known initialization. Due to the lack of a common reference frame and apriori information about $\{\mathbf{S}_{i}\}$, obtaining the set $\{\mathbf{T}_{i}^{0}\}$ typically requires $O(N^{2})$ worst case complexity, where all the scene clouds are matched to one another to obtain the relative transformations aligning them. To better condition the problem and reduce its complexity, we introduce the supervision of a CAD proxy $\mathbf{M}$ in form of a mesh model and re-write Eq. (1):

[TABLE]

where $\mathbf{T}_{i}^{M}\in SE(3)$ is the transformation from the scene to the model space, such that the segmented scene points $(\mathbf{S}_{i}|\mathbf{M})$ come to the best agreement. To estimate $\{\mathbf{T}_{i}^{M}\}$, we follow a two stage technique. First, a rather approximate estimate $\{\mathbf{\tilde{T}}_{i}^{M}\}$ is made by matching the CAD model to a single scene. Note that this time, the set $\{\mathbf{\tilde{T}}_{i}^{M}\}$ can be computed in $O(N)$, since it only requires CAD to scan alignment. However, because scene clouds suffer from partial visibility, noise and deviations w.r.t. the CAD model, the discovery of the pose of the model in the scans provides only rough initial transformations to the model coordinate frame. For this reason, as the final stage, the CAD prior is disregarded and the scans are globally refined, simultaneously. This lets us reconstruct configurations deviating significantly from the CAD prior.

Our procedure of multi-view refinement is similar to  [14], where a global scheme for scan alignment is employed. Let $\mathbf{S}_{1},\dots\mathbf{S}_{M}$ be the set of scans that are to be brought in alignment. To generalize and formalize the notation for registrations of all point clouds to each other, we maintain a directed pose graph in form of an adjacency matrix $A\in\{0,1\}^{M\times M}$, such that $A(h,k)=1$ iff cloud $\mathbf{S}_{h}$ can be registered to cloud $\mathbf{S}_{k}$. Let $\bm{\theta}=(\bm{\theta}_{1},\dots,\bm{\theta}_{M})$ be the absolute camera poses of each view. The alignment error between two clouds $\mathbf{S}_{h}$ and $\mathbf{S}_{k}$ then reads:

[TABLE]

where $\{p_{i}^{h}\rightarrow q_{i}^{h}\}$ are the $N_{h}$ closest point correspondences obtained from the clouds $\mathbf{S}_{h}$ and $\mathbf{S}_{k}$. The point-to-plane distance $d(\cdot,\cdot)$ is defined to be:

[TABLE]

with $n^{q}_{i}$ referring to the normal associated to point $q_{i}$. $\mathbf{R}$ and $\mathbf{t}$ are the components of the pair transformation $\{\mathbf{R}\in SO(3),\mathbf{t}\in\mathbb{R}^{3}\}$. The overall alignment error, which we want to minimize at this stage, is obtained by summing up the contribution of every pair of overlapping views:

[TABLE]

where $\rho$ is the robust estimator. The final absolute poses are the result of the minimization $(\bm{\theta}_{1},...,\bm{\theta}_{M})=\operatornamewithlimits{argmin}_{\bm{\theta}}(E)$, and align the $M$ clouds in a least squares sense. In contrast to the pairwise registration error in Eq. (3), which has closed form solution for the relative transformation $\bm{\theta}$, there are no closed form solutions in the multiview setting. Therefore, we use a non-linear optimization procedure, Levenberg Marquardt. The rotations are parameterized with angle-axis representation $(\mathbf{w}\in\mathbb{R}^{3},\phi)$. We constrain the frame with the highest number of points found on the CAD model to be static and update (solve for) the rest of the poses. In practice, this leads to faster convergence. Note that, in contrast to the methods that exploit pairwise registration, our poses are absolute and do not suffer from drifts or tracking artifacts. We also do not require a conversion from relative poses to absolute ones, which are usually obtained by the computation of a minimum spanning tree or shortest paths over the pose graph [16, 19]. This property eases the implementation and reduces errors, that are to be encountered in usual heuristics.

Due to the accuracy requirements, unlike [14], we omit using distance transforms at this stage. We rather use speeded up KD-Trees to achieve exact nearest neighbors [30]. Since we optimize over the poses, and not over 3D points, the trees are built only once in the beginning and all closest point computations are done in the local coordinate frame of the view of interest. This is important for efficiency. For reasons of accuracy, we use analytical Jacobians. As cloud sizes become large, this optimization exhibits significant computational costs. This is why, a priori sampling plays a huge role, where we use $\approx$ 20k to 30k points per scan, distributed evenly in space.

To summarize, our key contribution lies in obtaining $\{\mathbf{T}_{i}^{M}\}$ in a robust, efficient and accurate manner. We will now show how to compute the rough alignment $\{\mathbf{\tilde{T}}_{i}^{M}\}$ and the pose graph (adjacency matrix) $A$.

3.1 Locally Implicit Models for Estimating $\{\mathbf{\tilde{T}}_{i}^{M}\}$

While using any method, which is capable of handling 3D points, e.g. [20, 42, 28, 41, 34], is possible, we mainly follow the Geometric Hashing of Drost et al. [11] and Birdal and Ilic [6] due to efficiency and robustness to clutter and occlusions. Yet, we introduce a more effective probabilistic formulation, inspired by the implicit shape models [23].

Model Description

In the first stage, we generate a pose invariant codebook encoding all possible semi-global structures that could be found on the CAD model. We represent this semi-global geometry via simple point pair features (PPF) of oriented point pairs $(\mathbf{m}_{i},\mathbf{m}_{j})$:

[TABLE]

where $\mathbf{d}=\mathbf{m}_{i}-\mathbf{m}_{j}$, $\mathbf{n}_{i}$ and $\mathbf{n}_{j}$ are the surface normals at points $\mathbf{m}_{i}$ and $\mathbf{m}_{j}$. $\angle(\cdot,\cdot)$ is the angle operator. The complete set of such features $\mathbf{F}=\{\mathbf{f}_{ij}\}$ for the prior CAD model is collected and quantized to generate the codebook: $\hat{F}$. We use our codebook to relate a feature $\mathbf{f}$ (key) to a set of oriented references points $\{(\mathbf{m}_{i},\mathbf{m}_{j})\}$ (stored in buckets) and build the global model description as an inverted file i.e. a hashtable $\mathbf{H}$. Thus, each bucket in the codebook contains self-similar point pairs extracted from the CAD model. Whenever a pair from the scene is matched to one in the model, their normals at the reference points are aligned. Then, the full pose of the object can be obtained once the rotation angle $\alpha$ around the normal is known. This can be done by aligning Local Coordinate Frames (LCF) constructed from matched pairs. Thus, instead of storing the full PPF, we store only this local parameterization $\{\mathbf{m}_{r},\alpha\}$ composed of the model reference point $\mathbf{m}_{r}$ and rotation angle $\alpha$. A pair correspondence resolves the full 6DOF pose and what is left is to retrieve the matching pairs $\{\mathbf{s}_{r},\mathbf{s}_{i}\}$ and $\{\mathbf{m}_{r},\mathbf{m}_{i}\}$. We now give a novel way to do this.

Probabilistic Formulation

During detection, a new point cloud scene $\mathbf{S}$ is encountered and downsampled to a set of points $\mathbf{S}_{D}=\{\mathbf{s}_{r}\}$, some of which are assumed to lie on the object. The sampling also enforces spatial uniformity (see our suppl. material). We fix a reference point $\mathbf{s}_{r}$ and pair it with all the other samples $\{\mathbf{s}_{i}\}$. Each pair makes up a PPF $\mathbf{f}_{ri}$. The original method [11] associates $\mathbf{f}_{ri}$ to a unique key and can not account for the quantization errors that inevitably happen due to the noise. To circumvent these quantization artifacts, resulting from the hard assignment in  [11], we quantize $\mathbf{f}_{ri}$ to $K$ different bins ($K>1$), activating different codebook entries as in ISM. This soft quantization results in possibly matching buckets $\mathbf{\bar{F}}_{ri}=\{\mathbf{\bar{f}}_{1}..\mathbf{\bar{f}}_{K}\}$. $\mathbf{\bar{F}}_{ri}$ indexes the buckets of $\mathbf{H}$, with weights $p(\mathbf{\bar{f}}_{k}|\mathbf{f}_{ri})$. For each matching bucket, we collect the valid interpretations $p(m,\alpha|\mathbf{\bar{f}})$, inversely proportional to the size of the bucket $N_{b}$, denoting the probabilities of particular pose configuration, given the quantized feature. Formally:

[TABLE]

with $p(\mathbf{\bar{f}}_{k}|\mathbf{f})=\frac{1}{K}$ and $p(m,\alpha|\mathbf{\bar{f}})=\frac{1}{N_{b}}$ being uniformly distributed. This probability is actually the prior on the PPF of the particular object and can be computed differently accounting for the nature of the object geometry using a suited distribution. At this point, the gathered pair representations for a particular scene reference point are sufficient to recover for the object pose. However, due to outliers, some of these matches will be erroneous. Therefore, a 2D voting scheme is employed, locally for each scene reference point $\mathbf{s}_{r}$. The voting space is composed of the alignment of the LCF $\alpha$ as well as the model point correspondence $\mathbf{m}$:

[TABLE]

For each $\mathbf{s}_{r}$, there is a voting space $V_{r}(\mathbf{m},\alpha)$, from which the best alignment is extracted as:

[TABLE]

Each such $(\mathbf{m}^{*}_{r},\alpha^{*}_{r})$ corresponds to a pose hypothesis. This is similar to performing Generalized Hough Transform (GHT) on reference point level locally and is the reason why we attribute the name Local ISM to our method. After all pose hypotheses are extracted, as the maxima in the local spaces, the poses are clustered together to assemble the final consensus, further boosting the final confidence.

Hypotheses Verification and Rejection

Devised matching theoretically generates a pose hypothesis for each scene reference point, which is assumed to be found on the model. There are typically $\sim 400-1000$ such points, reducing to  50 poses after the clustering, where the close-by poses are grouped together and averaged. Still, as many hypotheses as the number of clusters remain to be verified and the best pose is expected to be refined. In our problem of instance reconstruction it is critical that no false positive pose hypotheses survives. For this reason we introduce a rigorous hypothesis verification scheme. The effective verification requires fine registration, while efficient registration requires as few poses as possible. This creates a chicken and egg problem. We address this issue via a multi-level registration approach. In the first stage, sparsely sampled scan points are finely registered to the model using the efficient LM-ICP [15] variant of Iterative Closest Point (ICP) registration [3]. We also build a 3D distance transform for fast nearest neighbor access. Our sparse LM-ICP requires only 1ms per hypothesis, allowing us to verify all the hypotheses. We define the hypothesis score to be:

[TABLE]

where $\bm{\theta}_{i}$ is the pose hypothesis and $\mathbf{s}_{k}(j)$ the closest sampled scene point to transformed model point $\bm{\theta}_{i}^{-1}\circ\mathbf{m}_{j}$. Intuitively, this score reflects the percentage of visible model points. The surviving poses are then sorted, taken to the next level and densely refined. This coarse to fine scheme is repeated for 3 levels of the pyramid. Finally, a dense registration is performed to accurately obtain the final pose.

Until this stage the surface normals are excluded from the fine registration process. We do this intentionally, to use them as a verification tool. Following registration, we check the surface consistency between the scene and the model. To do so for each scene point, the surface normal of the closest model point is retrieved. A scan is only accepted if a majority of the normals agree with the model. While this procedure can result in potentially good detections being removed (due to scene deviations), it does not allow false positives to survive as shown in Sec. 4.

3.2 Computing Pose Graph $A$ and Live Feedback

Any global optimization algorithm requires an adjacency graph $G=(V,E)$, which encodes the existence of overlap between camera views. The nodes of this sparse graph contain the cameras $V=\{C_{1}..C_{N}\}$, whereas an edge $E_{ij}$ is only created between nodes $(C_{i},C_{j})$ if they share significant overlap. An absolute pose $\mathbf{T}_{i}$ is associated to each node and a relative pose $\mathbf{T}_{ij}$ is to each edge. Traditionally, this requires pair-wise overlap computation between all cameras. While a naive approach would involve linking the cameras, whose centers are found to be close, this is by no means a guarantee for shared overlap. Therefore, we present a more accurate approach, without sacrificing efficiency, thanks to the availability of the CAD model.

Consider the voxel grid index $\mathbf{D}$ of model $\mathbf{M}$ as in Fig. 5(a). Each segmented scene point $\mathbf{s}_{i}^{\prime}\in\mathbf{T}^{-1}_{i}\circ\mathbf{S}_{i}$ is mapped to a voxel $D_{k}$, which stores a set of cameras $\{C_{i}\}$ observing it. Whenever the point $\mathbf{m}_{k}$ belonging to the voxel $D_{k}$ is visible in the camera $C_{j}$, this camera is added to the list of cameras seeing that model point. Each list stores unique camera indices. From that, we compute the histogram of pairwise overlaps (HPO) as shown in Fig. 5(b).

While all the possible edges are now generated (as the bins in HPO), it is not recommended to use all these in the multiview alignment i.e. the overlap might be little, causing a negative impact. Instead, we adopt an iterative algorithm, similar to hysteresis thresholding. First, HPO is sorted with decreasing overlap (Fig. 5(c)). Next, two thresholds $\alpha_{l}$ and $\alpha_{h}$ are defined. All pairs with overlap less than $\alpha_{l}$ are discarded. All cameras with overlap larger than $\alpha_{h}$ are immediately linked and edges are constructed in the graph. If, at this stage, the graph is not connected, we start inserting edges from the remaining bins of HPO into $A$ until either the connectivity or the threshold $\alpha_{l}$ is reached. This is illustrated in Figures 5(c) and 5(d). If the final graph is still not connected, we use the largest connected sub-graph, to ensure optimize-ability. For efficient online update, a modified union-find data structure is used to store the graph and dynamically insert edges when new views are encountered. Unlike quadratic complexity of the standard pose graph creation methods, ours has linear complexity.

Live Feedback

Due to the connected-ness of pose graph, our method is able to keep track of the overlap between all the point clouds, at all times, informing the user whenever graph disconnects or overlap is small. The complement of the already reconstructed part reveals the unscanned region, which is also fed back to the operator. Incoming scans directly propagate and form links in the pose graph, allowing online response to the user’s actions.

4 Experimental Evaluation

We evaluate our method against a set of real datasets acquired by laser scanners and structured light sensors. The CAD models we work with might contain uneven distribution of vertices or inner geometry. We always eliminate the inner structure by thresholding the ambient occlusion values [29] before the models are re-meshed [25]. At detection time, a relative model and scene sampling distance of $d=\tau diam(\bm{M})$ is used, where $0.05\geq\tau\geq 0.025$ depending on the object. We also adjust another threshold on the distance to consider a scene point to be on the model based on the sensor quality. For accurate scanners we use $1.5mm$, while for less accurate ones $0.5cm$. This does not affect the segmentation, but the hypothesis verification.

Mian Dataset

We first compare the reconstruction quality on Mian Dataset [28]. This dataset includes 50 laser scanned point clouds of 4 complete 3D objects, with varying occlusion and clutter. The objects change locations from scan to scan, creating dynamic scenes. The clutter and background also varies as the objects appear together with other different ones in each scene. We quantify this dynamic clutter by relating it to the provided occlusion values:

[TABLE]

and provide it in Table 1 for each object. The models present in the scenes are provided by [28] to act as ground truth. We do not perform any prior operation to the scenes such as segmentation or post-processing except meshing via SSD [39]. For Parasaurolophus and Chicken objects, the pose graph becomes disconnected and therefore, we optimize individually the two sub-components and record the mean. We also report the number of scans in which the model is detected and verified. Not every model is visible in every scan. In the end, our mean accuracy is well below a millimeter, where the used sensor, Minolta Vivid 910 scanner, reports an ideal accuracy of $\sim 0.5$mm. We are also not aware of any other works, reporting reconstruction results on such datasets. Fig. 6 visualizes our outcome, and Table 1 shows our reconstruction accuracy both prior to and after the optimization. While our error is quantitatively small, the qualitative comparison also yields a pleasing result, sometimes being superior even to the original model.

The detection performance of a basic variant of our method has already been proven to be robust on this dataset [11]. Figures 7(a) and 7(b) provide PR-curves for LISM and the hypothesis verification. Note that although LISM already performs well, our verification clearly improves the distinction between a match vs false positive. Using a simple threshold, we could obtain $100\%$ precision without sacrificing the recall. Thus, our score threshold, combined with the normal consistency check manages to reject all false hypotheses, at the expense of rejecting a small amount of TP.

Toy Objects Dataset

Since our objective is to assess the fidelity of the reconstruction to the CAD model, we opt to use the objects from the 3D printed dataset [37]: Leopard, Teddy and Bunny and Tank (See Fig. 8). The diameters of objects vary in the range of $15-30cm$. The print accuracy is up to $50\mu$ (micro-meters), well sufficient for consideration as ground truth. To capture the real scenes, a home-brew, high accuracy phase-shift sensor, delivering $<$0.4mm point accuracy is chosen. We sample up to 10 scans per object, taken out of a 100 frame sequence. To disrupt the acquisition order, we randomly shuffle this subset and apply our reconstruction algorithm. Next, we compute the CAD-to-reconstruction distances in CloudCompare [1]. We do not explicitly register our reconstruction to CAD model, because we already end up on model coordinate frame (Having the result in the CAD space is a side benefit of our approach). Moreover, we use the original 100-frame, ordered sequence as an input to standard reconstruction pipelines such as Kinect Fusion [35], Kehl et. al. [21] (also uses color) and Slavcheva et. al. [37] all of which require a temporally ordered set of frames, with a large inter-frame overlap. All of these algorithms take depth image as input, whereas ours uses the unstructured 3D data and the model.

Our results on this dataset are shown in Tab. 2 (Ours) when original CAD is used. We also report the results when KinectFusion (KF) prior is used (Ours-KF). The individual error distribution of the objects are shown in Fig. 7(c). Because our method does not suffer from drift and computes absolute poses all the time, although we use 10 times less scans, we are still 2-4 times more accurate then conventional methods. This also shows that our method could retain the good accuracy of the sensor.

Next, we augment this dataset with further scenes of the same objects, such that clutter and occlusions are present. Some shots are shown in Fig. 8 (mid-row). Our reconstruction accuracy (Ours-CO) is shown in Tab. 2 for different objects. These results are still better than or close to Sdf2Sdf [37]. Due to inclusion of some outliers, our results get slightly worse than the one in no clutter, yet they are still acceptable. However, none of the other approaches can run on this new set due to the existence of significant outliers.

In a further experiment, we gradually decimate the toy models down to a mesh of $\approx$500 vertices. We exclude tank as the decimation has little effect on the planarities. As shown in Fig. 7(d), even though the CAD prior gets very crude, we are still able to achieve a reasonable reconstruction, as long as the CAD model is still detectable in the scenes. Note that, results of KF prior is plotted in dashes as it is also a form of rough mesh approximation. Furthermore, Fig. 9 visually compares our reconstruction to the state of the art on the tank object. Because we do not use smoothing voxel representations (such as SDF), our method is much better at preserving sharp features at the model edges.

Dataset of Large Objects

Finally, we apply our pipeline to quality inspection of real gas turbine casings and large objects. In this real scenario, CAD models come directly from the manufacturer. Due to space constraints, we summarize the data modality in Tab.3. The manufactured parts deviate significantly from the ideal model due to manufacturing and we scan them in the production environment within clutter and occlusions. With such large objects and little resemblance of the CAD prior, obtaining ground truth becomes a challenging task. Thus, we use a photogrammetry (PG) system [5, 4] to collect a sparse set of scene points, by attaching markers on the objects. We capture many images (see Tab.3) from different angles and run Linearis 3D software for bundle adjustment to obtain sparse ground truth. For Ventil object, we also use Surphaser software for reconstruction using external markers. Both Surphaser and our outputs are compared to the PG data in Tab. 3. The mean errors are obtained by CloudCompare [1]. We also provide running times of the individual stages. As seen, our accuracy outperforms an industry standard solution, Surphaser Software, by a margin of $38\%$ on Ventil object. The performance in objects of varying sizes indicate that our reconstruction method is applicable from small to large scale while maintaining repeatability. Fig. 10 presents further qualitative results on our reconstruction of the Turbine and Sofa objects. Please consult the supplementary material for more evaluations.

Limitations

Due to the nature of PPF matching, our approach requires objects with rich geometry. Symmetric objects are also problematic due to ambiguity in pose estimation. Last but not least, currently, there is no mechanism to handle mis-detections. Yet, mis-detections are hardly a problem when the score threshold is reasonably high. This way, we detect in less scenes but avoid mistakes.

5 Conclusions

We proposed reconstruction-via-detection framework, as an alternative perspective to robust 3D instance reconstruction from unconstrained point cloud scans. Our framework integrates probabilistic object detection, hypothesis verification, pose graph construction and multi-view optimization. Such a scheme allowed us to deal with problems of dynamic clutter, occlusion and object segmentation. Moreover, the computational cost is reduced, due to model-to-scan alignment. To the best of our knowledge, this is the first method, capable of reconstructing instances within clutter and occlusions, without explicit segmentation.

As a future direction, we like to take care of confusions stemming from rotational symmetries by optimizing over possible global alignments of the scans. We also plan to extend our method to robotics via next-best view prediction.