itkDeformableMesh3DFilter.h

Go to the documentation of this file.

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

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

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

#include "itkMeshToMeshFilter.h"
#include "vnl/vnl_matrix_fixed.h"
#include "vnl/vnl_math.h"
#include "itkMesh.h"
#include "itkVector.h"
#include "itkTriangleCell.h"
#include "itkImage.h"
#include "itkImageRegionIterator.h"
#include <itkCovariantVector.h>

namespace itk
{

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

  typedef MeshToMeshFilter<TInputMesh, TOutputMesh> Superclass;

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

  itkNewMacro(Self);

  itkTypeMacro(DeformableMesh3DFilter,MeshToMeshFilter);

  typedef TInputMesh                          InputMeshType;
  typedef typename InputMeshType::PointsContainerPointer
                                              InputPointsContainerPointer;
  typedef typename InputMeshType::PointsContainer::Iterator
                                              InputPointsContainerIterator;
  typedef typename InputMeshType::PointDataContainerPointer
                                              InputPointDataContainerPointer;
  typedef typename InputMeshType::PointDataContainer::Iterator
                                              InputPointDataContainerIterator;
  typedef typename InputMeshType::CellsContainerPointer
                                              InputCellsContainerPointer;
  typedef typename InputMeshType::CellsContainer::Iterator
                                              InputCellsContainerIterator;
  typedef typename InputMeshType::CellDataContainerPointer
                                              InputCellDataContainerPointer;
  typedef typename InputMeshType::CellDataContainer::Iterator
                                              InputCellDataContainerIterator;

  typedef TOutputMesh                         OutputMeshType;
  typedef typename OutputMeshType::PointsContainerPointer
                                              OutputPointsContainerPointer;
  typedef typename OutputMeshType::CellsContainer
                                              OutputCellsContainer;
  typedef typename OutputMeshType::CellsContainerPointer
                                              OutputCellsContainerPointer;
  typedef typename OutputMeshType::PointsContainer::Iterator
                                              OutputPointsContainerIterator;

  typedef typename InputMeshType::CellType          CellType;
  typedef typename InputMeshType::CellTraits        CellTraits;
  typedef typename InputMeshType::PointType         InputPointType;
  typedef typename InputMeshType::PixelType         PixelType;

  typedef Image<unsigned char, 3>                      PotentialImageType;
  typedef ImageRegionIterator<PotentialImageType>      PotentialIterator;
  typedef CovariantVector<PixelType, 3>                GradientType;
  typedef Image<GradientType, 3>                       GradientImageType;
  typedef ImageRegionIterator<GradientImageType>       GradientIterator;
  typedef typename GradientImageType::SizeType         ImageSizeType;
  typedef typename GradientImageType::IndexType        ImageIndexType;

  typedef itk::CellInterface<PixelType, CellTraits>    TCellInterface;
  typedef itk::TriangleCell<TCellInterface>            TriCell;

  typedef CovariantVector<int, 3>                      int3DVector;
  typedef CovariantVector<double, 2>                   double2DVector;
  typedef CovariantVector<double, 3>                   double3DVector;

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

  /* Stiffness Matrix Type definition */
  typedef vnl_matrix_fixed<double, 4, 4>  StiffnessMatrixType;
  typedef StiffnessMatrixType *           StiffnessMatrixRawPointer; 

  void SetStiffnessMatrix( StiffnessMatrixType *stiff, int i );

  itkSetMacro(Gradient, GradientImagePointer);
  itkGetMacro(Gradient, GradientImagePointer);

  itkSetMacro(StepThreshold, int);
  itkGetMacro(StepThreshold, int);

  itkSetMacro(Stiffness, double2DVector);
  itkGetMacro(Stiffness, double2DVector);

  itkSetMacro(TimeStep, double);
  itkGetMacro(TimeStep, double);

  itkSetMacro(Scale, double3DVector);

  itkSetMacro(PotentialMagnitude, PixelType);
  itkSetMacro(GradientMagnitude, PixelType);
  itkSetMacro(PotentialOn, unsigned short);
  itkSetMacro(ObjectLabel, unsigned char);

  itkGetMacro(Normals, InputMeshPointer);

protected:
  DeformableMesh3DFilter();
  ~DeformableMesh3DFilter();
  DeformableMesh3DFilter(const Self&) {}
  void operator=(const Self&) {}
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void GenerateData();

private:
  InputMeshPointer  m_Forces; 
  InputMeshPointer  m_Normals;
  InputMeshPointer  m_Displacements;
  InputMeshPointer  m_Derives;
  InputMeshPointer  m_Locations;

  void Initialize();
  void SetDefaultStiffnessMatrix();
  void SetMeshStiffness();
  void Advance();     // update data for next iteration
  void ComputeDt();   // compute point positions
  void ComputeOutput();
  void GradientFit(); // fit the model with gradient information
  void ComputeNormals();
  void PotentialFit();

  StiffnessMatrixType         m_StiffnessMatrix[10];
  StiffnessMatrixRawPointer  *m_K;

  double2DVector    m_Stiffness;

  double3DVector    m_Scale;

  int       m_NumberOfNodes;
  int       m_NumberOfCells;

  int       m_ImageHeight;
  int       m_ImageDepth;

  unsigned short m_ModelXUpLimit;
  unsigned short m_ModelXDownLimit;
  unsigned short m_ModelYUpLimit;
  unsigned short m_ModelYDownLimit;
  unsigned short m_ModelZUpLimit;
  unsigned short m_ModelZDownLimit;
  unsigned short m_PotentialOn;
  unsigned char  m_ObjectLabel;
  PixelType      m_GradientMagnitude;
  PixelType      m_PotentialMagnitude;

  GradientImagePointer        m_Gradient; 
  PotentialImageType::Pointer m_Potential;  
};

} // end namespace itk

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

#endif