itkDeformableSimplexMesh3DFilter.h

Go to the documentation of this file.

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

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: itkDeformableSimplexMesh3DFilter.h,v $
Language:  C++
Date:      $Date: 2005/05/05 21:23:12 $
Version:   $Revision: 1.12 $

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 __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 InputMeshType::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;


    //typedef Image<PixelType, 3>                                   GradientIntensityImageType;
    //typedef typename GradientIntensityImageType::Pointer          GradientIntensityImagePointer;

    //typedef typename itk::MapContainer<unsigned long, PointType> ForceOriginMapType;
    //typedef typename itk::MapContainer<unsigned long, VectorType> ForceMapType;

    /* 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

---