This the most basic of all PSM model optimization filters. This filter assembles all of the necessary components to perform an entropy-based correspondence optimization for constructing a point-based shape model of shape surfaces. More...

#include <itkPSMEntropyModelFilter.h>

Inheritance diagram for itk::PSMEntropyModelFilter< TImage, TShapeMatrix >:

Collaboration diagram for itk::PSMEntropyModelFilter< TImage, TShapeMatrix >:

Classes
struct	CuttingPlaneType

Public Types
typedef PSMEntropyModelFilter	Self

typedef InPlaceImageFilter< TImage, TImage >	Superclass

typedef SmartPointer< Self >	Pointer

typedef SmartPointer< const Self >	ConstPointer

typedef PSMParticleSystem< Dimension >	ParticleSystemType

typedef TShapeMatrix	ShapeMatrixType

typedef ShapeMatrixType::Pointer	ShapeMatrixPointerType

typedef TImage	ImageType

typedef ImageType::PointType	PointType

typedef PSMGradientDescentOptimizer< typename ImageType::PixelType, Dimension >	OptimizerType

Public Member Functions
	itkStaticConstMacro (Dimension, unsigned int, TImage::ImageDimension)

	itkNewMacro (Self)

	itkTypeMacro (PSMEntropyModelFilter, InPlaceImageFilter)

void	SetInput (const std::string &s, itk::DataObject *o)

void	SetInput (const TImage *image)

void	SetInput (unsigned int index, const TImage *image)

void	SetNumberOfScales (unsigned int n)

	itkGetMacro (NumberOfScales, unsigned int)

	itkSetMacro (CurrentScale, unsigned int)

	itkGetMacro (CurrentScale, unsigned int)

void	SetInputCorrespondencePoints (unsigned int index, const std::vector< PointType > &corr)

	itkGetObjectMacro (ParticleSystem, ParticleSystemType)

	itkGetConstObjectMacro (ParticleSystem, ParticleSystemType)

PSMParticleEntropyFunction< typename ImageType::PixelType, Dimension > *	GetParticleEntropyFunction ()

PSMShapeEntropyFunction< Dimension > *	ShapeEntropyFunction ()

	itkGetObjectMacro (Optimizer, OptimizerType)

	itkGetConstObjectMacro (Optimizer, OptimizerType)

void	SetMaximumNumberOfIterations (const std::vector< unsigned int > &n)

void	SetMaximumNumberOfIterations (unsigned int n, unsigned int i=0)

unsigned int	GetMaximumNumberOfIterations (unsigned int i=0) const

unsigned int	GetNumberOfElapsedIterations () const

	itkGetMacro (Initialized, bool)

	itkGetMacro (Initializing, bool)

	itkSetMacro (Initializing, bool)

void	SetShapeEntropyWeighting (double w)

double	GetShapeEntropyWeighting () const

const std::vector< double > &	GetShapePCAVariances () const

void	SetRegularizationInitial (const std::vector< double > &v)

void	SetRegularizationInitial (double t, unsigned int i=0)

double	GetRegularizationInitial (unsigned int i=0) const

void	SetRegularizationFinal (const std::vector< double > &v)

void	SetRegularizationFinal (double t, unsigned int i=0)

double	GetRegularizationFinal (unsigned int i=0) const

void	SetRegularizationDecaySpan (const std::vector< double > &v)

void	SetRegularizationDecaySpan (double t, unsigned int i=0)

double	GetRegularizationDecaySpan (unsigned int i=0) const

void	SetRegularizationConstant (double r)

void	SetMinimumVariance (double r)

double	GetRegularizationConstant () const

double	GetMinimumVariance () const

void	SetTolerance (const std::vector< double > &v)

void	SetTolerance (double t, unsigned int i=0)

double	GetTolerance (unsigned int i=0) const

	itkGetMacro (ShapeMatrix, ShapeMatrixPointerType)

const ShapeMatrixType *	GetShapeMatrix () const

bool	CreateSingleCorrespondence ()

void	SetDomainName (const std::string &s, unsigned int i)

unsigned int	GetDomainIndexByName (const std::string &name)

void	AddCuttingPlane (const vnl_vector_fixed< double, 3 > &x, const vnl_vector_fixed< double, 3 > &y, const vnl_vector_fixed< double, 3 > &z, unsigned int domain)

void	AddCuttingPlane (const vnl_vector_fixed< double, 3 > &x, const vnl_vector_fixed< double, 3 > &y, const vnl_vector_fixed< double, 3 > &z, const std::string &s)

Protected Member Functions
void	PrintSelf (std::ostream &os, Indent indent) const

void	GenerateData ()

virtual void	AllocateDataCaches ()

virtual void	AllocateWorkingImages ()

virtual void	AllocateDomainsAndNeighborhoods ()

void	InitializeCorrespondences ()

	itkSetMacro (Initialized, bool)

void	OptimizerIterateCallback (Object *, const EventObject &)

PSMImplicitSurfaceDomain< typename ImageType::PixelType, Dimension >::Pointer &	GetDomainByName (const std::string &name)

PSMImplicitSurfaceDomain< typename ImageType::PixelType, Dimension >::Pointer &	GetDomain (unsigned int i)

Detailed Description

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>
class itk::PSMEntropyModelFilter< TImage, TShapeMatrix >

This the most basic of all PSM model optimization filters. This filter assembles all of the necessary components to perform an entropy-based correspondence optimization for constructing a point-based shape model of shape surfaces.

This class combines a PSMShapeEntropyFunction with a PSMParticleEntropyFunction within a PSMTwoCostFunction to produce an optimization of particle positions with respect to both their positional entropy on shape surfaces and their entropy within a higher-dimensional shape space (the entropy of the distributions of shapes). The relative weighting of these two terms may be adjusted using the SetShapeEntropyWeighting method, which increases or decreases the influence of the entropy of the shape model on the optimization. The default value for ShapeEntropyWeighting is 1.0.

NEED CITATION HERE

HOW DO YOU USE THIS FILTER? First you need to specify the input images. Input images are in the form of distance transforms that contain an implicit surface representation at the zero level set within the image. The zero level set is the surface on which the particles are constrained during the optimization. You will specify multiple input images, one for each shape in your shape cohort. To specify the inputs, use the method SetInput(i,image *), where i is the number of the input and image * is an itk::Image::Pointer to the distance transform image.

This filter can be run in "initialization mode", which causes all data structures to allocate and initialize, but does not run the actual optimization. To run in initialization mode, set the Initializing flag to true.

Author: Josh Cates

Definition at line 78 of file itkPSMEntropyModelFilter.h.

Member Typedef Documentation

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef TImage itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::ImageType

Type of the input/output image.

Definition at line 105 of file itkPSMEntropyModelFilter.h.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef PSMGradientDescentOptimizer<typename ImageType::PixelType, Dimension> itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::OptimizerType

Type of the optimizer

Definition at line 111 of file itkPSMEntropyModelFilter.h.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef PSMParticleSystem<Dimension> itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::ParticleSystemType

Type of the particle system

Definition at line 92 of file itkPSMEntropyModelFilter.h.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef ImageType::PointType itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::PointType

Expose the point type

Definition at line 108 of file itkPSMEntropyModelFilter.h.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef PSMEntropyModelFilter itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::Self

Standard class typedefs.

Definition at line 83 of file itkPSMEntropyModelFilter.h.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

typedef TShapeMatrix itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::ShapeMatrixType

The type of the Shape Matrix, which defines optimization behavior.

Definition at line 95 of file itkPSMEntropyModelFilter.h.

Member Function Documentation

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::AddCuttingPlane	(	const vnl_vector_fixed< double, 3 > &	x,
		const vnl_vector_fixed< double, 3 > &	y,
		const vnl_vector_fixed< double, 3 > &	z,
		unsigned int	domain
	)

Adds cutting plane information for given domain i. Currently, only one cutting plane per domain is supported.

Definition at line 136 of file itkPSMEntropyModelFilter.hxx.

 {
   if (m_CuttingPlanes.size() < domain+1)
     {
       m_CuttingPlanes.resize(domain+1);
     }
   CuttingPlaneType p;
   p.x = x;
   p.y = y;
   p.z = z;
   p.valid = true;
   m_CuttingPlanes[domain] = p;
 }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::AllocateDataCaches ( )

protectedvirtual

This method sets up temporary data structures needed for the optimization. It is called during the first run of GenerateData.

Definition at line 80 of file itkPSMEntropyModelFilter.hxx.

 {
   // Set up the various data caches that the optimization functions will use.
   // Sigma cache is caching a parameter for the local particle entropy
   // computation that is updated for each particle.
   m_SigmaCache = PSMContainerArrayAttribute<double, Dimension>::New();
   m_ParticleSystem->RegisterAttribute(m_SigmaCache);
   m_ParticleEntropyFunction->SetSpatialSigmaCache(m_SigmaCache);
   
   // m_MeanCurvatureCache = PSMMeanCurvatureAttribute<typename ImageType::PixelType, Dimension>::New();
   // m_ParticleSystem->RegisterAttribute(m_MeanCurvatureCache);
 }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::AllocateDomainsAndNeighborhoods ( )

protectedvirtual

This method allocates data structures necessary to keep track of image domains and image neighborhoods. It is called during the first run of GenerateData.

Definition at line 107 of file itkPSMEntropyModelFilter.hxx.

 {
   // Allocate all the necessary domains and neighborhoods. This must be done
   // *after* registering the attributes to the particle system since some of
   // them respond to AddDomain.
   for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
     { 
     m_DomainList.push_back( PSMImplicitSurfaceDomain<typename
                             ImageType::PixelType, Dimension>::New() );
     m_NeighborhoodList.push_back( PSMSurfaceNeighborhood<ImageType>::New() );
     m_DomainList[i]->SetSigma(m_WorkingImages[i]->GetSpacing()[0] * 2.0);    
     m_DomainList[i]->SetImage(m_WorkingImages[i]);
 
     if (m_CuttingPlanes.size() > i)
       {        
      m_DomainList[i]->SetCuttingPlane(m_CuttingPlanes[i].x,
                           m_CuttingPlanes[i].y,
                           m_CuttingPlanes[i].z);
       }
         
     m_ParticleSystem->AddDomain(m_DomainList[i]);
     m_ParticleSystem->SetNeighborhood(i, m_NeighborhoodList[i]);
     }
 }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::AllocateWorkingImages ( )

protectedvirtual

This method allocates working images needed during the optimization. It is called during the first run of GenerateData.

Definition at line 95 of file itkPSMEntropyModelFilter.hxx.

 {
   m_WorkingImages.resize(this->GetNumberOfInputs());
   for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
      {
      m_WorkingImages[i] = const_cast<TImage *>(this->GetInput(i));
      }
 }

template<class TImage , class TShapeMatrix >

bool itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::CreateSingleCorrespondence ( )

Creates a single correspondence point to each domain that is placed at the surface position closest to the upper-left-hand corner of each of the input images.

Definition at line 347 of file itkPSMEntropyModelFilter.hxx.

 {
   bool ok = true;
   for (unsigned int i = 0; i < m_ParticleSystem->GetNumberOfDomains(); i++)
     {
       typename itk::ZeroCrossingImageFilter<ImageType, ImageType>::Pointer zc =
         itk::ZeroCrossingImageFilter<ImageType, ImageType>::New();
 
       zc->SetInput( dynamic_cast<PSMImplicitSurfaceDomain<typename ImageType::PixelType, Dimension> *>(
                                                  m_ParticleSystem->GetDomain(i))->GetImage());
       zc->Update();
       itk::ImageRegionConstIteratorWithIndex<ImageType> it(zc->GetOutput(), 
                                                            zc->GetOutput()->GetRequestedRegion());
 
       bool done = false;
       for (it.GoToReverseBegin(); !it.IsAtReverseEnd() && done == false; --it)
         {
           if (it.Get() == 1.0)
             {
               PointType pos;
               dynamic_cast<PSMImplicitSurfaceDomain<typename ImageType::PixelType, Dimension> *>(
                          m_ParticleSystem->GetDomain(i))->GetImage()->TransformIndexToPhysicalPoint(it.GetIndex(), pos);
               try
                 {
                   m_ParticleSystem->AddPosition(pos, i);
                   done = true;
                 }
               catch(itk::ExceptionObject &)
                 {
                   done = false;
                   ok = false;
                 }
             }
         }
     }
   return ok;
 }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GenerateData ( )

protected

This method does the work of the optimization.

Definition at line 220 of file itkPSMEntropyModelFilter.hxx.

 {
   // First, undo the default InPlaceImageFilter functionality that will 
   // release our inputs.
   this->SetInPlace(false); 
 
   // If this is the first call to GenerateData, then we need to allocate some structures
   if (this->GetInitialized() == false)
     {
       this->AllocateWorkingImages();
       this->AllocateDataCaches();
       this->GetOptimizer()->SetCostFunction(m_CostFunction);
       
       this->AllocateDomainsAndNeighborhoods();
       
       // Point the optimizer to the particle system.
       this->GetOptimizer()->SetParticleSystem(this->GetParticleSystem());
       //      this->ReadTransforms();
       this->InitializeCorrespondences();
       this->InitializeOptimizationFunctions(); 
       
       this->SetInitialized(true);
     }
 
   // This filter can be run in "initialization mode", which causes all
   // data structures to allocate and initialize, but does not run the
   // actual optimization.
   if (this->GetInitializing() == true) return;
 
   // Multiscale optimization.  This can be stopped and restarted by
   // calling GenerateData again by maintaining m_CurrentScale.
   for (unsigned int scale = m_CurrentScale; scale < m_NumberOfScales; scale++)
     {
       m_CurrentScale = scale;
 
       // Set up the optimization parameters for this scale, unless
       // this is a restart from a previous call to GenerateData. This
       // section deals with convergence criteria.
       if (this->GetAbortGenerateData() == false)
         {
           // This section deals with convergence.
           m_Optimizer->SetTolerance(m_Tolerances[scale]);
           m_Optimizer->SetMaximumNumberOfIterations(m_MaximumNumberOfIterations[scale]);
           
           // Set up the exponentially-decreasing regularization constant.  If
           // the decay span is greater than 1 iteration, then we will set up
           // the annealing approach.  Otherwise, the optimizer will simply use
           // its constant annealing parameter.
           if (m_RegularizationDecaySpan[scale] >= 1.0f)
             {
               m_ShapeEntropyFunction->SetMinimumVarianceDecay(m_RegularizationInitial[scale], 
                                                               m_RegularizationFinal[scale], 
                                                               m_RegularizationDecaySpan[scale]);
             }
           else
             {
               m_ShapeEntropyFunction->SetMinimumVariance(m_RegularizationInitial[scale]);
               m_ShapeEntropyFunction->SetHoldMinimumVariance(true);
             }
         }
       
       this->SetAbortGenerateData(false); // reset the abort flag
 
       // Finally, run the optimization.  Abort flag is checked in the
       // iteration callback registered with the optimizer. See
       // this->OptimizerIterateCallback
       this->GetOptimizer()->StartOptimization();
 
 
       // If this is multiscale, split particles for the next iteration
       // -- but not if this is the last iteration.
       if ((m_NumberOfScales > 1) && (scale != m_NumberOfScales-1) )
         {
           m_ParticleSystem->SplitAllParticles(this->GetInput()->GetSpacing()[0] * 1.0);
         }
 
     }
 }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

PSMImplicitSurfaceDomain< typename ImageType::PixelType, Dimension>::Pointer& itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetDomain ( unsigned int i )

inlineprotected

Returns a pointer to the ith domain in the domain list.

Definition at line 613 of file itkPSMEntropyModelFilter.h.

    {
      if (i >= m_DomainList.size())
        { itkExceptionMacro("Requested domain not available"); }
      return m_DomainList[i];
    }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

PSMImplicitSurfaceDomain< typename ImageType::PixelType, Dimension>::Pointer& itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetDomainByName ( const std::string & name )

inlineprotected

Returns a pointer to the domain that is referenced by the given name

Definition at line 605 of file itkPSMEntropyModelFilter.h.

    {
      return this->GetDomain(this->GetDomainIndexByName(name));
    }

template<class TImage , class TShapeMatrix >

unsigned int itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetDomainIndexByName ( const std::string & name )

Returns the index associated with the given name. Throws an exception if the given name is not found in the domain name list.

Definition at line 168 of file itkPSMEntropyModelFilter.hxx.

 {
   // This is slow, but is not anticipated to be used very extensively.
   // Better to have simple code than overengineer something not
   // performance-critical.
 
   for (unsigned int i = 0; i < m_DomainListNames.size(); i++)
     {
       if (m_DomainListNames[i] == name)
      {
        return i;
      }      
     }
 
   itkExceptionMacro("The domain name " + name + " was not found. ");
   return 0; // algorithm will never reach this point  
 }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

unsigned int itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetNumberOfElapsedIterations ( ) const

inline

Return the number of elapsed iterations of the solver. Note that this number is reset to zero with each call to GenerateData.

Definition at line 274 of file itkPSMEntropyModelFilter.h.

   {
     return m_Optimizer->GetNumberOfIterations();
   }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

PSMParticleEntropyFunction<typename ImageType::PixelType, Dimension>* itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetParticleEntropyFunction ( )

inline

Returns a pointer to the ParticleEntropyFunction. This is the cost function that will maximize positional entropy of particle distributions on shape surfaces. This is the cost function term that ensures good shape representations.

Definition at line 220 of file itkPSMEntropyModelFilter.h.

   {
     return m_ParticleEntropyFunction;
   }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

const std::vector<double>& itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::GetShapePCAVariances ( ) const

inline

Returns a vector of the variances associated with the PCA decomposition of the shape space. There will be only number_of_samples - 1 total valid PCA modes. This method simply calls the method of the same name in PSMShapeEntropyFunction. It is included here for convenience.

Definition at line 342 of file itkPSMEntropyModelFilter.h.

    { 
      return m_ShapeEntropyFunction->GetShapePCAVariances(); 
    }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::InitializeCorrespondences ( )

protected

This method copies the correspondence point lists provided by SetInputCorrespondencePoints into the initialized particle system. It is called during the first run of GenerateData.

Definition at line 188 of file itkPSMEntropyModelFilter.hxx.

 {
   // If the user has specified correspondence points on the input,
   // then make sure the number of lists of correspondence points
   // matches the number of inputs (distance transforms).  Everything
   // should match this->GetNumberOfInputs().
   if (m_InputCorrespondencePoints.size() > 0)
     {
       if (this->GetNumberOfInputs() != m_InputCorrespondencePoints.size() ) 
         {
           itkExceptionMacro("The number of inputs does not match the number of correspondence point lists.");
         }
       else
         {
           for (unsigned int i = 0; i < m_InputCorrespondencePoints.size(); i++)
             {
               this->GetParticleSystem()->AddPositionList(m_InputCorrespondencePoints[i],i);
             }
         }
     }
   else // No input correspondences are specified, so add a point to each surface.
     {
       this->CreateSingleCorrespondence();
     }
   
   // Push position information out to all observers (necessary to
   // correctly fill out the shape matrix)
   this->GetParticleSystem()->SynchronizePositions();
 }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkGetMacro	(	Initialized	,
		bool
	)

The Initialized flag indicates whether GenerateData has previously been called and all the necessary temporary data structures have been allocated.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkGetMacro	(	Initializing	,
		bool
	)

Get/Set the Initializing flag. When set to true, this flag will prevent GenerateData from starting the optimization. When m_Initializing is true, GenerateData will allocated all data structures and set necessary parameters, but return before running the optimization.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkGetMacro	(	ShapeMatrix	,
		ShapeMatrixPointerType
	)

Returns shape matrix. Each column of the shape matrix is a different point-based representation of a shape in the cohort. There are several types of shape matrices, which may be defined differently for subclasses of the PSMEntropyModelFilter class.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkGetObjectMacro	(	ParticleSystem	,
		ParticleSystemType
	)

Returns the particle system used in the shape model computation.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkGetObjectMacro	(	Optimizer	,
		OptimizerType
	)

Return a pointer to the optimizer object.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkNewMacro ( Self )

Method for creation through the object factory.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkSetMacro	(	Initialized	,
		bool
	)

protected

The Initialized flag indicates whether GenerateData has previously been called and all the necessary temporary data structures have been allocated.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkStaticConstMacro	(	Dimension	,
		unsigned	int,
		TImage::ImageDimension
	)

Dimensionality of the domain of the particle system.

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::itkTypeMacro	(	PSMEntropyModelFilter< TImage, TShapeMatrix >	,
		InPlaceImageFilter
	)

Run-time type information (and related methods).

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::OptimizerIterateCallback	(	Object *	,
		const EventObject &
	)

protected

A callback method that will be called after each iteration of the Solver.

Definition at line 328 of file itkPSMEntropyModelFilter.hxx.

 {
   // Update any optimization values based on potential changes from
   // the user during the last iteration here.  This allows for changes in a
   // thread-safe manner.
   
   // Now invoke any iteration events registered with this filter.
   this->InvokeEvent(itk::IterationEvent());
 
   // Request to terminate this filter.
   if (this->GetAbortGenerateData() == true)
     {
       m_Optimizer->StopOptimization();
     }
 }

template<class TImage , class TShapeMatrix >

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetDomainName	(	const std::string &	s,
		unsigned int	i
	)

Sets the name of the ith domain. This functionality is only for convenience, but required if you want to lookup a domain index by its name.

Definition at line 156 of file itkPSMEntropyModelFilter.hxx.

 {
   if (m_DomainListNames.size() < (i+1))
     {
       m_DomainListNames.resize(i+1);
     }
   m_DomainListNames[i] = s;
 }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetInput	(	const std::string &	s,
		itk::DataObject *	o
	)

inline

Override parent classes to expand input list on new inputs. This filter requires multiple input images. Each input to this filter represents a shape sample. Note that there may be hundreds of inputs to this filter!

Definition at line 132 of file itkPSMEntropyModelFilter.h.

     {
       Superclass::SetInput(s,o);
     }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetInputCorrespondencePoints	(	unsigned int	index,
		const std::vector< PointType > &	corr
	)

inline

This is a placeholder for a more formalized implementation of a point-based shape model. Set the Nth list of correspondences for the input model. These are the initial correspondence point positions for the Nth input surface (see SetInput).

Definition at line 202 of file itkPSMEntropyModelFilter.h.

     {
       if (m_InputCorrespondencePoints.size() < (index+1))
         {
           m_InputCorrespondencePoints.resize(index+1);
         }
       m_InputCorrespondencePoints[index] = corr;
     }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetMaximumNumberOfIterations ( const std::vector< unsigned int > & n )

inline

Set / Get the maximum number of iterations that the solver is allowed to execute. If set to 0, this parameter is ignored and the solver will iterate until any other convergence criteria are met. A maximum number of iterations must be specified for each scale (second, optional parameter if NumberOfScales > 1).

Definition at line 243 of file itkPSMEntropyModelFilter.h.

     {
       m_MaximumNumberOfIterations = n;
     }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetNumberOfScales ( unsigned int n )

inline

The number of scales for the optimization. Starting with the input correspondence points for Scale 0, the algorithm will run a full optimization with the parameters given for that scale (RegularizationInitial, RegularizationFinal, etc.). After optimization at each scale, the particle system size will be doubled by splitting each particle and optimization will proceed at the next scale. If no correspondence points are supplied on the inputs, then the system at Scale 0 will be initialized with a single correspondence point, placed at the surface position closest to the upper-left-hand corner of each of the input images.

If NumberOfScales = 1, then the filter will simply optimize the positions of the input correspondence points. Note that you must supply parameters separately for each scale of the optimization.

Definition at line 166 of file itkPSMEntropyModelFilter.h.

     {
       m_NumberOfScales = n;
       if (m_Tolerances.size() < n)
         {
           m_Tolerances.resize(n);
         }
       if (m_MaximumNumberOfIterations.size() < n)
         {
           m_MaximumNumberOfIterations.resize(n);
         }
       if (m_RegularizationInitial.size() < n)
         {
           m_RegularizationInitial.resize(n);
         }
       if (m_RegularizationFinal.size() < n)
         {
           m_RegularizationFinal.resize(n);
         }
       if (m_RegularizationDecaySpan.size() < n)
         {
           m_RegularizationDecaySpan.resize(n);
         }
 
     }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetRegularizationConstant ( double r )

inline

Directly set the regularization. This bypasses all other methods, but will only be valid until the current scale is optimized.

Definition at line 461 of file itkPSMEntropyModelFilter.h.

    {
      m_ShapeEntropyFunction->SetMinimumVariance(r);
    }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetRegularizationInitial ( const std::vector< double > & v )

inline

A regularization constant is added to the diagonal elements of the covariance matrix of the particle positions in shape space during the optimization. It is called "minimum variance" in the PSMShapeEntropyFunction class because it enforces a minimum variance in each of the eigen-modes of the shape space during the optimization. Higher MinimumVariance produces larger gradients, thus allowing shapes to move larger distances in shape space during optimization of positions with this function. Higher MinimumVariance values minimize the effects of smaller modes of variation in the covariance matrix. Conversely, smaller MinimumVariance values increase the significance of the smaller modes of variation on the gradient calculation. The parameters RegularizationInitial, RegularizationFinal, and RegularizationDecaySpan define an "annealing" type optimization, where the minimum variance starts at RegularizationInitial and exponentially decreases over RegularizationDecaySpan to the RegularizationFinal value. If the RegularizationDecaySpan is set to 0, then only RegularizationConstant is used as the MinimumVariance parameter and is held fixed during the optimization.

Definition at line 367 of file itkPSMEntropyModelFilter.h.

      {
        if (v.size() != m_RegularizationInitial.size()) 
          {
            itkExceptionMacro("Number of variables does not match number of scales.  Call SetNumberOfScales first.");
          }
        m_RegularizationInitial = v;
      }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetShapeEntropyWeighting ( double w )

inline

This method sets/gets the relative weighting of terms in the two-term cost function used for the optimization. This parameter adjusts the weighting of the shape representation term with respect to the strength of the entropy minimization in shape space. Higher values will favor a more compact representation in shape space and produce less regular samplings of shape surfaces. Default value is an equal weighting between the two terms (1.0).

Definition at line 299 of file itkPSMEntropyModelFilter.h.

   {
     m_CostFunction->SetRelativeGradientScaling(w);
   }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

void itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::SetTolerance ( const std::vector< double > & v )

inline

Set the tolerance for the optimization, below which the optimization will be considered to have converged. Tolerance is specified as a distance in the implicit surface images. The solver will converge when no pixel has moved more than the specified tolerance in a given iteration. An optional argument specifies the scale to which you want this tolerance applied (see SetNumberOfScales). If NumberOfScales > 1, then you MUST supply a value for each scale.

Definition at line 486 of file itkPSMEntropyModelFilter.h.

      {
        if (v.size() != m_Tolerances.size()) 
          {
            itkExceptionMacro("Number of variables does not match number of scales.  Call SetNumberOfScales first.");
          }
        m_Tolerances = v;
      }

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>

PSMShapeEntropyFunction<Dimension>* itk::PSMEntropyModelFilter< TImage, TShapeMatrix >::ShapeEntropyFunction ( )

inline

Returns a pointer to the ShapeEntropyFunction. This is the cost function that will minimize the entropy of the shape vectors in high-dimensional shape space. This is the cost function term that establishes correspondence across shapes.

Definition at line 229 of file itkPSMEntropyModelFilter.h.

   {
     return m_ShapeEntropyFunction;
   }

The documentation for this class was generated from the following files:

C:/Users/Brig/Documents/ShapeWorksStudio/src/ParticleShapeworks/include/itkPSMEntropyModelFilter.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/ParticleShapeworks/include/itkPSMEntropyModelFilter.hxx

Classes

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>> class itk::PSMEntropyModelFilter< TImage, TShapeMatrix >

Member Typedef Documentation

Member Function Documentation

template<class TImage, class TShapeMatrix = PSMShapeMatrixAttribute<double, TImage::ImageDimension>>
class itk::PSMEntropyModelFilter< TImage, TShapeMatrix >