itkImageRandomNonRepeatingConstIteratorWithIndex.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageRandomNonRepeatingConstIteratorWithIndex.h,v $
  Language:  C++
  Date:      $Date: 2009-02-05 19:04:57 $
  Version:   $Revision: 1.9 $

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

#include "itkImageConstIteratorWithIndex.h"
#include "itkImage.h"
#include <algorithm>
#include <iostream>
#include "itkMersenneTwisterRandomVariateGenerator.h"


namespace itk
{


class NodeOfPermutation
{
public:
  unsigned long   m_Priority;
  unsigned long   m_Index;
  double          m_Value;

  NodeOfPermutation ()
    {
    m_Priority=0;
    m_Index=0;
    m_Value=0.0;
    }

  bool operator<( const NodeOfPermutation& b) const
    {
    if(m_Priority==b.m_Priority)
      {
      return m_Value < b.m_Value;
      }
    else
      {
      return m_Priority < b.m_Priority;
      }
    }
};


class RandomPermutation
{
public:
  typedef Statistics::MersenneTwisterRandomVariateGenerator::Pointer GeneratorPointer;
  NodeOfPermutation *   m_Permutation;
  GeneratorPointer      m_Generator;
  unsigned long         m_Size;

  RandomPermutation(unsigned long sz)
    {
    m_Size = sz;
    m_Permutation = new NodeOfPermutation[m_Size];
    m_Generator = Statistics::MersenneTwisterRandomVariateGenerator::New();
    this->Shuffle();
    }

  void Dump()
    {
    for(unsigned int i=0;i<m_Size;i++)
      {
      std::cout<<m_Permutation[i].m_Value<<" "<<m_Permutation[i].m_Priority
               <<" "<<m_Permutation[i].m_Index<<";";
      std::cout<<std::endl;
      }
    }

  void SetPriority(unsigned long i,unsigned long priority)
    {
    if(i>m_Size)
      {
      std::cerr<<"Error - i dont have "<<i<<" elements"<<std::endl;
      }
    else
      {
      m_Permutation[i].m_Priority = priority;
      }
    }

  void Shuffle()
    {
    for(unsigned int i=0; i < m_Size; i++ )
      {
      m_Permutation[i].m_Value = m_Generator->GetVariateWithClosedRange ( 1.0 );
      m_Permutation[i].m_Index=i;
      }
    std::sort(m_Permutation,m_Permutation+m_Size);
    }

  unsigned long operator[](unsigned long i)
    {
    return m_Permutation[i].m_Index;
    }

  ~RandomPermutation()
    {
    delete [] m_Permutation;
    }

  void ReinitializeSeed()
    {
    m_Generator->Initialize();
    }

  void ReinitializeSeed(int seed)
    {
    m_Generator->Initialize ( seed );
    }
};


template<typename TImage>
class ITK_EXPORT ImageRandomNonRepeatingConstIteratorWithIndex : public ImageConstIteratorWithIndex<TImage>
{
public:
  typedef ImageRandomNonRepeatingConstIteratorWithIndex   Self;
  typedef ImageConstIteratorWithIndex<TImage>             Superclass;

  typedef typename TImage::IndexType   IndexType;

  typedef typename TImage::RegionType RegionType;

  typedef TImage ImageType;

  typedef typename TImage::PixelContainer       PixelContainer;
  typedef typename PixelContainer::Pointer      PixelContainerPointer;

  ImageRandomNonRepeatingConstIteratorWithIndex();
  ~ImageRandomNonRepeatingConstIteratorWithIndex()
    { 
    if( m_Permutation )
      {
      delete m_Permutation;
      }
    }

  ImageRandomNonRepeatingConstIteratorWithIndex(const ImageType *ptr, const RegionType& region);

  ImageRandomNonRepeatingConstIteratorWithIndex( const ImageConstIteratorWithIndex<TImage> &it)
    {
    this->ImageConstIteratorWithIndex<TImage>::operator=(it);
    m_Permutation = NULL;
    }

  void GoToBegin(void)
    {
    m_NumberOfSamplesDone = 0L;
    this->UpdatePosition();
    }

  void GoToEnd(void)
    {
    m_NumberOfSamplesDone = m_NumberOfSamplesRequested;
    this->UpdatePosition();
    }

  bool IsAtBegin(void) const
    {
    return (m_NumberOfSamplesDone == 0L);
    }

  bool IsAtEnd(void) const
    {
    return (m_NumberOfSamplesDone >= m_NumberOfSamplesRequested);
    }


  itkStaticConstMacro( ImageDimension, unsigned int, ::itk::GetImageDimension< TImage >::ImageDimension );


  typedef itk::Image< unsigned long, itkGetStaticConstMacro(ImageDimension ) >  PriorityImageType;

  void SetPriorityImage(const PriorityImageType * priorityImage);

  Self & operator++()
    {
    m_NumberOfSamplesDone++;
    this->UpdatePosition();
    return *this;
    }

  Self & operator--()
    {
    m_NumberOfSamplesDone--;
    this->UpdatePosition();
    return *this;
    }

  void SetNumberOfSamples( unsigned long number );
  unsigned long GetNumberOfSamples( void ) const;

  void ReinitializeSeed();

  void ReinitializeSeed(int);

private:
  void UpdatePosition();

  unsigned long           m_NumberOfSamplesRequested;
  unsigned long           m_NumberOfSamplesDone;
  unsigned long           m_NumberOfPixelsInRegion;
  RandomPermutation *     m_Permutation;
};

} // end namespace itk

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

#endif