itkImageRandomNonRepeatingConstIteratorWithIndex.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageRandomNonRepeatingConstIteratorWithIndex.h,v $
  Language:  C++
  Date:      $Date: 2005-10-03 15:18:45 $
  Version:   $Revision: 1.6 $

  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
{


  /* 
     The itk::ImageRandomNonRepeatingIterator works by creating a random
     permutation of the image pixels and then using that to control the
     order in which it accesses them.  The classes nodeOfPermutation and
     randomPermutation are used to support that.  randomPermutation is
     basically container which holds nodeOfPermutation objects.  The
     node class overloads the < operator, which allows the sort algorithm
     from the STL to be used on it.
  */
  class nodeOfPermutation
  {
   public:
    unsigned long priority;
    unsigned long index;
    double value;
    nodeOfPermutation ()
    {
      priority=0;
      index=0;
      value=0.0;
    }
    bool operator<( const nodeOfPermutation& b) const
    {
      if(priority==b.priority)
        {
        return value < b.value;
        }
      else
        {
        return priority<b.priority;
        }
    }
  };
  class randomPermutation
  {
   public:
    nodeOfPermutation * permutation;
    Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_Generator;
    unsigned long size;
    randomPermutation(unsigned long sz)
    {
      size=sz;
      permutation=new nodeOfPermutation[size];
      m_Generator = Statistics::MersenneTwisterRandomVariateGenerator::New();
      this->Shuffle();
    }
    void Dump()
    {
      for(unsigned int i=0;i<size;i++)
        {
        std::cout<<permutation[i].value<<" "<<permutation[i].priority
                 <<" "<<permutation[i].index<<";";
        std::cout<<std::endl;
        }
    }
    void SetPriority(unsigned long i,unsigned long priority)
    {
      if(i>size)
        {
        std::cerr<<"Error - i dont have "<<i<<" elements"<<std::endl;
        }
      else
        {
        permutation[i].priority=priority;
        }
    }
    void Shuffle()
    {
      for(unsigned int i=0;i<size;i++)
        {
        permutation[i].value= m_Generator->GetVariateWithClosedRange ( 1.0 );
        permutation[i].index=i;
        }
      std::sort(permutation,permutation+size);
    }
    unsigned long operator[](unsigned long i)
    {
      return permutation[i].index;
    }
    ~randomPermutation()
    {
      delete [] 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 

---