itkBSplineScatteredDataPointSetToImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBSplineScatteredDataPointSetToImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2008-07-07 19:11:03 $
  Version:   $Revision: 1.2 $

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

#include "itkPointSetToImageFilter.h"
#include "itkCoxDeBoorBSplineKernelFunction.h"
#include "itkFixedArray.h"
#include "itkVariableSizeMatrix.h"
#include "itkVector.h"
#include "itkVectorContainer.h"

#include "vnl/vnl_matrix.h"

namespace itk
{

template <class TInputPointSet, class TOutputImage>
class BSplineScatteredDataPointSetToImageFilter
: public PointSetToImageFilter<TInputPointSet, TOutputImage>
{
public:
  typedef BSplineScatteredDataPointSetToImageFilter           Self;
  typedef PointSetToImageFilter<TInputPointSet, TOutputImage> Superclass;
  typedef SmartPointer<Self>                                  Pointer;
  typedef SmartPointer<const Self>                            ConstPointer;

  itkNewMacro(Self);

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

  typedef TOutputImage                                        ImageType;
  typedef TInputPointSet                                      PointSetType;

  typedef typename ImageType::PixelType                       PixelType;
  typedef typename ImageType::RegionType                      RegionType;
  typedef typename ImageType::SizeType                        SizeType;
  typedef typename ImageType::IndexType                       IndexType;
  typedef typename ImageType::PointType                       ContinuousIndexType;

  typedef typename PointSetType::PointType                    PointType;
  typedef typename PointSetType::PixelType                    PointDataType;
  typedef typename PointSetType::PointDataContainer           PointDataContainerType;

  typedef float                                               RealType;
  typedef VectorContainer<unsigned, RealType>                 WeightsContainerType;
  typedef Image<PointDataType,
    itkGetStaticConstMacro( ImageDimension )>                 PointDataImageType;
  typedef Image<RealType,
    itkGetStaticConstMacro( ImageDimension )>                 RealImageType;
  typedef FixedArray<unsigned,
    itkGetStaticConstMacro( ImageDimension )>                 ArrayType;
  typedef VariableSizeMatrix<RealType>                        GradientType;
  typedef RealImageType                                       HessianType;

  typedef CoxDeBoorBSplineKernelFunction<3>                            KernelType;

  void SetNumberOfLevels( unsigned int );
  void SetNumberOfLevels( ArrayType );
  itkGetConstReferenceMacro( NumberOfLevels, ArrayType );

  void SetSplineOrder( unsigned int );
  void SetSplineOrder( ArrayType );
  itkGetConstReferenceMacro( SplineOrder, ArrayType );

  itkSetMacro( NumberOfControlPoints, ArrayType );
  itkGetConstReferenceMacro( NumberOfControlPoints, ArrayType );
  itkGetConstReferenceMacro( CurrentNumberOfControlPoints, ArrayType );

  itkSetMacro( CloseDimension, ArrayType );
  itkGetConstReferenceMacro( CloseDimension, ArrayType );

  itkSetMacro( GenerateOutputImage, bool );
  itkGetConstReferenceMacro( GenerateOutputImage, bool );
  itkBooleanMacro( GenerateOutputImage );

  void SetPointWeights( const WeightsContainerType * weights );

  itkSetMacro( PhiLattice, typename PointDataImageType::Pointer );
  itkGetConstMacro( PhiLattice, typename PointDataImageType::Pointer );

  void EvaluateAtPoint( PointType, PointDataType & );
  void EvaluateAtIndex( IndexType, PointDataType & );
  void EvaluateAtContinuousIndex( ContinuousIndexType, PointDataType & );

  void Evaluate( PointType, PointDataType & );

  void EvaluateGradientAtPoint( PointType, GradientType & );
  void EvaluateGradientAtIndex( IndexType, GradientType & );
  void EvaluateGradientAtContinuousIndex( ContinuousIndexType, GradientType & );

  void EvaluateGradient( PointType, GradientType & );

protected:
  BSplineScatteredDataPointSetToImageFilter();
  virtual ~BSplineScatteredDataPointSetToImageFilter();
  void PrintSelf( std::ostream& os, Indent indent ) const;

  void GenerateData();

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

  void GenerateControlLattice();
  void RefineControlLattice();
  void UpdatePointSet();
  void GenerateOutputImage();
  void GenerateOutputImageFast();
  void CollapsePhiLattice( PointDataImageType *,
                           PointDataImageType *,
                           RealType, unsigned int );


  bool                                                        m_DoMultilevel;
  bool                                                        m_GenerateOutputImage;
  bool                                                        m_UsePointWeights;
  unsigned int                                                m_MaximumNumberOfLevels;
  unsigned int                                                m_CurrentLevel;
  ArrayType                                                   m_NumberOfControlPoints;
  ArrayType                                                   m_CurrentNumberOfControlPoints;
  ArrayType                                                   m_CloseDimension;
  ArrayType                                                   m_SplineOrder;
  ArrayType                                                   m_NumberOfLevels;
  typename WeightsContainerType::Pointer                      m_PointWeights;
  typename KernelType::Pointer                                m_Kernel[ImageDimension];
  vnl_matrix<RealType>                                        m_RefinedLatticeCoefficients[ImageDimension];
  typename PointDataImageType::Pointer                        m_PhiLattice;
  typename PointDataImageType::Pointer                        m_PsiLattice;
  typename PointDataContainerType::Pointer                    m_InputPointData;
  typename PointDataContainerType::Pointer                    m_OutputPointData;

  inline typename RealImageType::IndexType
  NumberToIndex( unsigned int number, typename RealImageType::SizeType size )
    {
    typename RealImageType::IndexType k;
    k[0] = 1;

    for ( unsigned int i = 1; i < ImageDimension; i++ )
      {
      k[i] = size[ImageDimension-i-1]*k[i-1];
      }
    typename RealImageType::IndexType index;
    for ( unsigned int i = 0; i < ImageDimension; i++ )
      {
      index[ImageDimension-i-1] = static_cast<unsigned int>( number/k[ImageDimension-i-1] );
      number %= k[ImageDimension-i-1];
      }
    return index;
    }
};

} // end namespace itk

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

#endif

---