itkJointDomainImageToListSampleAdaptor.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkJointDomainImageToListSampleAdaptor.h,v $
  Language:  C++
  Date:      $Date: 2009-05-22 12:55:00 $
  Version:   $Revision: 1.3 $

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

#include "itkMacro.h"
#include "itkFixedArray.h"
#include "itkPoint.h"
#include "itkPixelTraits.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkListSample.h"

namespace itk { 
namespace Statistics {

template< class TImage >
struct ImageJointDomainTraits
{
  typedef ImageJointDomainTraits                          Self;
  typedef PixelTraits< typename TImage::PixelType >       PixelTraitsType;
  typedef typename PixelTraitsType::ValueType             RangeDomainMeasurementType;
  typedef typename TImage::IndexType::IndexValueType      IndexValueType;

  itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension);
  itkStaticConstMacro(Dimension, 
                      unsigned int, 
                      TImage::ImageDimension +
                      PixelTraitsType::Dimension );

  typedef float                                                              CoordinateRepType;
  typedef Point< CoordinateRepType, itkGetStaticConstMacro(ImageDimension) > PointType;
  typedef JoinTraits< RangeDomainMeasurementType, CoordinateRepType >        JoinTraitsType;
  typedef typename JoinTraitsType::ValueType                                 MeasurementType;

  typedef FixedArray< MeasurementType, itkGetStaticConstMacro(Dimension) >
  MeasurementVectorType;
}; // end of ImageJointDomainTraits


template < class TImage >
class ITK_EXPORT JointDomainImageToListSampleAdaptor 
  : public ListSample< typename ImageJointDomainTraits< TImage >::MeasurementVectorType >
{
public:

  typedef JointDomainImageToListSampleAdaptor Self;

  typedef ListSample < 
      typename ImageJointDomainTraits< TImage >::MeasurementVectorType >   Superclass;

  typedef SmartPointer< Self >                Pointer;
  typedef SmartPointer<const Self>            ConstPointer;
  
 
  typedef ImageJointDomainTraits< TImage > ImageJointDomainTraitsType;

  typedef typename ImageJointDomainTraitsType::MeasurementVectorType
                                                   MeasurementVectorType;

  typedef typename ImageJointDomainTraitsType::MeasurementType
                                                   MeasurementType;

  typedef typename ImageJointDomainTraitsType::RangeDomainMeasurementType
                                                   RangeDomainMeasurementType;

  typedef typename ImageJointDomainTraitsType::PointType   PointType;

  typedef typename ImageJointDomainTraitsType::CoordinateRepType 
                                                   CoordinateRepType;
  itkTypeMacro(JointDomainImageToListSampleAdaptor, ListSample);

  itkNewMacro(Self);

  itkStaticConstMacro(MeasurementVectorSize, 
                      unsigned int, 
                      ImageJointDomainTraitsType::Dimension);

  itkSuperclassTraitMacro( MeasurementVectorSizeType )


  itkSuperclassTraitMacro( AbsoluteFrequencyType )
    itkSuperclassTraitMacro( TotalAbsoluteFrequencyType )
  itkSuperclassTraitMacro( InstanceIdentifier )

  typedef TImage                                          ImageType;
  typedef ImageRegionIterator< ImageType >                ImageIteratorType; 
  typedef ImageRegionConstIterator< ImageType >           ImageConstIteratorType; 

  typedef typename ImageType::Pointer                     ImagePointer;
  typedef typename ImageType::ConstPointer                ImageConstPointer;
  typedef typename ImageType::PixelType                   PixelType;
  typedef typename ImageType::PixelContainerConstPointer  PixelContainerConstPointer;
  typedef typename ImageType::IndexType                   ImageIndexType;
  typedef typename ImageType::IndexType::IndexValueType   ImageIndexValueType;
  typedef typename ImageType::SizeType                    ImageSizeType;
  typedef typename ImageType::RegionType                  ImageRegionType;
  typedef MeasurementVectorType                           ValueType;
 
  void SetImage(const TImage* image);

  const TImage* GetImage() const;

  InstanceIdentifier Size() const;

  AbsoluteFrequencyType GetFrequency(InstanceIdentifier id) const;

  TotalAbsoluteFrequencyType GetTotalFrequency() const;

  itkStaticConstMacro(RangeDomainDimension, 
                      unsigned int, 
                      itk::PixelTraits< 
                      typename TImage::PixelType >::Dimension);

  typedef FixedArray< RangeDomainMeasurementType, 
                      itkGetStaticConstMacro( RangeDomainDimension ) > 
  RangeDomainMeasurementVectorType;

  typedef std::vector< InstanceIdentifier > InstanceIdentifierVectorType; 

  typedef FixedArray< float, itkGetStaticConstMacro(MeasurementVectorSize) >
                                            NormalizationFactorsType;

  void SetNormalizationFactors(NormalizationFactorsType& factors);

  const MeasurementVectorType & GetMeasurementVector( InstanceIdentifier id) const; 

  itkSetMacro( UsePixelContainer, bool );
  itkGetConstMacro( UsePixelContainer, bool );
  itkBooleanMacro( UsePixelContainer );

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

  class ConstIterator
    {
    friend class JointDomainImageToListSampleAdaptor;
    public:

    ConstIterator( const JointDomainImageToListSampleAdaptor * adaptor )
      {
      *this = adaptor->Begin();
      }

    ConstIterator(const ConstIterator &iter)
      {
      m_InstanceIdentifier = iter.m_InstanceIdentifier;
      m_Adaptor            = iter.m_Adaptor;
      }

    ConstIterator& operator=( const ConstIterator & iter )
      {
      m_InstanceIdentifier = iter.m_InstanceIdentifier;
      return *this;
      }

    AbsoluteFrequencyType GetFrequency() const
      {
      return 1;
      }

    const MeasurementVectorType & GetMeasurementVector() const
      {
      m_MeasurementVectorCache = m_Adaptor->GetMeasurementVector( m_InstanceIdentifier );
      return this->m_MeasurementVectorCache;
      }

    InstanceIdentifier GetInstanceIdentifier() const
      {
      return m_InstanceIdentifier;
      }

    ConstIterator& operator++()
      {
      ++m_InstanceIdentifier;
      return *this;
      }

    bool operator!=(const ConstIterator &it)
      {
      return (m_InstanceIdentifier != it.m_InstanceIdentifier);
      }

    bool operator==(const ConstIterator &it)
      {
      return (m_InstanceIdentifier == it.m_InstanceIdentifier);
      }

#if !(defined(_MSC_VER) && (_MSC_VER <= 1200))
  protected:
#endif
    // This method should only be available to the ListSample class
    ConstIterator(
      const JointDomainImageToListSampleAdaptor * adaptor,
      InstanceIdentifier iid)
      {
      m_Adaptor = adaptor;
      m_InstanceIdentifier = iid;
      }

    // This method is purposely not implemented
    ConstIterator();

  private:
    mutable MeasurementVectorType                   m_MeasurementVectorCache;
    InstanceIdentifier                              m_InstanceIdentifier;
    const JointDomainImageToListSampleAdaptor *     m_Adaptor; 
    };

  class Iterator : public ConstIterator
  {

  friend class JointDomainImageToListSampleAdaptor;

  public:

    Iterator(Self * adaptor):ConstIterator(adaptor)
      {
      }

    Iterator(const Iterator &iter):ConstIterator( iter )
      {
      }

    Iterator& operator =(const Iterator & iter)
      {
      this->ConstIterator::operator=( iter );
      return *this;
      }

#if !(defined(_MSC_VER) && (_MSC_VER <= 1200))
  protected:
#endif
    // To ensure const-correctness these method must not be in the public API.
    // The are purposly not implemented, since they should never be called.
    Iterator();
    Iterator(const Self * adaptor);
    Iterator(const ConstIterator & it);
    ConstIterator& operator=(const ConstIterator& it);
    Iterator(
      const JointDomainImageToListSampleAdaptor * adaptor,
      InstanceIdentifier iid):ConstIterator( adaptor, iid )
      {
      }

  private:
  };


  Iterator Begin()
    {
    Iterator iter(this, 0);
    return iter;
    }

  Iterator End()
    {
    Iterator iter(this, m_Image->GetPixelContainer()->Size());
    return iter;
    }

  ConstIterator Begin() const
    {
    ConstIterator iter(this, 0);
    return iter;
    }

  ConstIterator End() const
    {
    ConstIterator iter(this, m_Image->GetPixelContainer()->Size());
    return iter;
    }

 
protected:
  JointDomainImageToListSampleAdaptor();
  virtual ~JointDomainImageToListSampleAdaptor() {}
  void PrintSelf(std::ostream& os, Indent indent) const;  

private:
  JointDomainImageToListSampleAdaptor(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  NormalizationFactorsType                  m_NormalizationFactors;
  mutable MeasurementVectorType             m_TempVector;
  mutable PointType                         m_TempPoint;
  mutable ImageIndexType                    m_TempIndex;
  mutable RangeDomainMeasurementVectorType  m_TempRangeVector;
  ImageConstPointer                         m_Image;
  bool                                      m_UsePixelContainer;

  PixelContainerConstPointer                m_PixelContainer;

}; // end of class JointDomainImageToListSampleAdaptor

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

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

#endif