Public Member Functions
	CoverTreeNode (const Observation &o)

void	addChild (int level, CoverTreeNode *p)

void	addObservation (const Observation &o)

double	distance (const CoverTreeNode &p) const

bool	isSingle () const

bool	hasObservation (const Observation &o) const

std::vector< CoverTreeNode * >	getChildren (int level) const

const Observation &	getObservation () const

const std::vector< Observation > &	getObservations ()

void	removeChild (int level, CoverTreeNode *p)

void	removeObservation (const Observation &o)

std::vector< CoverTreeNode * >	getAllChildren () const

Private Attributes
std::map< int, std::vector< CoverTreeNode * > >	_childMap

std::vector< Observation >	_observations

Detailed Description

Definition at line 12 of file Covertree.h.

Constructor & Destructor Documentation

◆ CoverTreeNode()

Covertree::CoverTreeNode::CoverTreeNode ( const Observation & o )

Definition at line 342 of file Covertree.cpp.

                                                           {/*{{{*/
    _observations.push_back(p);
 }/*}}}*/

Member Function Documentation

◆ addChild()

void Covertree::CoverTreeNode::addChild	(	int	level,
		CoverTreeNode *	p
	)

Returns the children of the node at level i. Note that this means the children exist in cover set i-1, not level i.

Does not include the node itself, though technically every node has itself as a child in a cover tree.

Definition at line 335 of file Covertree.cpp.

                                                                   {/*{{{*/
    _childMap[level].push_back(p);
 }/*}}}*/

◆ addObservation()

void Covertree::CoverTreeNode::addObservation ( const Observation & o )

Definition at line 338 of file Covertree.cpp.

                                                                  {/*{{{*/
    if(find(_observations.begin(), _observations.end(), p) == _observations.end())
     _observations.push_back(p);
 }/*}}}*/

◆ distance()

double Covertree::CoverTreeNode::distance ( const CoverTreeNode & p ) const

Definition at line 345 of file Covertree.cpp.

                                                                    {/*{{{*/
    return _observations[0].distance(p.getObservation());
 }/*}}}*/

◆ isSingle()

bool Covertree::CoverTreeNode::isSingle ( ) const

Definition at line 373 of file Covertree.cpp.

                                              {/*{{{*/
    return _observations.size() == 1;
 }/*}}}*/

◆ hasObservation()

bool Covertree::CoverTreeNode::hasObservation ( const Observation & o ) const

Definition at line 370 of file Covertree.cpp.

                                                                        {/*{{{*/
    return find(_observations.begin(), _observations.end(), p) != _observations.end();
 }/*}}}*/

◆ getChildren()

std::vector< Covertree::CoverTreeNode * > Covertree::CoverTreeNode::getChildren ( int level ) const

Definition at line 356 of file Covertree.cpp.

                                                                                      {/*{{{*/
    std::map<int,std::vector<CoverTreeNode*> >::const_iterator
      it = _childMap.find(level);
    if(it!=_childMap.end()) {
       return it->second;
    }
    return std::vector<CoverTreeNode*>();
 }/*}}}*/

◆ getObservation()

const Observation & Covertree::CoverTreeNode::getObservation ( ) const

Definition at line 364 of file Covertree.cpp.

                                                                {/*{{{*/
    return _observations[0]; 
 }/*}}}*/

◆ getObservations()

const std::vector<Observation>& Covertree::CoverTreeNode::getObservations ( )

inline

Definition at line 34 of file Covertree.h.

34 { return _observations; }

◆ removeChild()

void Covertree::CoverTreeNode::removeChild	(	int	level,
		CoverTreeNode *	p
	)

Definition at line 415 of file Covertree.cpp.

                                                                      {/*{{{*/
    std::vector<CoverTreeNode*>& v = _childMap[level];
    for(unsigned int i=0;i<v.size();i++) {
       if(v[i]==p) {
          v[i]=v.back();
          v.pop_back();
          break;
       }
    }
 }/*}}}*/

◆ removeObservation()

void Covertree::CoverTreeNode::removeObservation ( const Observation & o )

Definition at line 425 of file Covertree.cpp.

                                                                     {/*{{{*/
    std::vector<Observation>::iterator it =
      find(_observations.begin(), _observations.end(), p);
    if(it != _observations.end())
     _observations.erase(it);
 }/*}}}*/

◆ getAllChildren()

std::vector< Covertree::CoverTreeNode * > Covertree::CoverTreeNode::getAllChildren ( ) const

Return every child of the node from any level. This is handy for the destructor.

Definition at line 348 of file Covertree.cpp.

                                                                                {/*{{{*/
    std::vector<CoverTreeNode*> children;
    std::map<int,std::vector<CoverTreeNode*> >::const_iterator it;
    for(it=_childMap.begin();it!=_childMap.end();++it) {
       children.insert(children.end(), it->second.begin(), it->second.end());
    }
    return children;
 }/*}}}*/

Field Documentation

◆ _childMap

std::map<int,std::vector<CoverTreeNode*> > Covertree::CoverTreeNode::_childMap

private

Definition at line 15 of file Covertree.h.

◆ _observations

std::vector<Observation> Covertree::CoverTreeNode::_observations