itkDeformableSimplexMesh3DFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkDeformableSimplexMesh3DFilter.h,v $
  Language:  C++
  Date:      $Date: 2008-12-08 16:00:52 $
  Version:   $Revision: 1.15 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 __itkDeformableSimplexMesh3DFilter_h
#define __itkDeformableSimplexMesh3DFilter_h

#include "itkMeshToMeshFilter.h"
#include "itkSimplexMesh.h"
#include "itkSimplexMeshGeometry.h"
#include "itkImage.h"
#include "itkCovariantVector.h"
#include "itkVector.h"
#include "itkSphereSpatialFunction.h"
#include "itkFloodFilledSpatialFunctionConditionalIterator.h"
#include "itkVectorGradientMagnitudeImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkArray.h"

#include <set>

namespace itk
{

template <class TInputMesh, class TOutputMesh>
class DeformableSimplexMesh3DFilter : public MeshToMeshFilter<TInputMesh, TOutputMesh>
{
public:
  typedef DeformableSimplexMesh3DFilter  Self;

  typedef MeshToMeshFilter<TInputMesh, TOutputMesh> Superclass;

  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(DeformableSimplexMesh3DFilter,MeshToMeshFilter);

  typedef TInputMesh  InputMeshType;
  typedef TOutputMesh OutputMeshType;

  typedef typename InputMeshType::PointsContainerPointer     InputPointsContainerPointer;
  typedef typename InputMeshType::PointsContainer            InputPointsContainer;
  typedef typename InputMeshType::PointsContainer::Iterator  InputPointsContainerIterator;

  typedef typename SimplexMeshGeometry::PointType     PointType;
  typedef typename PointType::VectorType              VectorType;
  typedef CovariantVector< 
    typename VectorType::ValueType, 3 >               CovariantVectorType;
  typedef typename InputMeshType::PixelType           PixelType;

  typedef CovariantVector<PixelType, 3>                   GradientType;
  typedef Image<GradientType, 3>                          GradientImageType;
  typedef Image<unsigned char, 3>                         BinaryOutput;
  typedef Image<float, 3>                                 MagnitudeOutput;

  typedef typename GradientImageType::Pointer             GradientImagePointer;
  typedef typename GradientImageType::IndexType           GradientIndexType;
  typedef typename GradientImageType::PixelType           GradientPixelType;
  typedef typename GradientIndexType::IndexValueType      GradientIndexValueType;
  typedef typename GradientImageType::SizeType            GradientImageSizeType;

  /* Mesh pointer definition. */
  typedef typename InputMeshType::Pointer     InputMeshPointer;
  typedef typename OutputMeshType::Pointer    OutputMeshPointer;

  typedef typename InputMeshType::PointType                     MeshPointType;
  typedef typename InputMeshType::CellsContainerPointer         CellsContainerPointer;
  typedef typename InputMeshType::CellsContainer::Iterator      CellsContainerIterator;
  typedef typename InputMeshType::NeighborListType              InputNeighbors;
  typedef typename InputMeshType::NeighborListType::iterator    InputNeighborsIterator;

  typedef itk::MapContainer<unsigned long, std::set<unsigned long> >
                                                VertexNeighborListType;
  typedef std::set<unsigned long>               NeighborSetType;
  typedef std::set<unsigned long>               IndexSetType;
  typedef typename NeighborSetType::iterator    NeighborSetIterator;
  typedef typename IndexSetType::iterator       IndexSetIterator;


  typedef typename InputMeshType::GeometryMapType   GeometryMapType;
  typedef typename GeometryMapType::Pointer         GeometryMapPointer;
  typedef typename GeometryMapType::Iterator        GeometryMapIterator;


  itkSetMacro(Gradient, GradientImagePointer);

  itkGetMacro(Gradient, GradientImagePointer);

  itkSetMacro(Iterations, int);
  itkGetMacro(Iterations, int);

  itkSetMacro(Alpha, double);

  itkGetMacro(Alpha, double);

  itkSetMacro(Beta, double);

  itkGetMacro(Beta, double);

  itkSetMacro(Gamma, double);

  itkGetMacro(Gamma, double);

  itkSetMacro(Damping, double);

  itkGetMacro(Damping, double);

  itkSetMacro(Rigidity, unsigned int);

  itkGetMacro(Rigidity, unsigned int);

  itkSetObjectMacro(Data, GeometryMapType );
  itkGetObjectMacro(Data, GeometryMapType );
     
  itkGetMacro(ImageWidth,int);
  itkGetMacro(ImageHeight,int);
  itkGetMacro(ImageDepth,int);

  itkGetMacro(Step, int);

protected:
  DeformableSimplexMesh3DFilter();
  ~DeformableSimplexMesh3DFilter();
  DeformableSimplexMesh3DFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void GenerateData();

  virtual void Initialize();

  virtual void ComputeGeometry();

  virtual void ComputeDisplacement();

  virtual void ComputeInternalForce(SimplexMeshGeometry* data);

  virtual void ComputeExternalForce(SimplexMeshGeometry* data);  

  virtual void ComputeOutput();

  virtual void UpdateReferenceMetrics();

  double L_Func(double r,double d, double phi);

  PointType ComputeBarycentricCoordinates(PointType p, SimplexMeshGeometry* data);

  double    m_Alpha;

  double    m_Beta;

  double    m_Gamma;
  double    m_Damping;

  unsigned int m_Rigidity;

  // definition of internal parameters
  int       m_Step;

  int       m_ImageWidth;

  int       m_ImageHeight;

  int       m_ImageDepth;

  int       m_Iterations;

  GeometryMapPointer m_Data;

  /* gradient image pointer */
  GradientImagePointer m_Gradient;

  
}; // end of class


} // end namespace itk

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

#endif //__itkDeformableSimplexMesh3DFilter_h