itkNarrowBandImageFilterBase.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkNarrowBandImageFilterBase.h,v $
  Language:  C++
  Date:      $Date: 2009-04-25 12:27:38 $
  Version:   $Revision: 1.11 $

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

#include "itkFiniteDifferenceImageFilter.h"
#include "itkMultiThreader.h"
#include "itkNarrowBand.h"
#include "itkBarrier.h"
#include "itkObjectStore.h"

namespace itk {

template <class TInputImage, class TOutputImage>
class NarrowBandImageFilterBase  
  : public FiniteDifferenceImageFilter<TInputImage, TOutputImage>
{
public:
  typedef NarrowBandImageFilterBase                              Self;
  typedef FiniteDifferenceImageFilter<TInputImage, TOutputImage> Superclass;
  typedef SmartPointer<Self>                                     Pointer;
  typedef SmartPointer<const Self>                               ConstPointer;

  itkTypeMacro(NarrowBandImageFilterBase, ImageToImageFilter );
  
  typedef typename Superclass::InputImageType               InputImageType;
  typedef typename Superclass::OutputImageType              OutputImageType;
  typedef typename Superclass::FiniteDifferenceFunctionType FiniteDifferenceFunctionType;
  
  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
  
  typedef typename Superclass::PixelType PixelType;
  
  typedef typename Superclass::TimeStepType TimeStepType;

  typedef typename OutputImageType::IndexType IndexType;
  
  typedef typename OutputImageType::ValueType ValueType;

  typedef BandNode<IndexType,PixelType> BandNodeType;

  typedef NarrowBand<BandNodeType>            NarrowBandType;
  typedef typename NarrowBandType::Pointer    NarrowBandPointer;
  typedef typename NarrowBandType::RegionType RegionType;

  itkSetMacro( IsoSurfaceValue, ValueType);
  itkGetConstMacro( IsoSurfaceValue, ValueType);

  //  itkGetConstMacro( RMSChange, ValueType);
  
  void InsertNarrowBandNode (BandNodeType &node) 
    {
    m_NarrowBand->PushBack(node); // add new node 
    this->Modified();
    }
  void InsertNarrowBandNode (IndexType &index)
    {
    BandNodeType tmpnode;
    tmpnode.m_Index = index;
    m_NarrowBand->PushBack(tmpnode);
    this->Modified();
    }
  void InsertNarrowBandNode (IndexType &index, PixelType &value, signed char &nodestate)
    {
    BandNodeType tmpnode;
    tmpnode.m_Data = value;
    tmpnode.m_Index = index;
    tmpnode.m_NodeState = nodestate;
    
    m_NarrowBand->PushBack(tmpnode);
    this->Modified();
    } 
  
  void SetNarrowBandTotalRadius (float val)
    {
    if (m_NarrowBand->GetTotalRadius() != val)
      {
      m_NarrowBand->SetTotalRadius(val);
      this->Modified();
      }
    }
  
  float GetNarrowBandTotalRadius()
    {
    return m_NarrowBand->GetTotalRadius();
    }
  
  void SetNarrowBandInnerRadius (float val)
    {
    if (m_NarrowBand->GetInnerRadius() != val)
      {
      m_NarrowBand->SetInnerRadius(val);
      this->Modified();
      }
    }

  float GetNarrowBandInnerRadius()
    {
    return m_NarrowBand->GetInnerRadius();
    }
  
  virtual void CreateNarrowBand (){};
  
  virtual void SetNarrowBand(NarrowBandType * ptr)
    {
    if ( m_NarrowBand != ptr )
      {
      m_NarrowBand = ptr;
      this->Modified();
      }   
    }
  
  virtual void CopyInputToOutput ();
  
protected:
  typename NarrowBandType::Pointer m_NarrowBand;
  NarrowBandImageFilterBase() 
    {
    m_NarrowBand = NarrowBandType::New();
    m_NarrowBand->SetTotalRadius(4);
    m_NarrowBand->SetInnerRadius(2);
    m_ReinitializationFrequency = 6;
    m_IsoSurfaceValue = 0.0;
    m_Step    = 0;
    m_Touched = false;
    m_Barrier = Barrier::New();
    }
  
  virtual ~NarrowBandImageFilterBase() {}
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  struct ThreadRegionType 
    {
    typename NarrowBandType::Iterator first; // this is the actual first element
    typename NarrowBandType::Iterator last;  // this is one past the actual last //element
    };
  
  std::vector<RegionType> m_RegionList;
  
  void GetSplitRegion (int i, ThreadRegionType &splitRegion);
  
  virtual void Initialize();
  
  virtual void InitializeIteration();
  
  virtual void PostProcessOutput();
  
  /* This function clears all pixels from the narrow band */
  void ClearNarrowBand ();
  
  void WaitForAll();

  virtual void GenerateData();
  
  /* Variables to control reinitialization */
  unsigned int m_ReinitializationFrequency;
  unsigned int m_Step;
  bool         m_Touched;
  bool *       m_TouchedForThread;
  ValueType    m_IsoSurfaceValue;
  
  typename Barrier::Pointer m_Barrier;

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

  struct NarrowBandImageFilterBaseThreadStruct
    {
    NarrowBandImageFilterBase *Filter;
    TimeStepType TimeStep;
    TimeStepType *TimeStepList;
    bool *ValidTimeStepList;
    };
  
  /* This class does not use AllocateUpdateBuffer to allocate memory for its 
   * narrow band. This is taken care of in SetNarrowBand, and InsertNarrowBandNode
   * functions. This function is here for compatability with the 
   * FiniteDifferenceSolver framework.
   */
  virtual void AllocateUpdateBuffer() {};
  
  
  static ITK_THREAD_RETURN_TYPE IterateThreaderCallback( void *arg );
  
  virtual void ThreadedIterate(void *arg, int threadId);

  virtual void ThreadedApplyUpdate(TimeStepType dt,
                                   const ThreadRegionType &regionToProcess,
                                   int threadId);
  virtual void ApplyUpdate(TimeStepType){}

  virtual TimeStepType ThreadedCalculateChange(const ThreadRegionType &regionToProcess,
                                               int threadId);
  virtual TimeStepType CalculateChange() {return 0;}
  
};

}// end namespace itk

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

#endif