itkKdTree.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkKdTree.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:29:46 $
  Version:   $Revision: 1.20 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkKdTree_h
#define __itkKdTree_h

#include <queue>
#include <vector>

#include "itkMacro.h"
#include "itkPoint.h"
#include "itkSize.h"
#include "itkObject.h"
#include "itkNumericTraits.h"
#include "itkArray.h"

#include "itkSample.h"
#include "itkSubsample.h"

#include "itkEuclideanDistance.h"

namespace itk{ 
namespace Statistics{

template< class TSample >
struct KdTreeNode
{
  typedef KdTreeNode< TSample> Self ;
  
  typedef typename TSample::MeasurementType MeasurementType ;
  
  itkStaticConstMacro(MeasurementVectorSize, unsigned int,
                      TSample::MeasurementVectorSize) ;

  typedef FixedArray< double, 
                      itkGetStaticConstMacro(MeasurementVectorSize) > CentroidType ;
  
  typedef typename TSample::InstanceIdentifier InstanceIdentifier ;

  virtual bool IsTerminal() = 0 ;

  virtual void GetParameters(unsigned int &partitionDimension, 
                             MeasurementType &partitionValue) = 0 ;  

  virtual Self* Left() = 0 ;

  virtual Self* Right() = 0 ;

  virtual unsigned int Size() = 0 ;

  virtual void GetWeightedCentroid(CentroidType &centroid) = 0 ;

  virtual void GetCentroid(CentroidType &centroid) = 0 ;

  virtual InstanceIdentifier GetInstanceIdentifier(size_t index) = 0 ;

  virtual void AddInstanceIdentifier(InstanceIdentifier id) = 0 ;

  virtual ~KdTreeNode() {}; // needed to subclasses will actually be deleted
} ; // end of class

template< class TSample >
struct KdTreeNonterminalNode: public KdTreeNode< TSample >
{
  typedef KdTreeNode< TSample > Superclass ;
  typedef typename Superclass::MeasurementType MeasurementType ;
  typedef typename Superclass::CentroidType CentroidType ;
  typedef typename Superclass::InstanceIdentifier InstanceIdentifier ;

  KdTreeNonterminalNode(unsigned int partitionDimension,
                        MeasurementType partitionValue,
                        Superclass* left,
                        Superclass* right) ;

  virtual ~KdTreeNonterminalNode() {}
  
  virtual bool IsTerminal()
  { return false ; }

  void GetParameters(unsigned int &partitionDimension, 
                     MeasurementType &partitionValue) ;

  Superclass* Left() 
  { return m_Left ; }

  Superclass* Right()
  { return m_Right ; }

  unsigned int Size()
  { return 0 ; }

  void GetWeightedCentroid(CentroidType &)
  { /* do nothing */ } 

  void GetCentroid(CentroidType &)
  { /* do nothing */ }

  InstanceIdentifier GetInstanceIdentifier(size_t)
  { return 0 ; }

  void AddInstanceIdentifier(InstanceIdentifier) {}

private:
  unsigned int m_PartitionDimension ;
  MeasurementType m_PartitionValue ;
  Superclass* m_Left ;
  Superclass* m_Right ;
} ; // end of class

template< class TSample >
struct KdTreeWeightedCentroidNonterminalNode: public KdTreeNode< TSample >
{
  typedef KdTreeNode< TSample > Superclass ;
  typedef typename Superclass::MeasurementType MeasurementType ;
  typedef typename Superclass::CentroidType CentroidType ;
  typedef typename Superclass::InstanceIdentifier InstanceIdentifier ;

  KdTreeWeightedCentroidNonterminalNode(unsigned int partitionDimension,
                                         MeasurementType partitionValue,
                                         Superclass* left,
                                         Superclass* right,
                                         CentroidType &centroid,
                                         unsigned int size) ;
  virtual ~KdTreeWeightedCentroidNonterminalNode() {}

  virtual bool IsTerminal()
  { return false ; }

  void GetParameters(unsigned int &partitionDimension, 
                     MeasurementType &partitionValue) ;

  Superclass* Left() 
  { return m_Left ; }

  Superclass* Right()
  { return m_Right ; }

  unsigned int Size()
  { return m_Size ; }

  void GetWeightedCentroid(CentroidType &centroid)
  { centroid = m_WeightedCentroid ; }

  void GetCentroid(CentroidType &centroid)
  { centroid = m_Centroid ; }

  InstanceIdentifier GetInstanceIdentifier(size_t)
  { return 0 ; }

  void AddInstanceIdentifier(InstanceIdentifier) {}

private:
  unsigned int m_PartitionDimension ;
  MeasurementType m_PartitionValue ;
  CentroidType m_WeightedCentroid ;
  CentroidType m_Centroid ;
  unsigned int m_Size ;
  Superclass* m_Left ;
  Superclass* m_Right ;
} ; // end of class


template< class TSample >
struct KdTreeTerminalNode: public KdTreeNode< TSample >
{
  typedef KdTreeNode< TSample > Superclass ;
  typedef typename Superclass::MeasurementType MeasurementType ;
  typedef typename Superclass::CentroidType CentroidType ;
  typedef typename Superclass::InstanceIdentifier InstanceIdentifier ;

  KdTreeTerminalNode() {}

  virtual ~KdTreeTerminalNode() {}

  bool IsTerminal()
  { return true ; }

  void GetParameters(unsigned int &, 
                     MeasurementType &) {}

  Superclass* Left() 
  { return 0 ; }

  Superclass* Right()
  { return 0 ; }

  unsigned int Size()
  { return static_cast<unsigned int>( m_InstanceIdentifiers.size() ); }

  void GetWeightedCentroid(CentroidType &)
  { /* do nothing */ } 

  void GetCentroid(CentroidType &)
  { /* do nothing */ } 

  InstanceIdentifier GetInstanceIdentifier(size_t index)
  { return m_InstanceIdentifiers[index] ; }

  void AddInstanceIdentifier(InstanceIdentifier id) 
  { m_InstanceIdentifiers.push_back(id) ;}

private:
  std::vector< InstanceIdentifier > m_InstanceIdentifiers ;
} ; // end of class

template < class TSample >
class ITK_EXPORT KdTree : public Object
{
public:
  typedef KdTree Self ;
  typedef Object Superclass ;
  typedef SmartPointer<Self> Pointer;

  itkTypeMacro(KdTree, Object);

  itkNewMacro(Self) ;

  typedef TSample SampleType ;
  typedef typename TSample::MeasurementVectorType MeasurementVectorType ;
  typedef typename TSample::MeasurementType MeasurementType ;
  typedef typename TSample::InstanceIdentifier InstanceIdentifier ;
  typedef typename TSample::FrequencyType FrequencyType ;

  itkStaticConstMacro(MeasurementVectorSize, unsigned int, 
                      TSample::MeasurementVectorSize) ;

  typedef EuclideanDistance< MeasurementVectorType > DistanceMetricType ;

  typedef KdTreeNode< TSample > KdTreeNodeType ;

  typedef std::pair< InstanceIdentifier, double > NeighborType ;

  typedef std::vector< InstanceIdentifier > InstanceIdentifierVectorType ;

  class NearestNeighbors
  {
  public:
    NearestNeighbors() {}
    
    ~NearestNeighbors() {} 
    
    void resize(unsigned int k)
    {
      m_Identifiers.clear() ;
      m_Identifiers.resize(k, NumericTraits< unsigned long >::max()) ;
      m_Distances.clear() ;
      m_Distances.resize(k, NumericTraits< double >::max()) ;
      m_FarthestNeighborIndex = 0 ;
    }

    double GetLargestDistance() 
    { return m_Distances[m_FarthestNeighborIndex] ; }

    void ReplaceFarthestNeighbor(InstanceIdentifier id, double distance) 
    {
      m_Identifiers[m_FarthestNeighborIndex] = id ;
      m_Distances[m_FarthestNeighborIndex] = distance ;
      double farthestDistance = NumericTraits< double >::min() ;
      const unsigned int size = static_cast<unsigned int>( m_Distances.size() );
      for ( unsigned int i = 0 ; i < size; i++ )
        {
        if ( m_Distances[i] > farthestDistance )
          {
          farthestDistance = m_Distances[i] ;
          m_FarthestNeighborIndex = i ;
          }
        }
    }

    InstanceIdentifierVectorType GetNeighbors()
    { return m_Identifiers ; }

    InstanceIdentifier GetNeighbor(unsigned int index)
    { return m_Identifiers[index] ; }

    std::vector< double >& GetDistances()
    { return m_Distances ; }

  private:
    unsigned int m_FarthestNeighborIndex ;
    
    InstanceIdentifierVectorType m_Identifiers ;

    std::vector< double > m_Distances ;
  } ;

  void SetBucketSize(unsigned int size) ;

  void SetSample(TSample* sample) ;

  TSample* GetSample()
  { return m_Sample ; }

  unsigned long Size()
  { return m_Sample->Size() ; }

  KdTreeNodeType* GetEmptyTerminalNode()
  { return m_EmptyTerminalNode ; } 

  void SetRoot(KdTreeNodeType* root) 
  { m_Root = root ; } 

  KdTreeNodeType* GetRoot() 
  { return m_Root ; } 

  MeasurementVectorType GetMeasurementVector(InstanceIdentifier id)
  { return m_Sample->GetMeasurementVector(id) ; }

  FrequencyType GetFrequency(InstanceIdentifier id)
  { return m_Sample->GetFrequency( id ) ; }

  DistanceMetricType* GetDistanceMetric()
  { return m_DistanceMetric.GetPointer() ; }

  void Search(MeasurementVectorType &query, 
              unsigned int k,
              InstanceIdentifierVectorType& result) ;

  void Search(MeasurementVectorType &query,
              double radius, 
              InstanceIdentifierVectorType& result) ;

  int GetNumberOfVisits()
  { return m_NumberOfVisits ; }

  bool BallWithinBounds(MeasurementVectorType &query, 
                        MeasurementVectorType &lowerBound,
                        MeasurementVectorType &upperBound,
                        double radius) ;

  bool BoundsOverlapBall(MeasurementVectorType &query, 
                         MeasurementVectorType &lowerBound,
                         MeasurementVectorType &upperBound,
                         double radius) ;

  void DeleteNode(KdTreeNodeType *node) ;

  void PrintTree(KdTreeNodeType *node, int level, 
                 unsigned int activeDimension) ;

  typedef typename TSample::Iterator Iterator ;

  Iterator Begin()
  {
    typename TSample::Iterator iter = m_Sample->Begin() ;
    return iter; 
  }

  Iterator End() 
  {
    Iterator iter = m_Sample->End() ;
    return iter; 
  }

protected:
  KdTree() ;
  
  virtual ~KdTree() ;

  void PrintSelf(std::ostream& os, Indent indent) const ;

  int NearestNeighborSearchLoop(KdTreeNodeType* node,
                                MeasurementVectorType &query,
                                MeasurementVectorType &lowerBound,
                                MeasurementVectorType &upperBound) ;

  int SearchLoop(KdTreeNodeType* node, MeasurementVectorType &query,
                 MeasurementVectorType &lowerBound,
                 MeasurementVectorType &upperBound) ;
private:
  KdTree(const Self&) ; //purposely not implemented
  void operator=(const Self&) ; //purposely not implemented

  TSample* m_Sample ;
  
  int m_BucketSize ;

  KdTreeNodeType* m_Root ;

  KdTreeNodeType* m_EmptyTerminalNode ;

  typename DistanceMetricType::Pointer m_DistanceMetric ;

  bool m_IsNearestNeighborSearch ;
 
  double m_SearchRadius ;

  InstanceIdentifierVectorType m_Neighbors ;

  NearestNeighbors m_NearestNeighbors ;

  MeasurementVectorType m_LowerBound ;

  MeasurementVectorType m_UpperBound ;

  int m_NumberOfVisits ;

  bool m_StopSearch ;

  NeighborType m_TempNeighbor ;
} ; // end of class

} // end of namespace Statistics
} // end of namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkKdTree.txx"
#endif

#endif

---