itkVariableDimensionHistogram.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVariableDimensionHistogram.h,v $
  Language:  C++
  Date:      $Date: 2009-03-04 20:26:56 $
  Version:   $Revision: 1.8 $

  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 __itkVariableDimensionHistogram_h
#define __itkVariableDimensionHistogram_h

#include <vector>

#include "itkIndex.h"
#include "itkSize.h"
#include "itkArray.h"
#include "itkSample.h"
#include "itkDenseFrequencyContainer.h"
#include "itkSparseFrequencyContainer.h"

namespace itk {
namespace Statistics {

template < class TMeasurement = float, 
           class TFrequencyContainer = DenseFrequencyContainer > 
class ITK_EXPORT VariableDimensionHistogram 
  : public Sample < Array< TMeasurement > >
{
public:

  typedef VariableDimensionHistogram      Self;
  typedef Sample< Array< TMeasurement > > Superclass;
  typedef SmartPointer<Self>              Pointer;
  typedef SmartPointer<const Self>        ConstPointer;

  itkTypeMacro(VariableDimensionHistogram, Sample);

  itkNewMacro(Self);

  typedef TMeasurement MeasurementType;

  typedef typename Superclass::MeasurementVectorType     MeasurementVectorType;
  typedef typename Superclass::InstanceIdentifier        InstanceIdentifier;
  typedef typename Superclass::MeasurementVectorSizeType MeasurementVectorSizeType;
  typedef MeasurementVectorType                          ValueType;

  typedef TFrequencyContainer                      FrequencyContainerType;
  typedef typename FrequencyContainerType::Pointer FrequencyContainerPointer;

  typedef typename FrequencyContainerType::FrequencyType      FrequencyType;
  typedef typename FrequencyContainerType::TotalFrequencyType TotalFrequencyType;

  typedef itk::Array< long >             IndexType;
  typedef typename IndexType::ValueType  IndexValueType;

  typedef itk::Array< long >           SizeType;
  typedef typename SizeType::ValueType SizeValueType;

  typedef std::vector< MeasurementType >  BinMinVectorType;
  typedef std::vector< MeasurementType >  BinMaxVectorType;
  typedef std::vector< BinMinVectorType > BinMinContainerType;
  typedef std::vector< BinMaxVectorType > BinMaxContainerType;

  void Initialize(const SizeType &size);
  

  void Initialize(const SizeType &size, MeasurementVectorType& lowerBound,
                  MeasurementVectorType& upperBound);

  void SetToZero();

  bool GetIndex(const MeasurementVectorType & measurement,
                IndexType & index ) const;
  
  const IndexType & GetIndex(const InstanceIdentifier &ident) const;

  itkGetMacro(ClipBinsAtEnds, bool);

  itkSetMacro(ClipBinsAtEnds, bool);

  bool IsIndexOutOfBounds(const IndexType &index) const;

  InstanceIdentifier GetInstanceIdentifier(const IndexType &index) const;
  
  unsigned int Size() const;

  SizeType GetSize() const
    { return m_Size; }

  SizeValueType GetSize(const unsigned int dimension) const
    {
    return m_Size[dimension]; 
    }

  const MeasurementType& GetBinMin(const unsigned int dimension, 
                             const unsigned long nbin) const
  { return m_Min[dimension][nbin]; }

  const MeasurementType& GetBinMax(const unsigned int dimension,
                             const unsigned long nbin) const
  { return m_Max[dimension][nbin]; }
  
  void SetBinMin(const unsigned int dimension, const unsigned long nbin,
                 const MeasurementType min)
    { m_Min[dimension][nbin] = min; }
  
  void SetBinMax(const unsigned int dimension, 
                 unsigned long nbin, const MeasurementType max)
  { m_Max[dimension][nbin] = max; }
  
  const MeasurementType& GetBinMinFromValue(const unsigned int dimension, 
                                      const float value ) const;
  
  const MeasurementType& GetBinMaxFromValue(const unsigned int dimension, 
                                      const float value ) const;
  
  const BinMinVectorType& GetDimensionMins(const unsigned int dimension) const
  { return m_Min[dimension]; }
  
  const BinMaxVectorType& GetDimensionMaxs(const unsigned int dimension) const
  {  return m_Max[dimension]; }
  
  const BinMinContainerType& GetMins() const
    { return m_Min; }
  const BinMaxContainerType& GetMaxs() const
    { return m_Max; }
  
  MeasurementVectorType& GetHistogramMinFromValue(const MeasurementVectorType 
                                                  &measurement); 
  
  MeasurementVectorType& GetHistogramMaxFromValue(const MeasurementVectorType 
                                                  &measurement); 
  
  MeasurementVectorType& GetHistogramMinFromIndex(const IndexType &index);
  
  MeasurementVectorType& GetHistogramMaxFromIndex(const IndexType &index); 
  
  FrequencyType GetFrequency(const InstanceIdentifier &ident) const
  { return m_FrequencyContainer->GetFrequency(ident); }

  FrequencyType GetFrequency(const IndexType &index) const;

  void SetFrequency(const FrequencyType value);

  bool SetFrequency(const InstanceIdentifier &ident, const FrequencyType value) 
  { return m_FrequencyContainer->SetFrequency(ident, value); }

  bool SetFrequency(const IndexType &index, 
                    const FrequencyType value);
  
  bool SetFrequency(const MeasurementVectorType &measurement, 
                    const FrequencyType value);


  bool IncreaseFrequency(const InstanceIdentifier &ident,
                         const FrequencyType value) 
  { return m_FrequencyContainer->IncreaseFrequency(ident, value); }

  bool IncreaseFrequency(const IndexType &index, 
                         const FrequencyType value);
  
  bool IncreaseFrequency(const MeasurementVectorType &measurement, 
                         const FrequencyType value);
  
  const MeasurementVectorType & GetMeasurementVector(const InstanceIdentifier &ident) const;
  
  const MeasurementVectorType & GetMeasurementVector(const IndexType &index) const;
  
  MeasurementType GetMeasurement(const unsigned long n,
                                  const unsigned int dimension) const;

  TotalFrequencyType GetTotalFrequency() const;

  FrequencyType GetFrequency(const unsigned long n,
                             const unsigned int dimension) const;

  double Quantile(const unsigned int dimension, const double &p) const;

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

public:
  class Iterator
    {
    public:
    Iterator(){};
    
    Iterator(Self * histogram) 
      { 
      m_Id = 0;
      m_Histogram = histogram; 
      } 
    
    Iterator(InstanceIdentifier ident, Self * histogram)
      : m_Id(ident), m_Histogram(histogram) {}
    
    FrequencyType GetFrequency() const
      { 
      return  m_Histogram->GetFrequency(m_Id);
      }
    
    bool SetFrequency(const FrequencyType value) 
      { 
      return m_Histogram->SetFrequency(m_Id, value); 
      }

    InstanceIdentifier GetInstanceIdentifier() const
      { return m_Id; }

    const MeasurementVectorType & GetMeasurementVector() const
      { 
      return m_Histogram->GetMeasurementVector(m_Id);
      } 

    Iterator& operator++() 
      { 
      ++m_Id; 
      return *this;
      }
    
    bool operator!=(const Iterator& it) 
      { return (m_Id != it.m_Id); }
    
    bool operator==(const Iterator& it) 
      { return (m_Id == it.m_Id); }
    
    Iterator& operator=(const Iterator& it)
      { 
      m_Id  = it.m_Id;
      m_Histogram = it.m_Histogram; 
      return *this;
      }

    Iterator(const Iterator& it)
      { 
      m_Id        = it.m_Id;
      m_Histogram = it.m_Histogram; 
      }
   
    private:
      // Iterator pointing DenseFrequencyContainer
      InstanceIdentifier m_Id;
      
      // Pointer of DenseFrequencyContainer
      Self* m_Histogram;
  }; // end of iterator class

  // Const Iterator
  class ConstIterator
    {
    public:
    ConstIterator(){};
    
    ConstIterator(const Self * histogram) 
      { 
      m_Id = 0;
      m_Histogram = histogram; 
      } 
    
    ConstIterator(InstanceIdentifier ident, const Self * histogram)
      : m_Id(ident), m_Histogram(histogram) {}
    
    FrequencyType GetFrequency() const
      { 
      return  m_Histogram->GetFrequency(m_Id);
      }
    
    bool SetFrequency(const FrequencyType value) 
      { 
      return m_Histogram->SetFrequency(m_Id, value); 
      }

    InstanceIdentifier GetInstanceIdentifier() const
      { return m_Id; }

    const MeasurementVectorType & GetMeasurementVector() const
      { 
      return m_Histogram->GetMeasurementVector(m_Id);
      } 

    ConstIterator& operator++() 
      { 
      ++m_Id; 
      return *this;
      }
    
    bool operator!=(const ConstIterator& it) 
      { return (m_Id != it.m_Id); }
    
    bool operator==(const ConstIterator& it) 
      { return (m_Id == it.m_Id); }
    
    ConstIterator& operator=(const ConstIterator& it)
      { 
      m_Id  = it.m_Id;
      m_Histogram = it.m_Histogram; 
      return *this;
      }

    ConstIterator(const ConstIterator & it)
      { 
      m_Id        = it.m_Id;
      m_Histogram = it.m_Histogram; 
      }
   
    private:
    // ConstIterator pointing DenseFrequencyContainer
    InstanceIdentifier m_Id;
    
    // Pointer of DenseFrequencyContainer
    const Self* m_Histogram;
  }; // end of iterator class

  Iterator  Begin()
    { 
    Iterator iter(0, this); 
    return iter;
    }
           
  Iterator  End()
    {
    return Iterator(m_OffsetTable[this->GetMeasurementVectorSize()], this);
    }
  
  ConstIterator  Begin() const
    { 
    ConstIterator iter(0, this); 
    return iter;
    }
           
  ConstIterator End() const
    {
    return ConstIterator(m_OffsetTable[this->GetMeasurementVectorSize()], this);
    }

protected:
  VariableDimensionHistogram();
  virtual ~VariableDimensionHistogram() {}

  void SetMeasurementVectorSize( const MeasurementVectorSizeType );

  // The number of bins for each dimension
  SizeType m_Size;
  
private:
  VariableDimensionHistogram(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  Array< InstanceIdentifier > m_OffsetTable;
  FrequencyContainerPointer   m_FrequencyContainer;
  unsigned int                m_NumberOfInstances;

  // lower bound of each bin
  std::vector< std::vector<MeasurementType> > m_Min;
  
  // upper bound of each bin
  std::vector< std::vector<MeasurementType> > m_Max;
  
  mutable MeasurementVectorType   m_TempMeasurementVector;
  mutable IndexType               m_TempIndex;

  bool                            m_ClipBinsAtEnds;

}; // end of class

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

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

#endif