Hierarchical Techniques to Improve Hybrid Point Cloud Registration
Ferran Roure
1
, Xavier Llad
´
o
1
, Joaquim Salvi
1
, Tomislav Privani
´
c
2
and Yago Diez
3
1
ViCOROB Research Institute, University of Girona, Girona, Spain
2
Faculty of Electrical Engineering and Computing, University of Zagreb, Zagreb, Croatia
3
GSIS Tokuyama Lab., Tohoku University, Sendai, Japan
Keywords:
Point Cloud Matching, Algorithms and Data Structures, Regular Grid, Hierarchical Approach.
Abstract:
Reconstructing 3D objects by gathering information from multiple spatial viewpoints is a fundamental prob-
lem in a variety of applications ranging from heritage reconstruction to industrial image processing. A central
issue is known as the ”point set registration or matching” problem. where the two sets being considered are
to be rigidly aligned. This is a complex problem with a huge search space that suffers from high computa-
tional costs or requires expensive and bulky hardware to be added to the scanning system. To address these
issues, a hybrid hardware-software approach was presented in (Pribani
´
c et al., 2016) allowing for fast soft-
ware registration by using commonly available (smartphone) sensors. In this paper we present hierarchical
techniques to improve the performance of this algorithm. Additionally, we compare the performance of our
algorithm against other approaches. Experimental results using real data show how the algorithm presented
greatly improves the time of the previous algorithm and perform best over all studied algorithms.
1 INTRODUCTION AND
PREVIOUS WORK
The registration or matching of objects is a funda-
mental problem in areas such as computer vision
(da Silva Tavares, 2010) and computational geome-
try (Agarwal et al., 2003; Diez and Sellar
`
es, 2011)
with applications areas as diverse as medical imaging
(Oliveira and Tavares, 2014), road network match-
ing (Diez et al., 2008) or mobile phone apps (Pro-
jectTango, 2016; StructureSensor, 2016). A typical
instance of the problem in 3D is that of object recon-
struction. This requires gathering 3D object informa-
tion from multiple viewpoints. Acquisition devices
are used to capture discrete points in the surfaces of
objects which are then represented as point clouds.
Since every view usually contains 3D data corre-
sponding to a different spatial coordinate system it is
necessary to transform the information from all the
views into a common coordinate system (see Figure
1 for a graphical example). From a formal stand-
point, two such systems are related through three an-
gles of rotation and a three-dimensional translation
vector. In order to register two objects represented
as point clouds, a minimum of three point correspon-
dences are needed to determine a 3D rigid motion.
Thus, the number of possible correspondences is in
O(n
6
), making the design of algorithms that can nav-
igate this search space efficiently an important issue.
For the purpose of the current discussion, al-
gorithms can be divided into two main categories:
coarse and fine matching algorithms (D
´
ıez et al.,
2015). Coarse registration algorithms do not require
an initial pose and aim at ”producing an estimate that
is good enough for some fine registration methods
to start from” (Besl and McKay, 1992; Aiger et al.,
2008). Fine registration methods provide the final
registration (Besl and McKay, 1992; Rusinkiewicz
and Levoy, 2001).
Concerning coarse registration, most approaches
aim at pure software solutions. Different strategies
exist to improve efficiency. For instance, approaches
based on shape descriptors determine point corre-
spondences based on local shapes measures (Mian
et al., 2010; Roure et al., 2015b). Other strategies
include data filtering (Rusinkiewicz and Levoy, 2001;
D
´
ıez et al., 2012) or devising novel searching strate-
gies to speed up the search for correspondences be-
tween points (Aiger et al., 2008). There are meth-
ods which expect as the input of the 3D reconstruc-
tion system not only 3D point position data, but also
the normal vectors of every 3D point (Makadia et al.,
2006). Another generic way to increase the efficiency
of any parallelized method is to use GPU implementa-
44
Roure F., Lladøs X., Salvi J., PribaniÄ
˘
G T. and Diez Y.
Hierarchical Techniques to Improve Hybrid Point Cloud Registration.
DOI: 10.5220/0006112600440051
In Proceedings of the 12th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP 2017), pages 44-51
ISBN: 978-989-758-225-7
Copyright
c
2017 by SCITEPRESS – Science and Technology Publications, Lda. All rights reserved
Figure 1: Registration example, two views from the bust model are brought to the same coordinate system by rigid motion µ.
tions (Choi et al., 2011). Perhaps the most significant
contributions in terms of computational gain made re-
cently correspond to searching strategies (Aiger et al.,
2008) (Mellado et al., 2014).
Coarse matching can also be tackled with the as-
sistance of hardware. At its most basic level, the
acquisition system can be upgraded with dedicated
parts to gain information on some of the parameters
(Matabosch et al., 2008; Martins et al., 2015). This
type of solutions (usually involving the installation of
robot arms and/or turntables) demands complex in-
stallations and are often expensive.
A recent trend (ProjectTango, 2016; StructureSen-
sor, 2016) seeks to use sensors from mobile devices
in order to help registration. These sensors are com-
monly available and less expensive, circumventing
many of the previous problems. The goal in this case
is to propose hybrid 3D registration methods which
combine the best features of software and mechanical
approaches. Significantly, (Pribani
´
c et al., 2016) pre-
sented a hybrid algorithm with a hardware part based
on smartphone technology that managed to gain ac-
cess to rotation data that could then be used to search
for the remaining translation part of the rigid motion
by software means.
The idea of disaggregating the rotation and trans-
lation part was not new and can be found, for example
in (Larkins et al., 2012). Once the rotation part of the
problem is solved (either by using hardware data as
in the former reference or by software means as in
the later), what remains is determining the translation
vectors that brings the two sets being registered closer
together. To solve this problem it is enough to find one
single correspondence between one point in each set
so that the resulting translation brings the sets close
enough for a fine registration to succeed. This yields
an immediate O(n) asymptotic cost for this version of
the problem.
In this paper we present an algorithm that extends
the work in (Pribani
´
c et al., 2016). By using the hard-
ware part developed in the mentioned reference, we
are able to focus on the software solution of the trans-
lation problem. We propose a hierarchical approach
that finds a coarse matching solution by selecting one
point in one set and determining a correspondence in
the other in the following way. First, the search is ini-
tialised by using the center of masses of the set. Then,
the search proceeds using a regular sample grid. Ini-
tially only the overlap between bounding boxes of the
sets is considered. Next, the sets are divided in regular
cells and the number of points in each cell is consid-
ered. Finally, the result of the coarse step of the algo-
rithm is determined by computing the residues con-
sidering the points in the sets.
The rest of the paper is organised as follows. Sec-
tion 2 introduces the paper that motivates this research
and provides details on the approach used in the cur-
rent work. The experiments in Section 3 illustrate the
validity of our approach and compare it with other
registration methods. This comparison includes not
only the original algorithm (Pribani
´
c et al., 2016) but
also two widely used registration methods: a) The
4PCS method, which is one of the most widely used
(Aiger et al., 2008), and b) its improved version, the
super4PCS method (Mellado et al., 2014) which is, to
the best of our knowledge, the fastest general-purpose
coarse matching algorithm to date. The paper ends
with a summary of the findings of the paper with spe-
cial attention to the most salient results reported in the
experiments in Section 4.
Hierarchical Techniques to Improve Hybrid Point Cloud Registration
45
2 MATERIALS AND METHODS
In this section we start by providing some details on
the algorithm that motivates this research. On the sec-
ond part we provide details on the new approach to the
problem.
2.1 Previous Algorithm
A pipeline for the registration problem where exist-
ing methods can be classified is presented in figure 2.
The algorithm presented in (Pribani
´
c et al., 2016) can
be described as a hybrid hardware-software coarse
matching algorithm.
More specifically, no filtering or detection steps
where used (although the algorithm does allow for
them) and the searching strategies part was divided
in two steps.
In the first step, the authors roughly determine the
rotation between the two sets by using a smart-
phone capable of providing 3D orientation data
(from the accelerometer and magnetometer sen-
sors). The sensors provide orientation angle data
that can be used to produce an orientation matrix
for the scanning system respect to a certain world
reference axis. These orientation matrices can be
composed from view to view to obtain the afore-
mentioned rough rotation correspondence.
In the second step, the rotationally aligned sets
are matched also for translation. As the rotational
alignment is expected to be noisy, so a robust
translation matching algorithm is required in or-
der for the subsequent fine registration algorithm
to succeed.
It is important to note that the data used for the
experiments in the reference where made available by
the same authors in (Roure et al., 2015a). This will al-
low us to produce reliable comparison results in sec-
tion 3 as well as focus on the improvement of the
translation part of the problem in the current work.
Consequently, what is left is to solve the translation
problem:
Once the two sets A and B have been regis-
tered up to rotation, the goal is to find a trans-
lation τ such that τ(B) is close enough to A in
terms of the mean Euclidean distance of the Near-
est Neighbouring (NN) point pairs between sets.
Close enough in this case stands for a pose that
allows the subsequent fine matching algorithm
(Rusinkiewicz and Levoy, 2001) to converge to
the best possible alignment without stalling at any
local minimum.
The search is initialised by determining a point in
set A for which a correspondence will be searched
for. In this case, the authors choose this point x
A
randomly among the 100 closest points to the cen-
tre of masses of set A.
The algorithm then searches for the best corre-
spondence for x
A
among all the points in set B.
To do this a grid-based greedy search is performed
that tries several possible translations. At every
iteration, the best translation is chosen by com-
puting the distance between A and each of the
proposed τ(B) and choosing the best. This step
is commonly referred to as residue computation.
The grid is then subsequently expanded around
the current best point and a new iteration starts.
Notice that with this strategy, the number of points
explored in the grid and, thus, the number of
residues computed, is constant for all executions.
However, for every residue computation, the time
needed will vary depending on how close the two
sets are.
After finishing the grid-based search, a translation
vector is outputted. This data is joined with the
rotation estimation obtained from the sensors and
the combination becomes the result of the match-
ing algorithm. Then the algorithm proceeds as de-
scribed in Figure 2 by running a fine matching al-
gorithm (Rusinkiewicz and Levoy, 2001).
2.2 Our Approach
In this section we provide details on the algorithm
being introduced. Mainly we propose a hierarchical
look at the sets being matched in order to avoid un-
necessary residue computations and, thus save com-
putation time. A graphical summary of our algorithm
can be found in Figure 3.
After obtaining the rotation data, the problem we
are left with is finding the translation τ that brings the
two sets being matched (A and B) as close together
as possible. A naive approach would be to choose a
point in set A and try all the possible correspondences
with all the poins in set B. This would have O(n) cost
(with n=|B|) which is already feasible in most cases.
The authors in (Pribani
´
c et al., 2016) realised how it is
not necessary to explore the whole search space and
that, by taking samples using a grid it was possible to
”zoom in” a good enough coarse solution so the sub-
sequent fine matching algorithm would produce the
best possible solution.
However, the algorithm used to explore the grid
treated all possible translation equally. The exact
same process was undergone by the first translation
tested than to the final one (which was much closer to
VISAPP 2017 - International Conference on Computer Vision Theory and Applications
46
FINE
MATCHING
COARSE MATCHING
DESCRIPTORS
SEARCHING
STRATEGIES
FILTERING
DETECTION
REFINEMENT
Figure 2: Scheme of the Registration Pipeline.
Figure 3: Hierarchical approach. In successive approximations of the software part of the coarse matching algorithm more
and more detailed information is considered. First, the algorithm is initialised by using centers of masses. Second, the overlap
volumes of the bounding boxes of the sets being matched are considered. Third, the number of points contained in a Regular
Grid is taken into account. Finally, full sets are used.
the final solution after having undergone several algo-
rithmic iterations). This resulted in a large number of
operations where the distance between two sets had
to be computed (residue computations). In our case,
we take this into account and look at the sets being
matched using varying levels of detail. For the sake
of simplicity from now on we will consider that each
new iteration increases the level of detail being con-
sidered.
The resulting algorithm follows:
Consider A and B to be registered up to rota-
tion. Find the translation τ such that τ(B ) is close
enough to A for the subsequent fine matching al-
gorithm to succeed.
In our case, our algorithm is stable enough so it
can be initialized directly by using the centres of
masses of the two sets (Figure 3, left). As the fol-
lowing steps optimize high level (bounding box)
overlap between the two sets, we can perform a
faster initialization. Consequently, x
A
is chosen
to be the centre of mass of set A and the search
grid of set B is built around the centre of mass of
set B .
In the first iteration of the grid-based search ((Fig-
ure 3, middle left), our algorithm only considers a
bounding box computed for each set: B(A ) and
B(B). For each grid point b the translation τ
b
of
vector b x
A
is computed and the volume overlap
between τ
b
(B(B)) and B(A ) is considered. All
the points in this first level of the grids are con-
sidered until the optimal volume overlap is com-
puted.
In the second iteration of this new grid-based
search (Figure 3, middle right), the two sets be-
ing matched are stored inside a 3D regular grid.
The bounding box of each set is divided in regu-
larly distributed cells and each point in the set is
simply assigned to the cell it belongs to. For each
cell, we annotate only the number of points stored
in it and we consider it to be the ”weight” of the
cell. With this we obtain a type of mid level repre-
sentation of each of the two sets that groups points
in terms of spatial proximity and summarises the
set as a number of weighted cubic regions. In this
case for each translation τ
b
considered we check
whether or not there are enough points in the cells
intersected by every translated cell. Finding the
best score in terms of possibly matched points
is the goal in this step. However, the bounding
box overlap values are required to remain within
a threshold of the value obtained in the previous
step.
In the third and final step of the grid-based search,
Hierarchical Techniques to Improve Hybrid Point Cloud Registration
47
(Figure 3, right), all the points in the sets are con-
sidered and the residues between the sets are com-
puted. As is usual in this type of computations, a
monte-carlo approach is used in order to speed up
these computations (D
´
ıez et al., 2012).
After finishing the grid-based search the algo-
rithm proceeds as is usual by running a fine
matching algorithm (Rusinkiewicz and Levoy,
2001) with the rotation data obtained from the
sensors and the translation data obtained from the
grid-based search.
3 EXPERIMENTS
In this section we present experiments with real data
that show how the algorithm presented in this paper
improves the behaviour of the algorithm used in (Prib-
ani
´
c et al., 2016). At the same time, we also compare
the algorithm presented in this paper to state of the
art point set matching algorithms in order to illustrate
the efficiency of our approach. The code for all the
algorithms considered was implemented in C++. All
experiments where run using a 33MHz processor un-
der a linux Ubuntu operating system.
Some significant improvement in the run-times re-
ported here for the algorithm by (Pribani
´
c et al., 2016)
and in the original paper can be observed. This is
mostly due to code optimization and parameter tun-
ing. Due to the fact that the algorithm presented
in this paper extends and improves that in (Pribani
´
c
et al., 2016) we were able to use some of the profil-
ing information studied to improve our code to also
improve that of (Pribani
´
c et al., 2016).
Consequently, and in order to keep the compari-
son fair, we present these improved results in this pa-
per. Additionally, this allows us to show clearly what
part of the improvement in running times respect to
the results previously reported correspond to general
code optimization and what part correspond to the use
of the hierarchical approach presented in this paper.
From now on, an for the sake of brevity, we will re-
fer to the previous algorithm as the regular grid algo-
rithm.
3.1 Data Used
The data used in this section corresponds to the
”bust” or ”mannequin” dataset used in (Pribani
´
c et al.,
2016) and made available in (Roure et al., 2015a).
This data can be downloaded from http://eia.udg.edu/
3dbenchmark. Using this data makes the compari-
son with the improved paper more meaningful while
the fact that it is publicly available ensures the repro-
ducibility of the experiments presented here.
The data consist of a set of 5 views from the ”bust”
model (see Figure 4). This corresponds to a real-
sized mannequin of a human body scanned with a 3D
structured-light system. See (Pribani
´
c et al., 2010;
Pribani
´
c et al., 2013) for more details on the model
and acquisition procedure. Each of the 5 views of the
model contain 450000 points. No post-processing
whatsoever was performed.
Consequently, this dataset presents quite a lot of
noise and the overlap between some of the views is
very low (ranging from 60-70% in consecutive views
to around 10% for the most distant views). This
represent a challenging scenario for any registration
method.
Figure 4: Left: bust0 view of Bust model. Right: Detail of
bust0 view.
The experiments consisted in registering the 5
available views each against all different views. This
provided us with 20 different registration scenarios.
Amongst these, 4 registration instances presented low
(around 10%) overlap, 6 presented medium (between
30 and 50%) overlap and the remaining 10 presented
high (approximately between 60 and 85% ) overlap.
All the results produced in this section were required
to meet these overlap percentages and later checked
manually to ensure correctness.
3.2 Runtime Improvement due to the
Hierarchical Approach
In order to evaluate whether or not the hierarchical
approach described in section 2 helps improve the
run-time performance of the algorithm, we run the
code-optimised version of the regular grid algorithm
against the algorithm that we are presenting. Table
1 presents results corresponding to five representative
registration examples. The first half of the table cor-
VISAPP 2017 - International Conference on Computer Vision Theory and Applications
48
responds to the regular grid method, the second half
of the table depicts the results of our new proposal.
Within each half of the table, the two initial rows and
the final row correspond to sets with high overlap, the
third row to sets with low overlap and the fourth to
medium overlap.
All registration instances where also checked for
correctness manually. The first column lists the views
involved in the registration, the second and third col-
umn contains information on the overlap obtained for
set A after coarse and fine alignment respectively.
The fourth and fifth column present times for the
coarse matching algorithms as well as the total time
(which includes the former as well as the time for fine
matching). All times are presented in seconds.
Table 1 shows how the proposed approach per-
forms faster than the regular grid algorithm. On aver-
age (over all views) the time needed by the new algo-
rithm was less than half that of the regular grid algo-
rithm. Notice how the overlap after coarse matching
is sometimes higher for the regular grid algorithm.
This happens due to this degree of overlap being
the only criteria that is considered while our approach
relies on other criteria to speed up the search (such
as bounding box overlap or coincidence of points in
grid cells). In any case, the small reduction in coarse
matching overlap does not affect the success of the
subsequent fine matching algorithm as can be seen in
the third column of the table.
3.3 Comparison With SOA Methods
In this section we study the performance of our al-
gorithm against state of the art point cloud match-
ing algorithms. Specifically, we consider, additionally
to the algorithm that motivated the current research,
(Pribani
´
c et al., 2016) two widely used registration
methods. The 4PCS method (Aiger et al., 2008) is
a widely used general-purpose point cloud matching
method that also counts with an improved version
called super4PCS (Mellado et al., 2014) which is, to
the best of our knowledge, the fastest general-purpose
coarse matching algorithm to date.
The first issue that needs to be addressed is that
of the nature of the methods being considered. The
two grid based methods are hardware-software hybrid
methods, so they rely on the fact that they can obtain
information on the rotation part of the problem and
take advantage of this to make the software part of the
algorithm much simpler (they only look for a transla-
tion). Conversely the two 4PCS-based methods are
actually looking for rotation as well as translation, so
they are exploring a larger search space. While we ac-
knowledge this, the point of hybrid methods is actu-
Figure 5: Run-times for: 4PCS algorithm (Aiger et al.,
2008), Super4PCS (Mellado et al., 2014), Improved Grid
(current paper) and Regular Grid (Pribani
´
c et al., 2016).
ally that the information that they get from hardware
provides an advantage over pure software methods.
In order to limit this as much as possible, we run the
4PCS-based methods both with the original sets and
also with the same rotation-aligned methods used by
the hybrid methods. We found out that the algorithms
were faster with the rotation aligned sets, so these are
the numbers that we report here.
Regarding parameter tuning and precision: Grid
based algorithms mainly needed to determine the size
of the grid. After trying 10 different grid sizes, we
found out that grids with very few points (six grid
points per iteration) did miss the correct result in some
cases. Consequently, we include results correspond-
ing to the fastest results among those grids that pro-
duced correct results (this corresponds to grids with 6
points per coordinate for a total of 18 points per grid
iteration). Conversely, 4PCS algorithm required quite
a lot of parameter tuning and were prone to missing
the correct result if the parameters were not set prop-
erly. The numbers presented here correspond to the
best running time that we could achieve after trying
several parameter configurations (so they correspond
to different parameter settings). Figure 5 presents run-
times for the four algorithms studied. For each of
them, data is separated in registration scenarios with
low overlap (first bar, in blue), medium overlap (sec-
ond bar, in red) and high overlap (third bar, in yellow).
All times are presented in seconds. Results show how
the rotation information obtained from hardware sen-
sors allows to make the software part of these algo-
rithms quite fast. Specifically, the previously existing
regular grid method outperforms the well-established
4PCS method and is the most robust method over-
all in the sense that it presents less relative differ-
ence in execution times between sets with high and
low overlap. The times of the 4PCS algorithm are
somewhat skewed by some registrations that are way
slower than the others. If we ignore these cases, the
running times of this algorithm become slightly in-
Hierarchical Techniques to Improve Hybrid Point Cloud Registration
49
Table 1: Details on the runt-time improvement obtained by the hierarchical approach introduced in the current paper.
Views Overlap % Coarse Overlap % Fine Coarse Time (s) Total Time (s)
Regular Grid
0 - 1 15.03% 86.36% 14.23 17.39
1 - 2 17.70% 72.24% 18.52 21.26
1 - 4 8.15% 9.87% 19.14 22.17
2 - 4 11.03% 43.38% 15.13 17.84
3 - 4 19.71% 76.53% 12.55 15.10
Our Approach
0 - 1 11.89% 86.34% 0.0087 3.40
1 - 2 17.44% 72.28% 0.010 3.87
1 - 4 3.81% 9.84% 9.014 12.24
2 - 4 11.03% 43.30% 7.63 10.11
3 - 4 15.28% 76.58% 3.63 7.13
ferior to those of the regular grid algorithm although
quite far from those of the super4PCS algorithm.
The algorithm presented in this paper is the fastest
of the four algorithms studied and outperforms (for
this particular type of problem) even the super4PCS
algorithm. In further detail, while the super4PCS is
the fastest algorithm in 5 of the 10 high overlap cases
(with an average total time of 3.97s for all the match-
ing process against the 4.01s average for our algo-
rithm), it also struggled to find a solution in 10 of the
20 cases. In these cases it failed to find the best solu-
tion and stalled under 5% overlap after fine matching.
After careful parameter tuning, it was possible to ob-
tain the best solution but the resulting executions took
longer. The resulting aggregate of the times of the
fastest parameter configurations leading to a correct
solution is what has finally been reported. All things
considered, the current paper obtained a 19.67% im-
provement over the super4PCS algorithm.
4 CONCLUSIONS
In this paper we have shown how the hierarchical ap-
proach (Figure 3) used to improve the translation de-
termination part of the hybrid algorithm presented in
(Pribani
´
c et al., 2016) results in reducing the aver-
age computation time to less than half. Results run
with real data show (Table 1, second column) how
this reduction is achieved at the price of some of
the overlap obtained after the coarse matching step.
This does not, however, reduce the algorithm accu-
racy after the refinement step. Additionally, we have
shown how hybrid algorithms can outperform two
well established coarse registration methods includ-
ing a 19% improvement over the super4PCS (Mellado
et al., 2014) algorithm which is, to the best of our
knowledge, the best pure-software, general-purpose
point cloud registration algorithm to date.
ACKNOWLEDGEMENTS
We want to thank the authors of the state of the art
algorithms considered for making their code publicly
available. Yago Diez is supported by the IMPACT
Tough Robotics Challenge Project of Japan Science
and Technology Agency.
REFERENCES
Agarwal, P. K., Har-Peled, S., Sharir, M., and Wang,
Y. (2003). Hausdorff distance under translation for
points and balls. In Proceedings of the Nineteenth An-
nual Symposium on Computational Geometry, SCG
’03, pages 282–291, New York, NY, USA. ACM.
Aiger, D., Mitra, N. J., and Cohen-Or, D. (2008). 4-points
congruent sets for robust pairwise surface registration.
In SIGGRAPH, volume 27(3), page 85.
Besl, P. J. and McKay, N. D. (1992). A method for regis-
tration of 3-d shapes. IEEE Transactions on Pattern
Analysis and Machine Intelligence, 14(2):239–256.
Choi, S., Kim, S., and Chae, J. (2011). Real-time 3d regis-
tration using gpu. Machine Vision and Applications,
pages 837–850.
da Silva Tavares, J. M. R. (2010). Image processing and
analysis: applications and trends. In AES-ATEMA#
8217; 2010 Fifth International Conference.
Diez, Y., Lopez, M. A., and Sellares, J. A. (2008). Noisy
road network matching. In International Conference
on Geographic Information Science, pages 38–54.
Springer Berlin Heidelberg.
D
´
ıez, Y., Mart
´
ı, J., and Salvi, J. (2012). Hierarchical normal
space sampling to speed up point cloud coarse match-
ing. Pattern Recognition Letters, 33:2127 – 2133.
D
´
ıez, Y., Roure, F., Llad
´
o, X., and Salvi, J. (2015). A quali-
tative review on 3d coarse registration methods. ACM
Computing Surveys (CSUR), 47(3):45.
Diez, Y. and Sellar
`
es, J. A. (2011). Noisy colored
point set matching. Discrete Applied Mathematics,
159(6):433–449.
Larkins, R. L., Cree, M. J., and Dorrington, A. A. (2012).
Verification of multi-view point-cloud registration for
VISAPP 2017 - International Conference on Computer Vision Theory and Applications
50
spherical harmonic cross-correl. In 27th Conf. Image
Vision Comp. New Zealand, pages 358–363. ACM.
Makadia, A., Patterson, A., and Daniilidis, K. (2006). Fully
automatic registration of 3d point clouds. In Computer
Vision and Pattern Recognition, 2006 IEEE Computer
Society Conference on, volume 1, pages 1297–1304.
Martins, A., Bessant, M., Manukyan, L., and Milinkovitch,
M. (2015). R2obbie-3d, a fast robotic high-res. sys-
tem for quant. phenotyping of surf. geom. and colour-
texture. PLoS ONE, 10(6):1–18.
Matabosch, C., Fofi, D., Salvi, J., and Batlle, E. (2008).
Registration of surfaces minimizing error propagation
for a one-shot multi-slit hand-held scanner. Pattern
Recognition, 41(6):2055 – 2067.
Mellado, N., Aiger, D., and Mitra, N. J. (2014). Super 4pcs
fast global pointcloud registration via smart indexing.
In Computer Graphics Forum, volume 33(5), pages
205–215. Wiley Online Library.
Mian, A., Bennamoun, M., and Owens, R. (2010). On the
repeatability and quality of keypoints for local feature-
based 3d object retrieval from cluttered scenes. Inter-
national Journal of Computer Vision, 89(2):348–361.
Oliveira, F. P. and Tavares, J. M. R. (2014). Medical image
registration: a review. Computer Methods in Biome-
chanics and Biomedical Engineering, 17(2):73–93.
PMID: 22435355.
Pribani
´
c, T., Diez, Y., Fernandez, S., and Salvi, J. (2013).
An efficient method for surface registration. In VIS-
APP (1), pages 500–503.
Pribani
´
c, T., Diez, Y., Roure, F., and Salvi, J. (2016). An
efficient surface registration using smartphone. Ma-
chine Vision and Applications, 27(4):559–576.
Pribani
´
c, T., Mrvo
ˇ
s, S., and Salvi, J. (2010). Efficient mul-
tiple phase shift patterns for dense 3d acquisition in
structured light scanning. Image and Vision Comput-
ing, 28(8):1255–1266.
ProjectTango (2016). Project tango. https://www.google.
com/atap/projecttango/#project. Accessed: 2016-09-
20.
Roure, F., D
´
ıez, Y., Llad
´
o, X., Forest, J., Pribanic, T., and
Salvi, J. (2015a). An experimental benchmark for
point set coarse registration. In Int. Conf. on Com-
puter Vision Theory and Applications.
Roure, F., Diez, Y., Llad
´
o, X., Forest, J., Pribanic, T., and
Salvi, J. (2015b). A study on the robustness of shape
descriptors to common scanning artifacts. In 14th Int.
Conf. Mach. Vis. App., MVA., pages 522–525. IEEE.
Rusinkiewicz, S. and Levoy, M. (2001). Efficient variants of
the icp algorithm. In IEEE International Conference
on 3D Digital Imaging and Modeling, pages 145–152.
StructureSensor (2016). Structure sensor. http://structure.
io/. Accessed: 2016-09-20.
Hierarchical Techniques to Improve Hybrid Point Cloud Registration
51