C:/cmcintos/defOrgs/source/physical/Phys_LevelSet.h

#include "stdafx.h"

#if defined (_MSC_VER) && (_MSC_VER >= 1000)
#pragma once
#endif

#ifndef _PHYS_LEVEL_SET_H
#define _PHYS_LEVEL_SET_H

#include "Physics.h"
#include "Geom_MeshSpatialObject.h"
#include "Geometric.h"
#include <vnl/vnl_matrix.h>
#include "itkImage.h"
#include "itkRescaleIntensityImageFilter.h"

#include "itkGeodesicActiveContourLevelSetImageFilter.h"
#include "itkCurvatureAnisotropicDiffusionImageFilter.h"
#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
#include "itkSigmoidImageFilter.h"
#include "itkFastMarchingImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkCastImageFilter.h"
#include "itkBinaryMask3DMeshSource.h"
#include "itkSpatialObjectToImageFilter.h"
#include "itkSignedDanielssonDistanceMapImageFilter.h"
#include "LevelSetDeformation.h"

#define DEBUG 0

namespace mial
{

        template<class DataType, class InputImageType, int nDims,class MType = vnl_matrix<DataType>, class VType = vnl_vector<DataType> >
        class Phys_LevelSet 
                : public Physics< DataType, nDims, MType, VType >
        {
        public:
                typedef Phys_LevelSet Self;
                typedef itk::SmartPointer<Self>  Pointer;
                typedef itk::SmartPointer<const Self>  ConstPointer;
                typedef itk::WeakPointer<const Self>  ConstWeakPointer;
                itkNewMacro(Self);

                typedef typename Physics<DataType,nDims,MType,VType>::Error Error;
                typedef typename itk::Image< DataType, nDims >                                          InternalImageType;
                typedef typename Geometric< DataType, nDims >::BinaryImageType          BinaryImageType;

        private:
                typename InputImageType::ConstPointer                   inputImg;
                typename InternalImageType::Pointer                     distanceImg;
                typename InternalImageType::Pointer                     edgePotentialImg;
                double propagationScaling;
                double curvatureScaling;
                double advectionScaling;
                double maximumRMSError;
                double numIterations;

                typename BinaryImageType::Pointer                       outputImg;

        public:
                

                typedef LevelSetDeformation<DataType,nDims,InternalImageType> DeformationType;
                virtual void initializeDistanceImg(); 
                virtual void initializeEdgePotentialImg();

                // functions which are pure virtual in the Physics ABC:
                virtual bool simulate();
                virtual bool runDeformation(const std::string defName,typename DeformationType::deformationIn* const i,std::stringstream * const s = NULL);
                virtual void setExternalForces( void * );
                //--------------------


                virtual void setInput( typename InputImageType::ConstPointer img ){ inputImg = img; }   // inline
                
                virtual void    setPropagationScaling(  const double ps ) { propagationScaling = ps; }  // inline
                virtual void    setCurvatureScaling(    const double cs ) { curvatureScaling = cs; }    // inline
                virtual void    setAdvectionScaling(    const double as ) { advectionScaling = as; }    // inline
                virtual void    setMaximumRMSError(             const double me ) { maximumRMSError = me; }             // inline
                virtual void    setNumIterations(               const double ni ) { numIterations = ni; }               // inline
                virtual double  getPropagationScaling() {       return this->propagationScaling; }                      // inline
                virtual double  getCurvatureScaling() {         return this->curvatureScaling; }                        // inline
                virtual double  getAdvectionScaling() {         return this->advectionScaling; }                        // inline
                virtual double  getMaximumRMSError() {          return this->maximumRMSError; }                         // inline
                virtual double  getNumIterations() {            return this->numIterations; }                           // inline

                // DEBUG TEMP FUNCTIONS:
                void printInternalValues();
                typename InternalImageType::Pointer getDistanceImage() { return this->distanceImg; }                    // DEBUG inline
                typename InternalImageType::Pointer getEdgePotentialImage() { return this->edgePotentialImg; }  // DEBUG inline
                typename BinaryImageType::Pointer getOutputImage() { return this->outputImg; }                                  // DEBUG inline

        protected:
                Phys_LevelSet(); // constructor
        };

} // end namespace mial

#include "Phys_LevelSet.cxx"
#endif // _PHYS_LEVEL_SET_H include

---