itkConstrainedRegionBasedLevelSetFunctionSharedData.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConstrainedRegionBasedLevelSetFunctionSharedData.h,v $
  Language:  C++
  Date:      $Date: 2009-05-14 21:46:47 $
  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 __itkConstrainedRegionBasedLevelSetFunctionSharedData_h
#define __itkConstrainedRegionBasedLevelSetFunctionSharedData_h

#include "itkRegionBasedLevelSetFunctionSharedData.h"

namespace itk
{

template < class TInputImage, class TFeatureImage, class TSingleData >
class ConstrainedRegionBasedLevelSetFunctionSharedData :
  public RegionBasedLevelSetFunctionSharedData< TInputImage, TFeatureImage, TSingleData >
{
public:

  typedef ConstrainedRegionBasedLevelSetFunctionSharedData       Self;
  typedef RegionBasedLevelSetFunctionSharedData< TInputImage, TFeatureImage, TSingleData >
    Superclass;
  typedef SmartPointer<Self>                                Pointer;
  typedef SmartPointer<const Self>                          ConstPointer;

  itkStaticConstMacro( ImageDimension, unsigned int, TFeatureImage::ImageDimension );

  itkNewMacro( Self );

  itkTypeMacro(ConstrainedRegionBasedLevelSetFunctionSharedData, RegionBasedLevelSetFunctionSharedData);

  typedef TInputImage                                   InputImageType;
  typedef typename Superclass::InputImagePointer        InputImagePointer;
  typedef typename Superclass::InputImageConstPointer   InputImageConstPointer;
  typedef typename Superclass::InputPixelType           InputPixelType;
  typedef typename Superclass::InputRegionType          InputRegionType;
  typedef typename Superclass::InputSizeType            InputSizeType;
  typedef typename Superclass::InputSizeValueType       InputSizeValueType;
  typedef typename Superclass::InputSpacingType         InputSpacingType;
  typedef typename Superclass::InputIndexType           InputIndexType;
  typedef typename Superclass::InputIndexValueType      InputIndexValueType;
  typedef typename Superclass::InputPointType           InputPointType;

  typedef TFeatureImage                                 FeatureImageType;
  typedef typename Superclass::FeatureImagePointer      FeatureImagePointer;
  typedef typename Superclass::FeatureImageConstPointer FeatureImageConstPointer;
  typedef typename Superclass::FeaturePixelType         FeaturePixelType;
  typedef typename Superclass::FeatureRegionType        FeatureRegionType;
  typedef typename Superclass::FeatureSizeType          FeatureSizeType;
  typedef typename Superclass::FeatureSizeValueType     FeatureSizeValueType;
  typedef typename Superclass::FeatureSpacingType       FeatureSpacingType;
  typedef typename Superclass::FeatureIndexType         FeatureIndexType;
  typedef typename Superclass::FeaturePointType         FeaturePointType;

  typedef typename Superclass::ListPixelType            ListPixelType;
  typedef typename Superclass::ListImageType            ListImageType;
  typedef typename Superclass::ListImagePointer         ListImagePointer;
  typedef typename Superclass::ListImageConstPointer    ListImageConstPointer;
  typedef typename Superclass::ListRegionType           ListRegionType;
  typedef typename Superclass::ListSizeType             ListSizeType;
  typedef typename Superclass::ListSizeValueType        ListSizeValueType;
  typedef typename Superclass::ListSpacingType          ListSpacingType;
  typedef typename Superclass::ListIndexType            ListIndexType;
  typedef typename Superclass::ListIndexValueType       ListIndexValueType;
  typedef typename Superclass::ListPointType            ListPointType;
  typedef typename Superclass::ListIteratorType         ListIteratorType;

  typedef typename Superclass::CentroidVectorType       CentroidVectorType;
  typedef typename Superclass::SampleType               SampleType;
  typedef typename Superclass::TreeGeneratorType        TreeGeneratorType;
  typedef typename Superclass::TreePointer              TreePointer;
  typedef typename Superclass::TreeType                 TreeType;
  typedef typename Superclass::KdTreePointer            KdTreePointer;

  typedef TSingleData                                             LevelSetDataType;
  typedef typename Superclass::LevelSetDataPointer                LevelSetDataPointer;
  typedef typename Superclass::LevelSetDataPointerVector          LevelSetDataPointerVector;
  typedef typename Superclass::LevelSetDataPointerVectorIterator  LevelSetDataPointerVectorIterator;

  void PopulateListImage()
    {
    ListSpacingType spacing = this->m_NearestNeighborListImage->GetSpacing();

    ListRegionType region = this->m_NearestNeighborListImage->GetLargestPossibleRegion();

    ListIteratorType lIt( this->m_NearestNeighborListImage, region );

    if ( this->m_KdTree.IsNotNull() )
      {
      for(lIt.GoToBegin(); !lIt.IsAtEnd(); ++lIt )
        {
        ListIndexType ind = lIt.GetIndex();

        float queryPoint[ImageDimension];
        for( unsigned int i = 0; i < ImageDimension; i++ )
          {
          queryPoint[i] = ind[i]*spacing[i];
          }

        typename TreeType::InstanceIdentifierVectorType neighbors;
        this->m_KdTree->Search( queryPoint, this->m_NumberOfNeighbors, neighbors );

        ListPixelType L;
        for( unsigned int i = 0; i < this->m_NumberOfNeighbors; i++ )
          {
          if( this->m_LevelSetDataPointerVector[i]->VerifyInsideRegion( ind ) )
            {
            L.push_back( neighbors[i] );
            }
          }
        lIt.Set( L );
        }
      }
    else
      {
      for(lIt.GoToBegin(); !lIt.IsAtEnd(); ++lIt )
        {
        ListIndexType ind = lIt.GetIndex();
        ListPixelType L;
        for( unsigned int i = 0; i < this->m_FunctionCount; i++ )
          {
          if( this->m_LevelSetDataPointerVector[i]->VerifyInsideRegion( ind ) )
            {
            L.push_back( i );
            }
          }
        lIt.Set( L );
        }
      }
    }

protected:
  ConstrainedRegionBasedLevelSetFunctionSharedData() : Superclass( ){}
  ~ConstrainedRegionBasedLevelSetFunctionSharedData(){}

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

} //end namespace itk

#endif