You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
235 lines
8.0 KiB
Plaintext
235 lines
8.0 KiB
Plaintext
// Included by octree.h
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef octree<T_,d_,A_>*
|
|
*octree_node<T_,d_,A_>::octree_pointer \brief Shorthand for a pointer to an octree.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef octree_node<T_,d_,A_>*
|
|
*octree_node<T_,d_,A_>::octree_node_pointer \brief Shorthand for a pointer to an octree node (this
|
|
*class).
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef const octree_node<T_,d_,A_>*
|
|
*octree_node<T_,d_,A_>::const_octree_node_pointer \brief Shorthand for a pointer to an immutable
|
|
*octree node (this class).
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef octree_node<T_,d_,A_>&
|
|
*octree_node<T_,d_,A_>::octree_node_reference \brief Shorthand for a reference to an octree node
|
|
*(this class).
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef const octree_node<T_,d_,A_>&
|
|
*octree_node<T_,d_,A_>::const_octree_node_reference \brief Shorthand for a reference to an
|
|
*immutable octree node (this class).
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef T_ octree_node<T_,d_,A_>::value_type
|
|
*\brief Shorthand for application data.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef T_* octree_node<T_,d_,A_>::pointer
|
|
*\brief Shorthand for a pointer to application data.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef T_& octree_node<T_,d_,A_>::reference
|
|
*\brief Shorthand for a reference to application data.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef const T_*
|
|
*octree_node<T_,d_,A_>::const_pointer \brief Shorthand for a pointer to immutable application data.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> typedef const T_&
|
|
*octree_node<T_,d_,A_>::const_reference \brief Shorthand for a reference to immutable application
|
|
*data.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> octree_node_pointer
|
|
*octree_node<T_,d_,A_>::_M_parent \brief The parent octree node that owns this node.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> octree_node_pointer
|
|
*octree_node<T_,d_,A_>::_M_children \brief A pointer to an array of \f$2^{\mathrm{\texttt{\d_}}}\f$
|
|
*children, or NULL if the node is a leaf node.
|
|
*/
|
|
|
|
/**\var template<typename T_, int d_=3, class A_> value_type octree_node<T_,d_,A_>::_M_data
|
|
*\brief Application-specific data.
|
|
*/
|
|
|
|
/**\brief Default constructor.
|
|
*
|
|
* The node will be a leaf node (i.e. have no children).
|
|
* The node's application-specific data will not be initialized by this constructor.
|
|
* The node will not have an owning octree -- which means that this constructor should never be used
|
|
* except possibly for serialization.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
octree_node<T_, d_, A_>::octree_node()
|
|
{
|
|
this->_M_parent = nullptr;
|
|
this->_M_children = nullptr;
|
|
}
|
|
|
|
/**\brief Root node constructor.
|
|
*
|
|
* The node will be a leaf node (i.e. have no children).
|
|
* The node's application-specific data will be initialized to the value you pass.
|
|
* This form of the constructor is used by the octree to create the root node of the tree.
|
|
*
|
|
* @param[in] parent The octree node owning this node
|
|
* @param[in] data Application-specific data to copy and store at this node.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
octree_node<T_, d_, A_>::octree_node(octree_node_pointer parent, const value_type& data)
|
|
: _M_parent(parent)
|
|
, _M_data(data)
|
|
{
|
|
this->_M_children = nullptr;
|
|
}
|
|
|
|
/**\brief Destructor.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
octree_node<T_, d_, A_>::~octree_node()
|
|
{
|
|
if (this->_M_children)
|
|
this->remove_children();
|
|
}
|
|
|
|
/**\fn template< typename T_, int d_, typename A_ > bool octree_node<T_,d_,A_>::is_leaf_node()
|
|
*\brief Test whether the node has any children.
|
|
*
|
|
* @retval True if the node is a leaf node (no children), false if the node has children.
|
|
*/
|
|
|
|
/**\fn template< typename T_, int d_, typename A_ > int octree_node<T_,d_,A_>::num_children()
|
|
*\brief Return the number of direct children of this node.
|
|
*
|
|
* For leaf nodes, this returns 0. Otherwise it will return \f$2^{\mathrm{\texttt{\d_}}}\f$.
|
|
*
|
|
* @retval The number of children.
|
|
*/
|
|
|
|
/**\brief Create children of this node if they did not already exist.
|
|
*
|
|
* Note that the application-specific data is not initialized by this call; you are responsible for
|
|
* any initialization. Use this variant when the default constructor of your application-specific
|
|
* data does some meaningful initialization.
|
|
* @retval True if children were created, false if they already existed.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
bool octree_node<T_, d_, A_>::add_children()
|
|
{
|
|
if (this->_M_children)
|
|
{
|
|
return false;
|
|
}
|
|
this->_M_children = new octree_node<T_, d_, A_>[1 << d_];
|
|
for (int i = 0; i < (1 << d_); ++i)
|
|
{
|
|
octree_node_pointer child = this->_M_children + i;
|
|
child->_M_parent = this;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**\brief Create children of this node if they did not already exist.
|
|
*
|
|
* Note that the application-specific data is not initialized by this call; you are responsible for
|
|
* any initialization. Use this variant when you need to provide a default value for the children's
|
|
* application-specific data. This is useful when the application-specific data is a pointer or some
|
|
* other basic type that does not normally get initialized.
|
|
* @retval True if children were created, false if they already existed.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
bool octree_node<T_, d_, A_>::add_children(const T_& child_initializer)
|
|
{
|
|
if (this->_M_children)
|
|
{
|
|
return false;
|
|
}
|
|
this->_M_children = new octree_node<T_, d_, A_>[1 << d_];
|
|
for (int i = 0; i < (1 << d_); ++i)
|
|
{
|
|
octree_node_pointer child = this->_M_children + i;
|
|
child->_M_parent = this->_M_parent;
|
|
child->_M_data = child_initializer;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**\brief Remove any child nodes from this node (if any existed to begin with).
|
|
*
|
|
* @retval True if children were removed, false if the node had none to begin with.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
bool octree_node<T_, d_, A_>::remove_children()
|
|
{
|
|
if (this->_M_children)
|
|
{
|
|
int i;
|
|
for (i = 0; i < (1 << d_); ++i)
|
|
{
|
|
this->_M_children[i]._M_parent =
|
|
nullptr; // prevent updates from propagating up the portion of the tree being deleted.
|
|
this->_M_children[i].remove_children();
|
|
}
|
|
delete[] this->_M_children;
|
|
this->_M_children = nullptr;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**\fn template< typename T_, int d_, typename A_ > reference octree_node<T_,d_,A_>::value()
|
|
*\brief Retrieve the application-specific data stored at a node.
|
|
*
|
|
* @retval A reference to the application-specific data.
|
|
*/
|
|
|
|
/**\fn template< typename T_, int d_, typename A_ > const reference octree_node<T_,d_,A_>::value()
|
|
*const \brief Retrieve a reference to immutable application-specific data stored at a node.
|
|
*
|
|
* @retval A reference to immutable application-specific data.
|
|
*/
|
|
|
|
/**\brief Return a (const) reference to a child node.
|
|
*
|
|
* @param child An integer in \f$[0,2^{\mathrm{\texttt{\d_}}}]\f$ indicating which child node to
|
|
* return.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
const octree_node<T_, d_, A_>& octree_node<T_, d_, A_>::operator[](int child) const
|
|
{
|
|
if (!this->_M_children)
|
|
{
|
|
throw std::domain_error("Attempt to access children of an octree leaf node.");
|
|
}
|
|
return this->_M_chilren[child];
|
|
}
|
|
|
|
/**\brief Return a reference to a child node.
|
|
*
|
|
* @param child An integer in \f$[0,2^{\mathrm{\texttt{\d_}}}]\f$ indicating which child node to
|
|
* return.
|
|
*/
|
|
template <typename T_, int d_, typename A_>
|
|
octree_node<T_, d_, A_>& octree_node<T_, d_, A_>::operator[](int child)
|
|
{
|
|
if (!this->_M_children)
|
|
{
|
|
throw std::domain_error("Attempt to access children of an octree leaf node.");
|
|
}
|
|
return this->_M_children[child];
|
|
}
|
|
|
|
/**\fn template<typename T_, int d_=3, class A_> reference octree_node<T_,d_,A_>::operator * ()
|
|
*\brief Provide access to the application-specific data.
|
|
*/
|
|
|
|
/**\fn template<typename T_, int d_=3, class A_> const_reference octree_node<T_,d_,A_>::operator *
|
|
*() const \brief Provide read-only access to the application-specific data.
|
|
*/
|