itkMembershipSample.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMembershipSample.h,v $
  Language:  C++
  Date:      $Date: 2005/09/30 17:24:45 $
  Version:   $Revision: 1.31 $

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

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

#include "itkExceptionObject.h"

namespace itk{ 
namespace Statistics{

template< class TSample >
class ITK_EXPORT MembershipSample : 
    public Sample< typename TSample::MeasurementVectorType >
{
public:
  typedef MembershipSample Self;
  typedef Sample< typename TSample::MeasurementVectorType > Superclass ;
  typedef SmartPointer< Self > Pointer ;
  typedef SmartPointer< const Self > ConstPointer ;

  itkTypeMacro(MembershipSample, Sample);
  itkNewMacro(Self) ;
  
  typedef typename TSample::MeasurementVectorType MeasurementVectorType;
  typedef typename TSample::MeasurementType MeasurementType;
  typedef typename TSample::InstanceIdentifier InstanceIdentifier;
  typedef typename TSample::FrequencyType FrequencyType ;
  typedef typename TSample::TotalFrequencyType TotalFrequencyType ;
  
  
  typedef std::vector< unsigned int > UniqueClassLabelsType ;

  typedef itk::hash_map< InstanceIdentifier, unsigned int> ClassLabelHolderType ;
  
  typedef Subsample< TSample > ClassSampleType ;
  typedef typename ClassSampleType::Pointer         ClassSamplePointer;
  typedef typename ClassSampleType::ConstPointer    ClassSampleConstPointer;
  
  void SetSample(const TSample* sample) ;

  const TSample* GetSample() const;
  
  void SetNumberOfClasses(unsigned int numberOfClasses) ;
  
  unsigned int GetNumberOfClasses() const ;

  void AddInstance(const unsigned int &classLabel, const InstanceIdentifier &id) ;
  unsigned int GetClassLabel(const InstanceIdentifier &id) const ;

  int GetInternalClassLabel(const unsigned int classLabel ) const ;

  unsigned int GetClassSampleSize(const unsigned int &classLabel) const ;

  const ClassSampleType* GetClassSample(const unsigned int &classLabel) const ;
  
  ClassLabelHolderType* GetClassLabels()
  { return &m_ClassLabelHolder ; }

  unsigned int Size(void) const ;
  
  const MeasurementVectorType & GetMeasurementVector(const InstanceIdentifier &id) const;
  
  MeasurementType GetMeasurement(const InstanceIdentifier &id, 
                                  const unsigned int &dimension) ;

  FrequencyType GetFrequency(const InstanceIdentifier &id) const ;
  
  TotalFrequencyType GetTotalFrequency() const ;

  void Resize(unsigned int n) 
  {
    m_ClassLabelHolder.resize(n) ;
  }

 
  class ConstIterator
  {
  public:
    ConstIterator(InstanceIdentifier id, const Self* membershipSample)
      :m_Id(id), m_MembershipSample(membershipSample),
       m_Sample(membershipSample->GetSample())
    {}
    
    FrequencyType GetFrequency() const
    { return  m_Sample->GetFrequency(m_Id) ; }
    
    const MeasurementVectorType & GetMeasurementVector() const
    { return m_Sample->GetMeasurementVector(m_Id) ; } 
    
    InstanceIdentifier GetInstanceIdentifier() const
    { return m_Id ; }

    void SetClassLabel(unsigned int classLabel)
    { m_MembershipSample->AddInstance(classLabel, m_Id) ; }

    unsigned int GetClassLabel() const
    { return m_MembershipSample->GetClassLabel(m_Id) ; }

    ConstIterator& operator++() 
    { 
      ++m_Id ;
      return *this ;
    }
    
    bool operator!=(const ConstIterator& it) 
    { 
      if (m_Id != it.m_Id || 
          m_MembershipSample != it.m_MembershipSample ||
          m_Sample != it.m_Sample)
        {
        return true ;
        }
      else
        {
        return false ;
        }
    }

    bool operator==(const ConstIterator& it) 
    { 
      if (m_Id == it.m_Id && 
          m_MembershipSample == it.m_MembershipSample &&
          m_Sample == it.m_Sample)
        {
        return true ;
        }
      else
        {
        return false ;
        }
    }
    
    ConstIterator& operator=(const ConstIterator& it)
    {
      m_Id = it.m_Id;
      m_MembershipSample = it.m_MembershipSample ;
      m_Sample = it.m_Sample ;
      return *this ;
    }

    ConstIterator(const ConstIterator& it)
    {
      m_Id = it.m_Id;
      m_MembershipSample = it.m_MembershipSample ;
      m_Sample = it.m_Sample ;
    }
    
  private:
    // identifier for the instance
    InstanceIdentifier m_Id ;  
    // Pointer to MemebershipSample object
    const Self* m_MembershipSample ;
    const TSample* m_Sample ;
  } ;

  ConstIterator Begin() const
  { 
    ConstIterator iter(0, this) ;
    return iter; 
  }
  
  ConstIterator  End() const        
  {
    ConstIterator iter(this->Size(), this) ; 
    return iter; 
  }
 
protected:
  MembershipSample() ;
  virtual ~MembershipSample() {}
  void PrintSelf(std::ostream& os, Indent indent) const;  
  
private:
  MembershipSample(const Self&) ; //purposely not implemented
  void operator=(const Self&) ; //purposely not implemented

  const TSample*                  m_Sample ;
  unsigned int                    m_CurrentClassLabel ;
  UniqueClassLabelsType           m_UniqueClassLabels ;
  ClassLabelHolderType            m_ClassLabelHolder ;
  unsigned int                    m_NumberOfClasses ;
  std::vector< unsigned int >     m_ClassSampleSizes ;
  std::vector< ClassSamplePointer > m_ClassSamples ;
} ; // end of class


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


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

#endif

---