C:/cmcintos/defOrgs/examples/DefOrgViewer/Source/DefOrgViewer.h

#ifndef DefOrgViewer_h
#define DefOrgViewer_h

#include "DefOrgViewerGUI.h"


//---------------------------------

// ITK includes:
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkEllipseSpatialObject.h"
#include "itkBlobSpatialObject.h"
#include "itkSceneSpatialObject.h"
#include "itkMeshSpatialObject.h"
#include "itkGroupSpatialObject.h"
#include "itkSpatialObjectReader.h"
#include "itkImageSpatialObject.h"
#include "itkMinimumMaximumImageFilter.h"
#include "itkVTKImageExport.h"
#include <itkCastImageFilter.h>

#include <itkRegularSphereMeshSource.h> // TEMP DEBUG

// std includes:
#include <iostream>

// VTK includes:
#include <vtkPointPicker.h>
#include "vtkRenderWindow.h"
#include "vtkImageImport.h"
#include "vtkImagePlaneWidget.h"
#include "vtkImageActor.h"
#include <vtkImageViewer.h>
#include "vtkImplicitPlaneWidget.h" // DEBUG
//#include "vtkJPEGReader.h" // DEBUG
//#include "vtkJPEGWriter.h" // DEBUG
#include "vtkVolumeMapper.h"
#include <vtkMetaImageReader.h>
//#include <vtkImageCast.h>
// volume rendering stuff:
#include <vtkPiecewiseFunction.h>
#include "vtkColorTransferFunction.h"
#include "vtkVolumeProperty.h"
#include "vtkVolumeRayCastCompositeFunction.h"
#include "vtkVolumeRayCastMIPFunction.h"
#include "vtkVolumeRayCastMapper.h"
#include "vtkVolume.h"
#include "vtkCamera.h"
#include "vtkLight.h"
#include "vtkInteractorStyleTrackballActor.h"
#include "vtkCubeAxesActor2D.h"
#include "vtkProperty2D.h"

#include "vtkRenderer.h"
#include "vtkOpenGLRenderer.h"
#include "vtkUnstructuredGrid.h"
#include "vtkCellArray.h"
#include "vtkProperty.h"
#include "vtkDataSetMapper.h"
#include "vtkImageData.h"
#include "vtkDataSet.h"

// other includes:
//#include "vtk2itk.cxx" // TEMP DEBUG
// vtkFlRenderWindowInteractor.h is included from DefOrgViewGUI.h
#include <itkMetaImageIOFactory.h>
#include "BYUToMeta.h"
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkMeanImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkCovariantVector.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"

#define N_DIMS 3

class VistVTKCellsClass; // predeclaration 

class DefOrgViewer
        : public DefOrgViewerGUI
{
public:
        // typedefs for the defOrg:
        typedef float                                                                                   DataType;
        typedef unsigned char                                                                   PixelType;
        typedef itk::Image< PixelType, N_DIMS >                                 ImageType;
        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;
        //typedef  itk::SpatialObject< N_DIMS >                         SpatialObjectType;
        //typedef  itk::MeshSpatialObject< MeshType >                   MeshSpatialObjectType;
        //typedef  itk::SceneSpatialObject< N_DIMS >                    SceneType;
        //typedef  SceneType::Pointer                                                   ScenePointer;
        //typedef  itk::GroupSpatialObject< N_DIMS >                    GroupType;
        //typedef  GroupType::Pointer                                                   GroupPointer;

        // typedefs for DefOrgViewer app:
        //typedef  vtkOpenGLRenderer                                                                    RendererType;
        typedef  vtkRenderer                                                                    RendererType;
        typedef  RendererType*                                                                  RendererPointer;
        typedef  itk::VTKImageExport< ImageType >                               itkImageExportType;
        typedef  vtkImageImport                                                                 vtkImageImportType;

        typedef itk::ImageFileReader< ImageType >                               ImageReaderType;
        ImageReaderType::Pointer                                                                imageReader;
        
        // 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;

        // constructors:
        DefOrgViewer();                 
        DefOrgViewer( MeshTypePointer itkMesh );

        // overrides of FLUID-created functions in DefOrgViewerGUI:
        void Quit();
        void Show();
        void Update();
        void LoadImage();
        void LoadMeta();
        void TogglePlayPause();
        void ToggleVolumeRendering();
        void TransferSlider1();
        void TransferSlider2();


        // class utility functions:
        vtkUnstructuredGrid* MeshToUnstructuredGrid( MeshType::Pointer itkMesh );
        void ConnectPipelines( itkImageExportType::Pointer exporter, vtkImageImportType* importer);
        void SetupOrganism();
        void UpdateOrganism();

private:
        // defOrg components:
        OrganismType::Pointer                   testOrg;
        LevelSetPhysicsType                             levelSetPhysLayer;
        EulerPhysicsType *                              eulerPhysLayerPointer;
        GradientSensorType::sensorIn    sensorInput;
        GradientSensorType                              gradientSensor;
        GeometricType*                                  geomLayerPointer;
        CognitiveType*                                  cognitiveLayerPointer;
        Beh_TranslateAllType                    * beh1;
        Def_TranslateAllType                    * def1;                                                         

        // DefOrgViewer components:
        vtkCubeAxesActor2D*                             axes;
        vtkLight*                                               light;
        vtkCamera*                                              camera;
        vtkImagePlaneWidget*                    planeX;
        ImageType::Pointer                              image;
        RendererPointer                                 renderer;
        vtkRenderWindow*                                renderWindow;
        itkImageExportType::Pointer             itkExporter;
        vtkImageImport*                                 vtkImporter;

        // volume rendering components:
        vtkPiecewiseFunction*                   opacityTransferFunction;
        vtkColorTransferFunction*               colorTransferFunction;
        vtkVolumeRayCastCompositeFunction* compositeFunction;
        vtkVolumeRayCastMIPFunction*    MIPFunction;
        vtkVolumeProperty*                              volumeProperty;
        vtkVolumeRayCastMapper*                 volumeMapper;
        vtkVolume*                                              volume;
        vtkDataSetMapper*                               meshMapper;
        vtkActor*                                               meshActor;

        //vtkInteractorStyleTrackballActor* trackBallInteractor;

        std::string                                             scheduleFileName;
        bool                                                    isVolumeRenderingOn;
        bool                                                    orgNotSet;
        
};


//**********************************************************************

class VistVTKCellsClass
{
        vtkCellArray* m_Cells;
        int* m_LastCell;
        int* m_TypeArray;
public:
        // typedef the itk cells we are interested in
        typedef itk::CellInterface<
                DefOrgViewer::MeshType::PixelType, 
                DefOrgViewer::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 // DefOrgViewer defined

---