itkDeformableMesh3DFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkDeformableMesh3DFilter_h
#define __itkDeformableMesh3DFilter_h

#include "itkMeshToMeshFilter.h"
#include "vnl/vnl_matrix_fixed.h"
#include "vnl/vnl_math.h"
#include "itkMesh.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::PointsContainerConstPointer      InputPointsContainerConstPointer;
  typedef typename InputMeshType::PointsContainer::Iterator        InputPointsContainerIterator;
  typedef typename InputMeshType::PointsContainer::ConstIterator   InputPointsContainerConstIterator;
  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::CellsContainerConstPointer       InputCellsContainerConstPointer;
  typedef typename InputMeshType::CellsContainer::ConstIterator    InputCellsContainerConstIterator;
  typedef typename InputMeshType::CellDataContainerPointer         InputCellDataContainerPointer;
  typedef typename InputMeshType::CellDataContainer::Iterator      InputCellDataContainerIterator;
  typedef typename InputMeshType::CellDataContainerConstPointer    InputCellDataContainerConstPointer;
  typedef typename InputMeshType::CellDataContainer::ConstIterator InputCellDataContainerConstIterator;

  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 InputMeshType::ConstPointer InputMeshConstPointer;
  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);
  itkGetConstMacro(Gradient, GradientImagePointer);

  itkSetMacro(StepThreshold, int);
  itkGetConstMacro(StepThreshold, int);

  itkSetMacro(Stiffness, double2DVector);
  itkGetConstMacro(Stiffness, double2DVector);

  itkSetMacro(TimeStep, double);
  itkGetConstMacro(TimeStep, double);

  itkSetMacro(Scale, double3DVector);

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

  itkGetConstMacro(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.hxx"
#endif

#endif