Review/Statistics/itkSample.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSample.h,v $
  Language:  C++
  Date:      $Date: 2009-05-02 05:43:58 $
  Version:   $Revision: 1.1 $

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

#include "itkMacro.h"
#include "itkPoint.h"
#include "itkSize.h"
#include "itkDataObject.h"
#include "itkFixedArray.h"
#include "itkMeasurementVectorTraits.h"
#include "itkNumericTraits.h"
#include <vector> // for the size_type declaration


namespace itk { 
namespace Statistics {

template < class TMeasurementVector >
class ITK_EXPORT Sample : public DataObject
{
public:
  typedef Sample                        Self;  
  typedef DataObject                    Superclass;
  typedef SmartPointer< Self >          Pointer;
  typedef SmartPointer<const Self >     ConstPointer;

  itkTypeMacro(Sample, DataObject);

  typedef TMeasurementVector MeasurementVectorType;

  typedef typename MeasurementVectorTraitsTypes< 
    MeasurementVectorType >::ValueType   MeasurementType;

  typedef MeasurementVectorTraits::AbsoluteFrequencyType       AbsoluteFrequencyType;

  typedef NumericTraits<AbsoluteFrequencyType>::AccumulateType TotalAbsoluteFrequencyType;

  typedef typename MeasurementVectorTraits::InstanceIdentifier  InstanceIdentifier;

  typedef unsigned int  MeasurementVectorSizeType;

  virtual InstanceIdentifier Size() const = 0;

  virtual const MeasurementVectorType & 
    GetMeasurementVector( InstanceIdentifier id) const = 0;

  virtual AbsoluteFrequencyType GetFrequency( InstanceIdentifier id ) const = 0;

  virtual TotalAbsoluteFrequencyType GetTotalFrequency() const = 0;

  
  virtual void SetMeasurementVectorSize( MeasurementVectorSizeType s )
    {
    // Test whether the vector type is resizable or not
    MeasurementVectorType m;
    if( MeasurementVectorTraits::IsResizable( m ) )
      {
      // then this is a resizable vector type
      //
      // if the new size is the same as the previou size, just return
      if( s == this->m_MeasurementVectorSize )
        {
        return;
        }
      else
        {
        // If the new size is different from the current size, then
        // only change the measurement vector size if the container is empty.
        if( this->Size() )
          {
          itkExceptionMacro("Attempting to change the measurement \
          vector size of a non-empty Sample");
          }
        else
          {
          this->m_MeasurementVectorSize = s;
          this->Modified();
          }
        }
      }
    else
      {
      // If this is a non-resizable vector type
      MeasurementVectorType m3;
      MeasurementVectorSizeType defaultLength = MeasurementVectorTraits::GetLength( m3 );
      // and the new length is different from the default one, then throw an exception
      if( defaultLength != s )
        {
        itkExceptionMacro("Attempting to change the measurement \
                           vector size of a non-resizable vector type");
        }
      }
    }

  itkGetConstMacro( MeasurementVectorSize, MeasurementVectorSizeType );

  virtual void Graft( const DataObject *thatObject )
    {
    this->Superclass::Graft(thatObject);

    const Self *thatConst = dynamic_cast< const Self * >(thatObject);
    if (thatConst)
      {
      this->SetMeasurementVectorSize(thatConst->GetMeasurementVectorSize());
      }
    }
  
protected:
  Sample()
    {
    m_MeasurementVectorSize = MeasurementVectorTraits::GetLength( 
                                        MeasurementVectorType() );
    }

  virtual ~Sample() {}

  void PrintSelf(std::ostream& os, Indent indent) const
    {
    Superclass::PrintSelf(os,indent);
    os << indent << "Length of measurement vectors in the sample: " << 
      m_MeasurementVectorSize << std::endl;
    }


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

  MeasurementVectorSizeType m_MeasurementVectorSize;
}; // end of class

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

#endif