Dynamic tree structure with weighted items in each node which are markable through out the tree. More...

#include <WeightedFastHoughTree.h>

Inheritance diagram for WeightedFastHoughTree< T, ADomain, ADomainDivsion >:

[legend]

Collaboration diagram for WeightedFastHoughTree< T, ADomain, ADomainDivsion >:

[legend]

Public Types
using	Node = typename Super::Node
	Type of the node in the tree.

Public Member Functions
template<class Ts>
void	seed (const Ts &items)
	Take the item set and insert them into the top node of the hough space.

template<class AItemInDomainMeasure>
std::vector< std::pair< ADomain, std::vector< T > > >	findHeavyLeavesDisjoint (AItemInDomainMeasure &weightItemInDomain, int maxLevel, double minWeight)
	Find all children node at maximum level and add them to the result list. Skip nodes if their weight is below minWeight.

template<class AItemInDomainMeasure, class ASkipNodePredicate>
std::vector< std::pair< ADomain, std::vector< T > > >	findLeavesDisjoint (AItemInDomainMeasure &weightItemInDomain, int maxLevel, ASkipNodePredicate &skipNode)
	Find all children node at maximum level and add them to the result list. Skip nodes if skipNode returns true.

template<class AItemInDomainMeasure>
std::vector< std::pair< ADomain, std::vector< T > > >	findHeaviestLeafRepeated (AItemInDomainMeasure &weightItemInDomain, int maxLevel, const TrackingUtilities::Weight minWeight=NAN)
	Go through all children until maxLevel is reached and find the heaviest leaves.

template<class AItemInDomainMeasure, class ASkipNodePredicate>
std::vector< std::pair< ADomain, std::vector< T > > >	findHeaviestLeafRepeated (AItemInDomainMeasure &weightItemInDomain, int maxLevel, ASkipNodePredicate &skipNode)
	Go through all children until maxLevel is reached and find the heaviest leaves.

template<class AItemInDomainMeasure, class ASkipNodePredicate>
std::unique_ptr< std::pair< ADomain, std::vector< T > > >	findHeaviestLeafSingle (AItemInDomainMeasure &weightItemInDomain, int maxLevel, ASkipNodePredicate &skipNode)
	Go through all children until the maxLevel is reached and find the leaf with the highest weight.

template<class AItemInDomainMeasure, class ASkipNodePredicate>
Node *	findHeaviestLeaf (AItemInDomainMeasure &weightItemInDomain, int maxLevel, ASkipNodePredicate &skipNode)
	Go through all children until the maxLevel is reached and find the leaf with the highest weight.

template<class AItemInDomainMeasure, class AIsLeafPredicate>
void	fillWalk (AItemInDomainMeasure &weightItemInDomain, AIsLeafPredicate &isLeaf, bool isLeafMarksItems=true)
	Walk through the children and fill them if necessary until isLeaf returns true.

template<class ATreeWalker>
void	walkHeighWeightFirst (ATreeWalker &walker, bool walkerMarksItems=true)
	Walk the tree investigating the heaviest children with priority.

void	fell ()
	Fell to tree meaning deleting all child nodes from the tree. Keeps the top node.

void	raze ()
	Like fell but also releases all memory the tree has acquired during long executions.

Node &	getTopNode ()
	Getter for the top node of the tree.

const Node &	getTopNode () const
	Constant getter for the top node of the tree.

Node &	getTopNode ()
	Getter for the top node of the tree.

const Node &	getTopNode () const
	Constant getter for the top node of the tree.

int	getNNodes () const
	Gets the number of nodes currently contained in the tree Also demonstrates how to walk over the tree.

int	getNNodes () const
	Gets the number of nodes currently contained in the tree Also demonstrates how to walk over the tree.

std::map< int, int >	getNNodesByLevel () const
	Gets the number of nodes by level in the tree Also demonstrates how to walk over the tree.

std::map< int, int >	getNNodesByLevel () const
	Gets the number of nodes by level in the tree Also demonstrates how to walk over the tree.

void	walk (AWalker &walker)
	Forward walk to the top node.

void	walk (AWalker &walker, APriorityMeasure &priority)
	Forward walk to the top node.

void	walk (AWalker &walker)
	Forward walk to the top node.

void	walk (AWalker &walker, APriorityMeasure &priority)
	Forward walk to the top node.

Public Attributes
SubPropertiesFactory	m_subPropertiesFactory
	Instance of the properties factory for the sub nodes.

SubPropertiesFactory	m_subPropertiesFactory
	Instance of the properties factory for the sub nodes.

Node	m_topNode
	Memory for the top node of the tree.

Node	m_topNode
	Memory for the top node of the tree.

std::deque< typename Node::Children >	m_children
	Central point to provide memory for the child structures.

std::deque< typename Node::Children >	m_children
	Central point to provide memory for the child structures.

size_t	m_nUsedChildren
	Last index of used children.

size_t	m_nUsedChildren
	Last index of used children.

Private Types
using	Super = WeightedParititioningDynTree<WithSharedMark<T>, ADomain, ADomainDivsion>
	Type of the Tree the partitions using markable items the hough space.

using	This
	Type of this class.

using	Properties
	Type of the Properties.

using	SubPropertiesFactory
	Type of the factory for the sub node properties.

Private Member Functions
std::vector< Node > *	createChildren (Node *parentNode)
	Create child nodes for the given parents.

std::vector< Node > *	createChildren (Node *parentNode)
	Create child nodes for the given parents.

std::vector< Node > *	getUnusedChildren ()
	Acquire the next unused child node structure, recycling all memory.

std::vector< Node > *	getUnusedChildren ()
	Acquire the next unused child node structure, recycling all memory.

Private Attributes
std::deque< bool >	m_marks
	Memory of the used marks of the items.

Detailed Description

template<class T, class ADomain, class ADomainDivsion>
class Belle2::TrackFindingCDC::WeightedFastHoughTree< T, ADomain, ADomainDivsion >

Dynamic tree structure with weighted items in each node which are markable through out the tree.

Used to build fast hough type algorithms, where objects are allowed to carry weights relative to the hough space part (here called a ADomain) they are contained in. The shared marks allow for iterative extraction of hough peaks such that other areas of the hough space notice that certain element have already been consumed.

Definition at line 51 of file WeightedFastHoughTree.h.

Member Typedef Documentation

◆ Node

template<class T, class ADomain, class ADomainDivsion>

using Node = typename Super::Node

Type of the node in the tree.

Definition at line 63 of file WeightedFastHoughTree.h.

◆ Properties

using Properties

privateinherited

Type of the Properties.

Definition at line 41 of file DynTree.h.

◆ SubPropertiesFactory

using SubPropertiesFactory

privateinherited

Type of the factory for the sub node properties.

Definition at line 44 of file DynTree.h.

◆ Super

template<class T, class ADomain, class ADomainDivsion>

using Super = WeightedParititioningDynTree<WithSharedMark<T>, ADomain, ADomainDivsion>

private

Type of the Tree the partitions using markable items the hough space.

Definition at line 56 of file WeightedFastHoughTree.h.

◆ This

using This

privateinherited

Type of this class.

Definition at line 38 of file DynTree.h.

Member Function Documentation

◆ createChildren() [1/2]

std::vector< Node > * createChildren ( Node * parentNode )

inlineprivateinherited

Create child nodes for the given parents.

Definition at line 284 of file DynTree.h.

      {
        std::vector<Node>* result = getUnusedChildren();
        auto subProperties = m_subPropertiesFactory(*parentNode);
        if (subProperties.empty()) {
          result->clear();
        } else {
          // Initialize new elements with dummy property.
          result->resize(subProperties.size(), Node(subProperties.back()));
          size_t iSubNode = 0;
          for (auto& properties : subProperties) {
            TrackingUtilities::clearIfApplicable(result->at(iSubNode));
            result->at(iSubNode) = properties;
            ++iSubNode;
          }
        }
        return result;
      }

◆ createChildren() [2/2]

std::vector< Node > * createChildren ( Node * parentNode )

inlineprivateinherited

Create child nodes for the given parents.

Definition at line 284 of file DynTree.h.

      {
        std::vector<Node>* result = getUnusedChildren();
        auto subProperties = m_subPropertiesFactory(*parentNode);
        if (subProperties.empty()) {
          result->clear();
        } else {
          // Initialize new elements with dummy property.
          result->resize(subProperties.size(), Node(subProperties.back()));
          size_t iSubNode = 0;
          for (auto& properties : subProperties) {
            TrackingUtilities::clearIfApplicable(result->at(iSubNode));
            result->at(iSubNode) = properties;
            ++iSubNode;
          }
        }
        return result;
      }

◆ fell()

template<class T, class ADomain, class ADomainDivsion>

void fell ( )

inline

Fell to tree meaning deleting all child nodes from the tree. Keeps the top node.

Definition at line 325 of file WeightedFastHoughTree.h.

      {
        this->getTopNode().clear();
        m_marks.clear();
        Super::fell();
      }

◆ fillWalk()

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure, class AIsLeafPredicate>

void fillWalk	(	AItemInDomainMeasure &	weightItemInDomain,
		AIsLeafPredicate &	isLeaf,
		bool	isLeafMarksItems = true )

inline

Walk through the children and fill them if necessary until isLeaf returns true.

Uses the weightItemInDomain to create weights for the items (or decide if an item belongs to a mode or not).

Definition at line 243 of file WeightedFastHoughTree.h.

      {
        auto walker = [&weightItemInDomain, &isLeaf](Node * node) {
          // Check if node is a leaf
          // Do not create children in this case
          if (isLeaf(node)) {
            // Do not walk children.
            return false;
          }
 
          // Node is not a leaf.
          // Check if it has children.
          // If children have not been created, create and fill them.
          typename Node::Children* children = node->getChildren();
          if (not children) {
            node->createChildren();
            children = node->getChildren();
            if constexpr(std::is_invocable_v<AItemInDomainMeasure&, const T&, Node*>) {
              // Weighting function does not modify the item: fill all children in a single pass
              // over the parent items without copies. Each child receives the items in the same order.
              for (const WithSharedMark<T>& markableItem : *node) {
                // Weighting function should not see the mark, but only the item itself.
                const T& item(markableItem);
                for (Node& childNode : *children) {
                  const TrackingUtilities::Weight weight = weightItemInDomain(item, &childNode);
                  if (not std::isnan(weight)) {
                    childNode.insert(markableItem, weight);
                  }
                }
              }
            } else {
              for (Node& childNode : *children) {
                assert(childNode.getChildren() == nullptr);
                assert(childNode.size() == 0);
                auto measure =
                  // cppcheck-suppress constParameterReference ; the item is unwrapped as a non-const reference below
                [&childNode, &weightItemInDomain](WithSharedMark<T>& markableItem) -> TrackingUtilities::Weight {
                  // Weighting function should not see the mark, but only the item itself.
                  T & item(markableItem);
                  return weightItemInDomain(item, &childNode);
                };
                childNode.insert(*node, measure);
              }
            }
          }
          // Continue to walk the children.
          return true;
        };
        walkHeighWeightFirst(walker, isLeafMarksItems);
      }

◆ findHeaviestLeaf()

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure, class ASkipNodePredicate>

Node * findHeaviestLeaf	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		ASkipNodePredicate &	skipNode )

inline

Go through all children until the maxLevel is reached and find the leaf with the highest weight.

If no node could be found, return a nullptr. A node is skipped if skipNode is returns true for this node.

Definition at line 203 of file WeightedFastHoughTree.h.

      {
        Node* heaviestNode = nullptr;
        TrackingUtilities::Weight heighestWeigth = NAN;
        auto isLeaf = [&heaviestNode, &heighestWeigth, maxLevel, &skipNode](Node * node) {
          // Skip the expansion and the filling of the children
          if (skipNode(node)) {
            return true;
          }
 
          TrackingUtilities::Weight nodeWeight = node->getWeight();
          // Skip the expansion and filling of the children if the node has not enough weight
          if (not std::isnan(heighestWeigth) and not(nodeWeight > heighestWeigth)) {
            return true;
          }
 
          // Node is a leaf at the maximum level and is heavier than everything seen before.
          // Save its content
          // Do not walk children
          if (node->getLevel() >= maxLevel) {
            heaviestNode = node;
            heighestWeigth = nodeWeight;
            return true;
          }
          return false;
        };
        // The isLeaf predicate does not mark any items.
        const bool isLeafMarksItems = false;
        fillWalk(weightItemInDomain, isLeaf, isLeafMarksItems);
        return heaviestNode;
      }

◆ findHeaviestLeafRepeated() [1/2]

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure, class ASkipNodePredicate>

std::vector< std::pair< ADomain, std::vector< T > > > findHeaviestLeafRepeated	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		ASkipNodePredicate &	skipNode )

inline

Go through all children until maxLevel is reached and find the heaviest leaves.

For this, the single heaviest leaf is found and added to an internal list. The process is repeated until no leaf can be found anymore. A node is skipped if skipNode is returns true for this node.

Definition at line 156 of file WeightedFastHoughTree.h.

      {
        std::vector<std::pair<ADomain,  std::vector<T> > > found;
        Node* node = findHeaviestLeaf(weightItemInDomain, maxLevel, skipNode);
        while (node) {
          const ADomain* domain = node;
          found.emplace_back(*domain, std::vector<T>(node->begin(), node->end()));
          for (WithSharedMark<T>& markableItem : *node) {
            markableItem.mark();
          }
          node = findHeaviestLeaf(weightItemInDomain, maxLevel, skipNode);
        }
        return found;
      }

◆ findHeaviestLeafRepeated() [2/2]

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure>

std::vector< std::pair< ADomain, std::vector< T > > > findHeaviestLeafRepeated	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		const TrackingUtilities::Weight	minWeight = NAN )

inline

Go through all children until maxLevel is reached and find the heaviest leaves.

For this, the single heaviest leaf is found and added to an internal list. The process is repeated until no leaf can be found anymore. A node is skipped if the weight is below minWeight.

Definition at line 137 of file WeightedFastHoughTree.h.

      {
        auto skipLowWeightNode = [minWeight](const Node * node) {
          return not(node->getWeight() >= minWeight);
        };
        return findHeaviestLeafRepeated(weightItemInDomain, maxLevel, skipLowWeightNode);
      }

◆ findHeaviestLeafSingle()

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure, class ASkipNodePredicate>

std::unique_ptr< std::pair< ADomain, std::vector< T > > > findHeaviestLeafSingle	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		ASkipNodePredicate &	skipNode )

inline

Go through all children until the maxLevel is reached and find the leaf with the highest weight.

If no node could be found, return an empty list, otherwise return a list with just on element. A node is skipped if skipNode is returns true for this node.

Definition at line 180 of file WeightedFastHoughTree.h.

      {
        using Result = std::pair<ADomain,  std::vector<T> >;
        std::unique_ptr<Result> found = nullptr;
        Node* node = findHeaviestLeaf(weightItemInDomain, maxLevel, skipNode);
        if (node) {
          const ADomain* domain = node;
          found.reset(new Result(*domain, std::vector<T>(node->begin(), node->end())));
          for (WithSharedMark<T>& markableItem : *node) {
            markableItem.mark();
          }
        }
        return found;
      }

◆ findHeavyLeavesDisjoint()

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure>

std::vector< std::pair< ADomain, std::vector< T > > > findHeavyLeavesDisjoint	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		double	minWeight )

inline

Find all children node at maximum level and add them to the result list. Skip nodes if their weight is below minWeight.

Definition at line 83 of file WeightedFastHoughTree.h.

      {
        auto skipLowWeightNode = [minWeight](const Node * node) {
          return not(node->getWeight() >= minWeight);
        };
        return findLeavesDisjoint(weightItemInDomain, maxLevel, skipLowWeightNode);
      }

◆ findLeavesDisjoint()

template<class T, class ADomain, class ADomainDivsion>

template<class AItemInDomainMeasure, class ASkipNodePredicate>

std::vector< std::pair< ADomain, std::vector< T > > > findLeavesDisjoint	(	AItemInDomainMeasure &	weightItemInDomain,
		int	maxLevel,
		ASkipNodePredicate &	skipNode )

inline

Find all children node at maximum level and add them to the result list. Skip nodes if skipNode returns true.

Definition at line 96 of file WeightedFastHoughTree.h.

      {
        std::vector<std::pair<ADomain,  std::vector<T> > > found;
        auto isLeaf = [&found, &skipNode, maxLevel](Node * node) {
          // Skip the expansion and the filling of the children
          if (skipNode(node)) {
            return true;
          }
 
          // Node is a leaf at the maximum level
          // Save its content
          // Do not walk children
          if (node->getLevel() >= maxLevel) {
            const ADomain* domain = node;
            found.emplace_back(*domain, std::vector<T>(node->begin(), node->end()));
            for (WithSharedMark<T>& markableItem : *node) {
              markableItem.mark();
            }
            return true;
          }
 
          // Else to node has enough weight and is not at the lowest level
          // Signal that it is not a leaf
          // Continue to create and fill children.
          return false;
        };
        fillWalk(weightItemInDomain, isLeaf);
        return found;
      }

◆ getNNodes() [1/2]

int getNNodes ( ) const

inlineinherited

Gets the number of nodes currently contained in the tree Also demonstrates how to walk over the tree.

Definition at line 248 of file DynTree.h.

      {
        int nNodes = 0;
        auto countNodes = [&nNodes](const Node*) -> bool {
          ++nNodes;
          return true;
        };
        const_cast<DynTree&>(*this).walk(countNodes);
        //walk(countNodes);
        return nNodes;
      }

◆ getNNodes() [2/2]

int getNNodes ( ) const

inlineinherited

Gets the number of nodes currently contained in the tree Also demonstrates how to walk over the tree.

Definition at line 248 of file DynTree.h.

      {
        int nNodes = 0;
        auto countNodes = [&nNodes](const Node*) -> bool {
          ++nNodes;
          return true;
        };
        const_cast<DynTree&>(*this).walk(countNodes);
        //walk(countNodes);
        return nNodes;
      }

◆ getNNodesByLevel() [1/2]

std::map< int, int > getNNodesByLevel ( ) const

inlineinherited

Gets the number of nodes by level in the tree Also demonstrates how to walk over the tree.

Definition at line 264 of file DynTree.h.

      {
        std::map<int, int> nNodesByLevel;
        auto countNodes = [&nNodesByLevel](const Node * node) -> bool {
          if (nNodesByLevel.count(node->getLevel()) == 0)
          {
            nNodesByLevel[node->getLevel()] = 1;
          } else
          {
            nNodesByLevel[node->getLevel()]++;
          }
          return true;
        };
        const_cast<DynTree&>(*this).walk(countNodes);
        //walk(countNodes);
        return nNodesByLevel;
      }

◆ getNNodesByLevel() [2/2]

std::map< int, int > getNNodesByLevel ( ) const

inlineinherited

Gets the number of nodes by level in the tree Also demonstrates how to walk over the tree.

Definition at line 264 of file DynTree.h.

      {
        std::map<int, int> nNodesByLevel;
        auto countNodes = [&nNodesByLevel](const Node * node) -> bool {
          if (nNodesByLevel.count(node->getLevel()) == 0)
          {
            nNodesByLevel[node->getLevel()] = 1;
          } else
          {
            nNodesByLevel[node->getLevel()]++;
          }
          return true;
        };
        const_cast<DynTree&>(*this).walk(countNodes);
        //walk(countNodes);
        return nNodesByLevel;
      }

◆ getTopNode() [1/4]

Node & getTopNode ( )

inlineinherited

Getter for the top node of the tree.

Definition at line 237 of file DynTree.h.

238 { return m_topNode; }

◆ getTopNode() [2/4]

Node & getTopNode ( )

inlineinherited

Getter for the top node of the tree.

Definition at line 237 of file DynTree.h.

238 { return m_topNode; }

◆ getTopNode() [3/4]

const Node & getTopNode ( ) const

inlineinherited

Constant getter for the top node of the tree.

Definition at line 241 of file DynTree.h.

242 { return m_topNode; }

◆ getTopNode() [4/4]

const Node & getTopNode ( ) const

inlineinherited

Constant getter for the top node of the tree.

Definition at line 241 of file DynTree.h.

242 { return m_topNode; }

◆ getUnusedChildren() [1/2]

std::vector< Node > * getUnusedChildren ( )

inlineprivateinherited

Acquire the next unused child node structure, recycling all memory.

Definition at line 304 of file DynTree.h.

      {
        if (m_nUsedChildren >= m_children.size()) {
          m_children.emplace_back();
        }
        ++m_nUsedChildren;
        return &(m_children[m_nUsedChildren - 1]);
      }

◆ getUnusedChildren() [2/2]

std::vector< Node > * getUnusedChildren ( )

inlineprivateinherited

Acquire the next unused child node structure, recycling all memory.

Definition at line 304 of file DynTree.h.

      {
        if (m_nUsedChildren >= m_children.size()) {
          m_children.emplace_back();
        }
        ++m_nUsedChildren;
        return &(m_children[m_nUsedChildren - 1]);
      }

◆ raze()

template<class T, class ADomain, class ADomainDivsion>

void raze ( )

inline

Like fell but also releases all memory the tree has acquired during long executions.

Definition at line 333 of file WeightedFastHoughTree.h.

      {
        this->fell();
        Super::raze();
        m_marks.shrink_to_fit();
      }

◆ seed()

template<class T, class ADomain, class ADomainDivsion>

template<class Ts>

void seed ( const Ts & items )

inline

Take the item set and insert them into the top node of the hough space.

Definition at line 68 of file WeightedFastHoughTree.h.

      {
        this->fell();
        Node& topNode = this->getTopNode();
        for (auto&& item : items) {
          m_marks.push_back(false);
          bool& markOfItem = m_marks.back();
          TrackingUtilities::Weight weight = DBL_MAX;
          topNode.insert(WithSharedMark<T>(T(item), &markOfItem), weight);
        }
      }

◆ walk() [1/4]

void walk ( AWalker & walker )

inlineinherited

Forward walk to the top node.

Definition at line 316 of file DynTree.h.

      {
        static_assert(std::is_assignable<std::function<bool(Node*)>, AWalker>(), "");
 
        getTopNode().walk(walker);
      }

◆ walk() [2/4]

void walk ( AWalker & walker )

inlineinherited

Forward walk to the top node.

Definition at line 316 of file DynTree.h.

      {
        static_assert(std::is_assignable<std::function<bool(Node*)>, AWalker>(), "");
 
        getTopNode().walk(walker);
      }

◆ walk() [3/4]

void walk	(	AWalker &	walker,
		APriorityMeasure &	priority )

inlineinherited

Forward walk to the top node.

Definition at line 325 of file DynTree.h.

      {
        static_assert(std::is_assignable<std::function<bool(Node*)>, AWalker>(), "");
        static_assert(std::is_assignable<std::function<float(Node*)>, APriorityMeasure>(), "");
 
        getTopNode().walk(walker, priority);
      }

◆ walk() [4/4]

void walk	(	AWalker &	walker,
		APriorityMeasure &	priority )

inlineinherited

Forward walk to the top node.

Definition at line 325 of file DynTree.h.

      {
        static_assert(std::is_assignable<std::function<bool(Node*)>, AWalker>(), "");
        static_assert(std::is_assignable<std::function<float(Node*)>, APriorityMeasure>(), "");
 
        getTopNode().walk(walker, priority);
      }

◆ walkHeighWeightFirst()

template<class T, class ADomain, class ADomainDivsion>

template<class ATreeWalker>

void walkHeighWeightFirst	(	ATreeWalker &	walker,
		bool	walkerMarksItems = true )

inline

Walk the tree investigating the heaviest children with priority.

If the walker is known not to mark items and no item is marked yet, the removal of marked items can be skipped as it would never erase anything.

Clear items that have been marked as used before evaluating the weight.

Definition at line 302 of file WeightedFastHoughTree.h.

      {
        if (not walkerMarksItems and std::find(m_marks.begin(), m_marks.end(), true) == m_marks.end()) {
          auto unmarkedPriority = [](Node * node) -> float {
            return node->getWeight();
          };
          this->walk(walker, unmarkedPriority);
          return;
        }
 
        auto priority = [](Node * node) -> float {
          auto isMarked = [](const WithSharedMark<T>& markableItem) -> bool {
            return markableItem.isMarked();
          };
          node->eraseIf(isMarked);
          return node->getWeight();
        };
 
        this->walk(walker, priority);
      }

Member Data Documentation

◆ m_children [1/2]

std::deque<typename Node::Children> m_children

inherited

Central point to provide memory for the child structures.

Definition at line 365 of file DynTree.h.

◆ m_children [2/2]

std::deque<typename Node::Children> m_children

inherited

Central point to provide memory for the child structures.

Definition at line 365 of file DynTree.h.

◆ m_marks

template<class T, class ADomain, class ADomainDivsion>

std::deque<bool> m_marks

private

Memory of the used marks of the items.

Definition at line 342 of file WeightedFastHoughTree.h.

◆ m_nUsedChildren [1/2]

size_t m_nUsedChildren

inherited

Last index of used children.

Definition at line 368 of file DynTree.h.

◆ m_nUsedChildren [2/2]

size_t m_nUsedChildren

inherited

Last index of used children.

Definition at line 368 of file DynTree.h.

◆ m_subPropertiesFactory [1/2]

SubPropertiesFactory m_subPropertiesFactory

inherited

Instance of the properties factory for the sub nodes.

Definition at line 359 of file DynTree.h.

◆ m_subPropertiesFactory [2/2]

SubPropertiesFactory m_subPropertiesFactory

inherited

Instance of the properties factory for the sub nodes.

Definition at line 359 of file DynTree.h.

◆ m_topNode [1/2]

Node m_topNode

inherited

Memory for the top node of the tree.

Definition at line 362 of file DynTree.h.

◆ m_topNode [2/2]

Node m_topNode

inherited

Memory for the top node of the tree.

Definition at line 362 of file DynTree.h.

The documentation for this class was generated from the following file:

tracking/trackFindingCDC/hough/trees/include/WeightedFastHoughTree.h

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Node

◆ Properties

◆ SubPropertiesFactory

◆ Super

◆ This

Member Function Documentation

◆ createChildren() [1/2]

◆ createChildren() [2/2]

◆ fell()

◆ fillWalk()

◆ findHeaviestLeaf()

◆ findHeaviestLeafRepeated() [1/2]

◆ findHeaviestLeafRepeated() [2/2]

◆ findHeaviestLeafSingle()

◆ findHeavyLeavesDisjoint()

◆ findLeavesDisjoint()

◆ getNNodes() [1/2]

◆ getNNodes() [2/2]

◆ getNNodesByLevel() [1/2]

◆ getNNodesByLevel() [2/2]

◆ getTopNode() [1/4]

◆ getTopNode() [2/4]

◆ getTopNode() [3/4]

◆ getTopNode() [4/4]

◆ getUnusedChildren() [1/2]

◆ getUnusedChildren() [2/2]

◆ raze()

◆ seed()

◆ walk() [1/4]

◆ walk() [2/4]

◆ walk() [3/4]

◆ walk() [4/4]

◆ walkHeighWeightFirst()

Member Data Documentation

◆ m_children [1/2]

◆ m_children [2/2]

◆ m_marks

◆ m_nUsedChildren [1/2]

◆ m_nUsedChildren [2/2]

◆ m_subPropertiesFactory [1/2]

◆ m_subPropertiesFactory [2/2]

◆ m_topNode [1/2]

◆ m_topNode [2/2]