itkBalloonForce3DFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBalloonForce3DFilter.h,v $
  Language:  C++
  Date:      $Date: 2002/09/23 18:12:27 $
  Version:   $Revision: 1.20 $

  Copyright (c) 2002 Insight 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 __itkBalloonForce3DFilter_h
#define __itkBalloonForce3DFilter_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 BalloonForce3DFilter : public MeshToMeshFilter<TInputMesh, TOutputMesh>
{
public:

  typedef BalloonForce3DFilter  Self;

  typedef MeshToMeshFilter<TInputMesh, TOutputMesh> Superclass;

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

  itkNewMacro(Self);
  
  itkTypeMacro(BalloonForce3DFilter,MeshToMeshFilter);

  typedef TInputMesh InputMeshType;
  typedef TOutputMesh OutputMeshType;
  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 typename OutputMeshType::PointsContainerPointer
      OutputPointsContainerPointer;
  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 CellInterface<PixelType,CellTraits>       CellInterface;
  typedef TriangleCell<CellInterface>               TriCell;

  typedef CovariantVector<PixelType, 3>             GradientType;
  typedef Image<GradientType, 3>                    GradientImageType;
  typedef Image<unsigned short, 3>                  ImageType;
  typedef typename ImageType::Pointer               ImagePointer;
  typedef typename ImageType::IndexType             IndexType;
  typedef ImageRegionIterator<ImageType>            ImageIterator;
  typedef ImageRegionIterator<GradientImageType>    GradientIterator;
  typedef ImageType::SizeType PotentialSizeType;
  typedef typename GradientImageType::Pointer       GradientImagePointer;

  typedef Vector<float, 3>     FloatVector;
  typedef Vector<int, 3>       IntVector;

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

  void ComputeForce(); 
  void Initialize();   
  void SetStiffnessMatrix(); 
  void Advance();      
  void ComputeDt();    
  void ComputeOutput(); 
  void NodeAddition();  
  void NodesRearrange();  
  void GradientFit(); 
  void ComputeNormals();  
  void ACDSearch();   
  void ComputeShrinkForce();  
  void InitialFit();          
  itkSetMacro(ImageOutput, ImagePointer);
  itkGetMacro(ImageOutput, ImagePointer);

  itkSetMacro(Potential, ImagePointer);
  itkGetMacro(Potential, ImagePointer);

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

  itkSetMacro(FirstSlice, int);
  itkGetMacro(FirstSlice, int);

  itkSetMacro(NeighborRadius, int);

  itkSetMacro(StepThreshold1, int);
  itkSetMacro(StepThreshold2, int);

  itkSetMacro(XResolution, int);
  itkSetMacro(YResolution, int);
  itkSetMacro(ZResolution, int);

  itkSetMacro(StiffnessV, double);
  itkSetMacro(StiffnessH, double);

  itkSetMacro(TimeStep, double);

  itkSetMacro(Center, IndexType);

  itkGetMacro(Normals, InputMeshPointer);

protected:
  BalloonForce3DFilter();
  ~BalloonForce3DFilter() {}
  BalloonForce3DFilter(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;
  InputMeshPointer  m_Input;
  OutputMeshPointer m_Output;

  vnl_matrix_fixed<double, 4, 4> NStiffness;
  vnl_matrix_fixed<double, 4, 4> SStiffness;
  vnl_matrix_fixed<double, 4, 4> CStiffness;
  vnl_matrix_fixed<double, 4, 4> **K;
  
  double    m_StiffnessV, m_StiffnessH;
  double    m_TimeStep;      
  int       m_XResolution, m_YResolution, m_ZResolution; 
  IndexType m_Center;        
  double    m_MiniT;         
  int       m_Step;          
  int       m_NumNodes;      
  int       m_NumCells;      
  int       m_NumNewNodes;   
  int       *m_GapLocations;
  int       m_ImageWidth;      
  int       m_ImageHeight;
  int       m_ImageDepth;
  int       m_ModelXUpLimit; 
  int       m_ModelXDownLimit;
  int       m_ModelYUpLimit;
  int       m_ModelYDownLimit;
  int       m_NewNode;       
  int       **m_ACD;         
  int       m_StepThreshold1;
  int       m_StepThreshold2;
  int       m_FirstSlice;    
  int       m_NeighborRadius;
  unsigned short        m_ObjectLabel; 
  ImagePointer          m_Potential;
  GradientImagePointer  m_Gradient; 
  ImagePointer          m_ImageOutput; 
  
};

} // end namespace itk

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

#endif

---