Helios++
Helios software for LiDAR simulations
SimpleKDTreeFactory.h
1 #pragma once
2 
3 #include <KDTreeFactory.h>
4 
5 #include <vector>
6 #include <functional>
7 
9 
19  // *** FRIENDS *** //
20  // ***************** //
21  friend class MultiThreadKDTreeFactory;
22  friend class SimpleKDTreeGeometricStrategy;
23 
24 private:
25  // *** SERIALIZATION *** //
26  // *********************** //
27  friend class boost::serialization::access;
34  template <typename Archive>
35  void serialize(Archive &ar, const unsigned int version){
36  boost::serialization::void_cast_register<
39  >();
40  ar &boost::serialization::base_object<KDTreeFactory>(*this);
42  }
43 
44 protected:
45  // *** ATTRIBUTES *** //
46  // ******************** //
55  std::function<KDTreeNode *(
56  KDTreeNode *,
57  bool const,
58  vector<Primitive *> &,
59  int const,
60  int const
62 
74 
75 public:
76  // *** CONSTRUCTION / DESTRUCTION *** //
77  // ************************************ //
85  virtual ~SimpleKDTreeFactory() = default;
86 
87  // *** CLONE *** //
88  // *************** //
92  KDTreeFactory * clone() const override;
96  virtual void _clone(KDTreeFactory *kdtf) const;
97 
98  // *** SIMPLE KDTREE FACTORY METHODS *** //
99  // *************************************** //
106  vector<Primitive *> &primitives,
107  bool const computeStats=false,
108  bool const reportStats=false
109  ) override;
110 
111 protected:
112  // *** BUILDING METHODS *** //
113  // ************************** //
137  virtual KDTreeNode * buildRecursive(
138  KDTreeNode *parent,
139  bool const left,
140  vector<Primitive*> &primitives,
141  int const depth,
142  int const index
143  );
173  KDTreeNode *parent,
174  bool const left,
175  vector<Primitive *> &primitives,
176  int const depth,
177  int const index,
178  std::function<void(
179  KDTreeNode *node,
180  KDTreeNode *parent,
181  bool const left,
182  vector<Primitive *> const &primitives
183  )> f_computeNodeBoundaries,
184  std::function<void(
185  KDTreeNode *node,
186  KDTreeNode *parent,
187  vector<Primitive *> &primitives,
188  int const depth
189  )> f_defineSplit,
190  std::function<void(
191  vector<Primitive *> const &primitives,
192  int const splitAxis,
193  double const splitPos,
194  vector<Primitive *> &leftPrimitives,
195  vector<Primitive *> &rightPrimitives
196  )> f_populateSplits,
197  std::function<void(
198  KDTreeNode *node,
199  KDTreeNode *parent,
200  vector<Primitive *> const &primitives,
201  int const depth,
202  int const index,
203  vector<Primitive *> &leftPrimitives,
204  vector<Primitive *> &rightPrimitives
205  )> f_buildChildrenNodes
206  );
212  virtual void computeKDTreeStats(KDTreeNodeRoot *root) const;
217  virtual void reportKDTreeStats(
218  KDTreeNodeRoot *root,
219  vector<Primitive *> const &primitives
220  ) const;
221 
251  virtual void defineSplit(
252  KDTreeNode *node,
253  KDTreeNode *parent,
254  vector<Primitive *> &primitives,
255  int const depth
256  ) const;
268  virtual void populateSplits(
269  vector<Primitive *> const &primitives,
270  int const splitAxis,
271  double const splitPos,
272  vector<Primitive *> &leftPrimitives,
273  vector<Primitive *> &rightPrimitives
274  ) const;
289  virtual void buildChildrenNodes(
290  KDTreeNode *node,
291  KDTreeNode *parent,
292  vector<Primitive *> const &primitives,
293  int const depth,
294  int const index,
295  vector<Primitive *> &leftPrimitives,
296  vector<Primitive *> &rightPrimitives
297  );
298 
299  // *** BUILDING UTILS *** //
300  // ************************ //
358  virtual void computeNodeBoundaries(
359  KDTreeNode *node,
360  KDTreeNode *parent,
361  bool const left,
362  vector<Primitive *> const &primitives
363  ) const;
364 
370  virtual void onPopulateSplitsDigestPrimitive(
371  Primitive *p,
372  int const splitAxis,
373  double const splitPos,
374  vector<Primitive *> &leftPrimitives,
375  vector<Primitive *> &rightPrimitives
376  ) const;
377 
387  virtual void computeMinMaxSAHForChild(
388  KDTreeNode *node,
389  KDTreeNode *parent,
390  bool const left,
391  vector<Primitive *> const &primitives
392  ) const;
393 
402  virtual void onRootBoundariesDigestPrimitive(
403  Primitive *primitive,
404  double &ax,
405  double &ay,
406  double &az,
407  double &bx,
408  double &by,
409  double &bz
410  ) const;
411 
421  virtual void onComputeNodeBoundariesCalcSAH(
422  KDTreeNode *node,
423  double const ax,
424  double const ay,
425  double const az,
426  double const bx,
427  double const by,
428  double const bz
429  ) const;
430 
443  virtual bool checkNodeMustSplit(
444  vector<Primitive *> const &primitives,
445  vector<Primitive *> const &leftPrimitives,
446  vector<Primitive *> const &rightPrimitives
447  ) const;
448 
454  virtual void makeLeaf(
455  KDTreeNode *node,
456  vector<Primitive *> const &primitives
457  ) const;
458 
459 };
Class that must be extended by any class which provides factory methods for k-dimensional trees....
Definition: KDTreeFactory.h:22
Class representing the root node of a KDTree.
Definition: KDTreeNodeRoot.h:12
Class representing a KDTree node.
Definition: KDTreeNode.h:9
Decorator for any KDTree factory which provides support for multi thread KDTree building.
Definition: MultiThreadKDTreeFactory.h:34
Abstract class defining the common behavior for all primitives.
Definition: Primitive.h:24
Class providing building methods for simple k-dimensional trees.
Definition: SimpleKDTreeFactory.h:18
virtual void computeNodeBoundaries(KDTreeNode *node, KDTreeNode *parent, bool const left, vector< Primitive * > const &primitives) const
Compute min and max position and surface area of bounding cuboid for given node.
Definition: SimpleKDTreeFactory.cpp:355
virtual KDTreeNode * buildRecursive(KDTreeNode *parent, bool const left, vector< Primitive * > &primitives, int const depth, int const index)
Recursively build a KDTree for given primitives.
Definition: SimpleKDTreeFactory.cpp:96
virtual void computeKDTreeStats(KDTreeNodeRoot *root) const
Analyze KDTree computing its max depth and the minimum and maximum number of primitives considering a...
Definition: SimpleKDTreeFactory.cpp:234
virtual KDTreeNode * buildRecursiveRecipe(KDTreeNode *parent, bool const left, vector< Primitive * > &primitives, int const depth, int const index, std::function< void(KDTreeNode *node, KDTreeNode *parent, bool const left, vector< Primitive * > const &primitives)> f_computeNodeBoundaries, std::function< void(KDTreeNode *node, KDTreeNode *parent, vector< Primitive * > &primitives, int const depth)> f_defineSplit, std::function< void(vector< Primitive * > const &primitives, int const splitAxis, double const splitPos, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives)> f_populateSplits, std::function< void(KDTreeNode *node, KDTreeNode *parent, vector< Primitive * > const &primitives, int const depth, int const index, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives)> f_buildChildrenNodes)
The recipe of the recursive building algorithm. It is meant to be used by the SimpleKDTreeFactory::bu...
Definition: SimpleKDTreeFactory.cpp:162
virtual void computeMinMaxSAHForChild(KDTreeNode *node, KDTreeNode *parent, bool const left, vector< Primitive * > const &primitives) const
Function to assist SimpleKDTreeFactory::computeNodeBoundaries when computing surface area heuristic a...
Definition: SimpleKDTreeFactory.cpp:396
KDTreeNodeRoot * makeFromPrimitivesUnsafe(vector< Primitive * > &primitives, bool const computeStats=false, bool const reportStats=false) override
Build a simple KDTree from given primitives.
Definition: SimpleKDTreeFactory.cpp:49
virtual void onPopulateSplitsDigestPrimitive(Primitive *p, int const splitAxis, double const splitPos, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives) const
Function to assist SimpleKDTreeFactory::populateSplits by providing the logic of digesting a primitiv...
Definition: SimpleKDTreeFactory.cpp:384
std::function< KDTreeNode *(KDTreeNode *, bool const, vector< Primitive * > &, int const, int const)> _buildRecursive
The member function as attribute used to recursively build KDTree nodes. By default it will be assign...
Definition: SimpleKDTreeFactory.h:61
virtual void makeLeaf(KDTreeNode *node, vector< Primitive * > const &primitives) const
Make given node a leaf one.
Definition: SimpleKDTreeFactory.cpp:478
virtual void defineSplit(KDTreeNode *node, KDTreeNode *parent, vector< Primitive * > &primitives, int const depth) const
Define the split axis and position for current node.
Definition: SimpleKDTreeFactory.cpp:284
virtual void reportKDTreeStats(KDTreeNodeRoot *root, vector< Primitive * > const &primitives) const
Report KDTree stats of given root node at INFO logging level.
Definition: SimpleKDTreeFactory.cpp:261
virtual void buildChildrenNodes(KDTreeNode *node, KDTreeNode *parent, vector< Primitive * > const &primitives, int const depth, int const index, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives)
Build children nodes for given node. If no children nodes must be built, then the node is configured ...
Definition: SimpleKDTreeFactory.cpp:325
virtual bool checkNodeMustSplit(vector< Primitive * > const &primitives, vector< Primitive * > const &leftPrimitives, vector< Primitive * > const &rightPrimitives) const
Check wheter the node must be splitted (true) or not (false) depending on its total primitives and th...
Definition: SimpleKDTreeFactory.cpp:466
virtual void onComputeNodeBoundariesCalcSAH(KDTreeNode *node, double const ax, double const ay, double const az, double const bx, double const by, double const bz) const
Function to assist SimpleKDTreeFactory::computeNodeBoundaries when computing the SAH for a node.
Definition: SimpleKDTreeFactory.cpp:450
virtual void onRootBoundariesDigestPrimitive(Primitive *primitive, double &ax, double &ay, double &az, double &bx, double &by, double &bz) const
Function to assist SimpleKDTreeFactory::computeNodeBoundaries by providing the logic of digesting a p...
Definition: SimpleKDTreeFactory.cpp:428
SimpleKDTreeFactory()
SimpleKDTreeFactory default constructor.
Definition: SimpleKDTreeFactory.cpp:9
virtual void populateSplits(vector< Primitive * > const &primitives, int const splitAxis, double const splitPos, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives) const
Populate list of primitives for left and right splits from given primitives of node being splitted.
Definition: SimpleKDTreeFactory.cpp:307
size_t minSplitPrimitives
How many primitives are required for a node to be splitted.
Definition: SimpleKDTreeFactory.h:73
virtual void _clone(KDTreeFactory *kdtf) const
Assign attributes from soruce SimpleKDTreeFactory to its clone.
Definition: SimpleKDTreeFactory.cpp:42
KDTreeFactory * clone() const override
Definition: SimpleKDTreeFactory.cpp:36
void serialize(Archive &ar, const unsigned int version)
Serialize a simple KDTree factory to a stream of bytes.
Definition: SimpleKDTreeFactory.h:35
Class providing a strategy for geometry-level parallelization of Simple KDTree building....
Definition: SimpleKDTreeGeometricStrategy.h:15