C:/cmcintos/defOrgs/examples/DefOrgViewerWithKW/Source/DefOrgViewerAdapter.h

#ifndef __DefOrgViewerAdapter_h
#define __DefOrgViewerAdapter_h

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkMeanImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkCovariantVector.h"

#include "vtkUnstructuredGrid.h"
#include "vtkCellArray.h"
#include "vtkProperty.h"

#include <iostream>
#include "itkOrganism.h"
#include "Phys_Euler.h"
#include "Ctrl_ScheduleDriven.h"
#include "Beh_TranslateAll.h"
#include "Def_Translation.h"
#include "Sense_Gradient.h"
#include "Geom_MeshSpatialObject.h"
#include "Phys_LevelSet.h"

#include "itkImage.h"
#include "itkImageFileReader.h"
#include "vtkImageImport.h"
#include "itkVTKImageExport.h"
#include "DefOrgViewerAdapter.h"

#include <vtksys/SystemTools.hxx>
#include <vtksys/CommandLineArguments.hxx>


#define N_DIMS 3
typedef unsigned char                                                                   PixelType;
typedef itk::Image< PixelType, N_DIMS >                                 ImageType;
typedef itk::ImageFileReader< ImageType >                               ImageFileReader;
typedef ImageFileReader::Pointer                                                ImageFileReaderPointer;
typedef  itk::VTKImageExport< ImageType >                               itkImageExportType;
typedef itkImageExportType::Pointer                                             itkImageExportTypePointer;
typedef itk::SceneSpatialObject<N_DIMS>::Pointer                itkScenePointer;

#define SetStringMacro(name) \
  virtual void Set##name (const char* _arg) \
  { \
    if ( _arg && (_arg == this->m_##name) ) { return;} \
    if (_arg) \
      { \
      this->m_##name = _arg;\
      } \
     else \
      { \
      this->m_##name = ""; \
      } \
  } 

class VistVTKCellsClass;

class DefOrgViewerAdapter{
public:
        // typedefs for the defOrg:
        typedef float                                                                                   DataType;       
        typedef  Geom_MeshSpatialObject< DataType, N_DIMS >             GeometricType;
        typedef itk::CovariantVector< DataType, N_DIMS >                GradientPixelType;
        typedef itk::Image< GradientPixelType, N_DIMS >                 GradientImageType;
        typedef Phys_LevelSet< DataType, ImageType, N_DIMS >    LevelSetPhysicsType;
        typedef Phys_Euler< DataType, 
                GradientImageType, N_DIMS >                                                     EulerPhysicsType;
        typedef Sense_Gradient< DataType, ImageType, 
                GradientImageType, N_DIMS >                                                     GradientSensorType;
        typedef Ctrl_ScheduleDriven<DataType, N_DIMS>                   CognitiveType;
        typedef Beh_TranslateAll<DataType, N_DIMS>                              Beh_TranslateAllType;
        typedef Def_Translation<DataType, N_DIMS>                               Def_TranslateAllType;

        typedef itk::ItkOrganism < ImageType, ImageType,
                GradientImageType, DataType, N_DIMS >                           OrganismType;

        typedef itk::DefaultDynamicMeshTraits<
                DataType, N_DIMS, N_DIMS >                                                      MeshTrait;
        typedef  itk::Mesh< DataType, N_DIMS, MeshTrait >               MeshType;
        typedef  MeshType::Pointer                                                              MeshTypePointer;

        // typedefs for itk->vtk mesh conversion:
        typedef itk::CellInterfaceVisitorImplementation<
                DataType, MeshType::CellTraits,
                itk::TriangleCell< itk::CellInterface<MeshType::PixelType, MeshType::CellTraits > >, 
                VistVTKCellsClass> TriangleVisitor;

        typedef itk::CellInterfaceVisitorImplementation<
                DataType, MeshType::CellTraits,
                itk::QuadrilateralCell< itk::CellInterface<MeshType::PixelType, MeshType::CellTraits > >, 
                VistVTKCellsClass> QuadrilateralVisitor;
        
        SetStringMacro(ScheduleFileName);
        SetStringMacro(MeshFileName);
        SetStringMacro(ImageFileName);

        DefOrgViewerAdapter();
        void SetupOrganism();
        void UpdateOrganism(itkScenePointer itkScene /*in/out*/);
        void PopulateVtkImage(vtkImageImport* vtkImporter /*in/out*/);
        void PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid /*in/out*/);
        void PopulateItkScene(itkScenePointer itkScene /*in/out*/);
        bool IsAllInputFilesSet();

        
private:
        void ConnectPipelines( itkImageExportTypePointer exporter, vtkImageImport* importer);
        void MeshToUnstructuredGrid( MeshTypePointer mesh, vtkUnstructuredGrid* vgrid); 

        std::string m_ImageFileName;
        std::string m_ScheduleFileName;
        std::string m_MeshFileName;

        ImageFileReaderPointer                  m_InputImageReader;
        itkImageExportTypePointer               m_ItkExporter;
        OrganismType::Pointer                   testOrg;
        LevelSetPhysicsType                             levelSetPhysLayer;
        EulerPhysicsType*                               eulerPhysLayerPointer;
        GradientSensorType::sensorIn    sensorInput;
        GradientSensorType                              gradientSensor;
        GeometricType*                                  geomLayerPointer;
        CognitiveType*                                  cognitiveLayerPointer;
        Beh_TranslateAllType*                   beh1;
        Def_TranslateAllType*                   def1;                                           

};

class VistVTKCellsClass
{
        vtkCellArray* m_Cells;
        int* m_LastCell;
        int* m_TypeArray;
public:
        // typedef the itk cells we are interested in
        typedef itk::CellInterface<
                DefOrgViewerAdapter::MeshType::PixelType, 
                DefOrgViewerAdapter::MeshType::CellTraits >  CellInterfaceType;

        typedef itk::TriangleCell<CellInterfaceType>      floatTriangleCell;
        typedef itk::QuadrilateralCell<CellInterfaceType> floatQuadrilateralCell;

        // Set the vtkCellArray that will be constructed
        void SetCellArray(vtkCellArray* a) 
        {
                m_Cells = a;
        }
        // Set the cell counter pointer
        void SetCellCounter(int* i)
        {
                m_LastCell = i;
        }
        // Set the type array for storing the vtk cell types
        void SetTypeArray(int* i)
        {
                m_TypeArray = i;
        }
        // Visit a triangle and create the VTK_TRIANGLE cell 
        void Visit(unsigned long, floatTriangleCell* t)
        {
                m_Cells->InsertNextCell(3,  (vtkIdType*)t->PointIdsBegin());
                m_TypeArray[*m_LastCell] = VTK_TRIANGLE;
                (*m_LastCell)++;
        }
        // Visit a triangle and create the VTK_QUAD cell 
        void Visit(unsigned long, floatQuadrilateralCell* t)
        {
                m_Cells->InsertNextCell(4,  (vtkIdType*)t->PointIdsBegin());
                m_TypeArray[*m_LastCell] = VTK_QUAD;
                (*m_LastCell)++;
        }
};


#endif

---