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

#ifndef __DefOrgViewerAdapterBaseTemplated_h
#define __DefOrgViewerAdapterBaseTemplated_h

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"

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

#include <iostream>

#include "itkImage.h"
#include "itkImageFileReader.h"
#include "vtkImageImport.h"
#include "itkVTKImageExport.h"
#include "DefOrgViewerAdapterBaseTemplated.h"
#include "DefOrgViewerAdapterBase.h"
#include "itkTriangleCell.h"
#include "itkQuadrilateralCell.h"
#include "itkDefaultDynamicMeshTraits.h"
#include "itkMesh.h"

#include <vtksys/SystemTools.hxx>
#include <vtksys/CommandLineArguments.hxx>
namespace mial{

#define N_DIMS 3
template<class MESHTYPE> class VistVTKCellsClass;
template <class ITKPIXELTYPE, class MESHDATATYPE>
class DefOrgViewerAdapterBaseTemplated:public DefOrgViewerAdapterBase{
public:

        //Constructor
        DefOrgViewerAdapterBaseTemplated(int maxNumImages):DefOrgViewerAdapterBase(maxNumImages){};

        //convenient typedefs for derived base classes
        typedef ITKPIXELTYPE                                                                    PixelType;
        typedef MESHDATATYPE                                                                    DataType;
        typedef typename itk::Image< PixelType, N_DIMS >                ImageType;
        typedef typename ImageType::Pointer                                             ImageTypePointer;
        typedef typename itk::ImageFileReader< ImageType >              ImageFileReader;
        typedef typename ImageFileReader::Pointer                               ImageFileReaderPointer;
        typedef typename itk::VTKImageExport< ImageType >               itkImageExportType;
        typedef typename itkImageExportType::Pointer                    itkImageExportTypePointer;
        typedef typename itk::SceneSpatialObject<N_DIMS>::Pointer               itkScenePointer;

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

        // typedefs for itk->vtk mesh conversion:
        typedef typename itk::TriangleCell< typename itk::CellInterface<MESHDATATYPE, MeshTypeCellTraits > > 
                 TriangleCell;
        typedef typename itk::CellInterfaceVisitorImplementation<
                DataType, MeshTypeCellTraits, TriangleCell, VistVTKCellsClass<typename DefOrgViewerAdapterBaseTemplated::MeshType> >
                 TriangleVisitor;
        typedef typename itk::QuadrilateralCell< typename itk::CellInterface<MESHDATATYPE, MeshTypeCellTraits > > QuadrilateralCell;
        typedef typename itk::CellInterfaceVisitorImplementation<
                DataType, MeshTypeCellTraits, QuadrilateralCell, VistVTKCellsClass<typename DefOrgViewerAdapterBaseTemplated::MeshType> > 
                QuadrilateralVisitor;
        
        virtual void SetupOrganism()=0;
        virtual void UpdateOrganism()=0;
        virtual void PopulateVtkImage()=0;
        virtual void PopulateVtkImageHelper(ImageTypePointer itkImage, vtkImageImport* vtkImporter);
        virtual void PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid )=0;
        virtual void PopulateItkScene()=0;
        
protected:
        virtual void ConnectPipelines( itkImageExportTypePointer exporter, vtkImageImport* importer);
        virtual void MeshToUnstructuredGrid( MeshTypePointer mesh, vtkUnstructuredGrid* vgrid); 

        ImageFileReaderPointer                  m_InputImageReader;     
private:
        std::vector<itkImageExportTypePointer> m_itkImageExportPointerHolder;
};

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

---