Super4PCS Library  V1.1.2(719f5c0)
timer.h
1 // Copyright 2014 Nicolas Mellado
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 // -------------------------------------------------------------------------- //
16 //
17 // Authors: Nicolas Mellado, Dror Aiger
18 //
19 // An implementation of the Super 4-points Congruent Sets (Super 4PCS)
20 // algorithm presented in:
21 //
22 // Super 4PCS: Fast Global Pointcloud Registration via Smart Indexing
23 // Nicolas Mellado, Dror Aiger, Niloy J. Mitra
24 // Symposium on Geometry Processing 2014.
25 //
26 // Data acquisition in large-scale scenes regularly involves accumulating
27 // information across multiple scans. A common approach is to locally align scan
28 // pairs using Iterative Closest Point (ICP) algorithm (or its variants), but
29 // requires static scenes and small motion between scan pairs. This prevents
30 // accumulating data across multiple scan sessions and/or different acquisition
31 // modalities (e.g., stereo, depth scans). Alternatively, one can use a global
32 // registration algorithm allowing scans to be in arbitrary initial poses. The
33 // state-of-the-art global registration algorithm, 4PCS, however has a quadratic
34 // time complexity in the number of data points. This vastly limits its
35 // applicability to acquisition of large environments. We present Super 4PCS for
36 // global pointcloud registration that is optimal, i.e., runs in linear time (in
37 // the number of data points) and is also output sensitive in the complexity of
38 // the alignment problem based on the (unknown) overlap across scan pairs.
39 // Technically, we map the algorithm as an 'instance problem' and solve it
40 // efficiently using a smart indexing data organization. The algorithm is
41 // simple, memory-efficient, and fast. We demonstrate that Super 4PCS results in
42 // significant speedup over alternative approaches and allows unstructured
43 // efficient acquisition of scenes at scales previously not possible. Complete
44 // source code and datasets are available for research use at
45 // http://geometry.cs.ucl.ac.uk/projects/2014/super4PCS/.
46 
47 #ifndef _SUPER4PCS_UTILS_TIMER_H_
48 #define _SUPER4PCS_UTILS_TIMER_H_
49 
50 #include <chrono> //timers
51 #include "super4pcs/utils/disablewarnings.h"
52 
53 namespace GlobalRegistration{
54 namespace Utils{
55 
56 class Timer {
57 public:
58  typedef std::chrono::high_resolution_clock clock;
59  typedef std::chrono::nanoseconds timestep;
60 
61  explicit inline Timer(bool run = false)
62  {
63  if (run) reset();
64  }
65  void reset()
66  {
67  _start = clock::now();
68  }
69  inline timestep elapsed() const
70  {
71  return std::chrono::duration_cast<timestep>(clock::now() - _start);
72  }
73  template <typename T, typename Traits>
74  friend std::basic_ostream<T, Traits>& operator<<(std::basic_ostream<T, Traits>& out, const Timer& timer)
75  {
76  return out << timer.elapsed().count();
77  }
78 private:
79  clock::time_point _start;
80 };
81 
82 } // namespace Utils
83 } // namespace Super4PCS
84 
85 #endif // _TIMER_H_
timestep elapsed() const
Definition: timer.h:69
Timer(bool run=false)
Definition: timer.h:61
Definition: bbox.h:54
void reset()
Definition: timer.h:65
std::chrono::high_resolution_clock clock
Definition: timer.h:58
std::chrono::nanoseconds timestep
Definition: timer.h:59
Definition: timer.h:56