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

#include "DefOrgViewerAdapter.h"

DefOrgViewerAdapter::DefOrgViewerAdapter(){
        geomLayerPointer = new GeometricType();
}

void DefOrgViewerAdapter::PopulateItkScene(itkScenePointer itkScene /*in/out*/){
        geomLayerPointer->readTopologyFromFile( m_MeshFileName );
        itkScene->AddSpatialObject(geomLayerPointer->theMeshSpatialObject);  
}

void DefOrgViewerAdapter::UpdateOrganism(itkScenePointer itkScene /*in/out*/){
        testOrg->run();
        itkScene->AddSpatialObject(geomLayerPointer->theMeshSpatialObject);  
}

void DefOrgViewerAdapter::PopulateVtkImage(vtkImageImport* vtkImporter){
        m_InputImageReader = ImageFileReader::New();
        m_InputImageReader->SetFileName(m_ImageFileName.c_str());
        
        m_InputImageReader->Update();
        ImageType::Pointer image = m_InputImageReader->GetOutput();     
        m_ItkExporter = itkImageExportType::New();
        m_ItkExporter->SetInput( image );
        m_ItkExporter->Update();
        ConnectPipelines( m_ItkExporter, vtkImporter );
        vtkImporter->Update();
}

void DefOrgViewerAdapter::ConnectPipelines( itkImageExportType::Pointer exporter, 
                                   vtkImageImport* importer)
{
        importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
        importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
        importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
        importer->SetSpacingCallback(exporter->GetSpacingCallback());
        importer->SetOriginCallback(exporter->GetOriginCallback());
        importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
        importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
        importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
        importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
        importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
        importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
        importer->SetCallbackUserData(exporter->GetCallbackUserData());
}

bool DefOrgViewerAdapter::IsAllInputFilesSet(){
        return 
        (vtksys::SystemTools::FileExists(m_ImageFileName.c_str()) &&
        vtksys::SystemTools::FileExists(m_ScheduleFileName.c_str()) &&
        vtksys::SystemTools::FileExists(m_MeshFileName.c_str()) 
        );
}


void DefOrgViewerAdapter::SetupOrganism()
{
        //TODO:: make this robust (i.e. flag errors if image not set, geom not set etc).
        
        // Instantiate the organism:
        testOrg = OrganismType::New();
        std::cout << "Organism created..." << std::endl;

        //Setup the sensor
        GradientSensorType::sensorIn input;
                
        input.sigma = 1.0;
        this->m_InputImageReader->Update();
        input.imageIn = this->m_InputImageReader->GetOutput();
        gradientSensor.run((void *)&input);
        std::cout << "Gradient sensor setup complete..." << std::endl;
        GradientSensorType::sensorOut * output = (GradientSensorType::sensorOut *) gradientSensor.getOuput();


        //Instantiate geomtery and physics layers
        eulerPhysLayerPointer = new EulerPhysicsType(0,0,10);   
                        
        //physLayer.setInput(reader->GetOutput());
        eulerPhysLayerPointer->setExternalForces((void *) &(output->imageOut));
        eulerPhysLayerPointer->setGeometry(geomLayerPointer);

        testOrg->setPhysicsLayer(eulerPhysLayerPointer);
        testOrg->setGeometricLayer(geomLayerPointer);
        std::cout << "Physics layer added..." << std::endl;

        //TEST BEHAVIOR
        //TODO figure out how to make sure it gets deleted.
        //TODO should we attach things by value instead by ref?
        cognitiveLayerPointer = new CognitiveType(5);
        beh1 = new Beh_TranslateAllType();
        def1 = new Def_TranslateAllType();
        cognitiveLayerPointer->setSchedule(m_ScheduleFileName);
        //Beh_TranslateAll<float, 3> beh1;
        //Def_Translation<float, 3> def1;                                                               
        this->testOrg->setCognitiveLayer(cognitiveLayerPointer);
        this->testOrg->addBehaviour(beh1);
        this->testOrg->addDeformation(def1);

        //Pass the output of the reader to the filter, then to the writer.
        testOrg->SetInput(m_InputImageReader->GetOutput());
}

void DefOrgViewerAdapter::PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid /*in/out*/){
        geomLayerPointer->readTopologyFromFile( m_MeshFileName );
        MeshToUnstructuredGrid( geomLayerPointer->theMesh, vtkGrid/*in/out*/ );
}


void DefOrgViewerAdapter::MeshToUnstructuredGrid( MeshTypePointer mesh, vtkUnstructuredGrid* vgrid )
{
        // Get the number of points in the mesh
        int numPoints = mesh->GetNumberOfPoints();
        if(numPoints == 0)
        {
                mesh->Print(std::cerr);
                std::cerr << "no points in Grid " << std::endl;
        }

        // Create the vtkPoints object and set the number of points
        vtkPoints* vpoints = vtkPoints::New();
        vpoints->SetNumberOfPoints(numPoints);
        // iterate over all the points in the itk mesh filling in
        // the vtkPoints object as we go
        MeshType::PointsContainer::Pointer points = mesh->GetPoints();
        for(MeshType::PointsContainer::Iterator i = points->Begin();
                i != points->End(); ++i)
        {
                // Get the point index from the point container iterator
                int idx = i->Index();
                // Set the vtk point at the index with the the coord array from itk
                // itk returns a const pointer, but vtk is not const correct, so
                // we have to use a const cast to get rid of the const
                vpoints->SetPoint(idx, const_cast<DataType*>(i->Value().GetDataPointer()));
        }
        // Set the points on the vtk grid
        vgrid->SetPoints(vpoints);

        // Now create the cells using the MulitVisitor
        // 1. Create a MultiVisitor
        MeshType::CellType::MultiVisitor::Pointer mv =
                MeshType::CellType::MultiVisitor::New();
        // 2. Create a triangle and quadrilateral visitor
        TriangleVisitor::Pointer tv = TriangleVisitor::New();
        QuadrilateralVisitor::Pointer qv =  QuadrilateralVisitor::New();
        // 3. Set up the visitors
        int vtkCellCount = 0; // running counter for current cell being inserted into vtk
        int numCells = mesh->GetNumberOfCells();
        int *types = new int[numCells]; // type array for vtk 
        // create vtk cells and estimate the size
        vtkCellArray* cells = vtkCellArray::New();
        cells->EstimateSize(numCells, 4);
        // Set the TypeArray CellCount and CellArray for both visitors
        tv->SetTypeArray(types);
        tv->SetCellCounter(&vtkCellCount);
        tv->SetCellArray(cells);
        qv->SetTypeArray(types);
        qv->SetCellCounter(&vtkCellCount);
        qv->SetCellArray(cells);
        // add the visitors to the multivisitor
        mv->AddVisitor(tv);
        mv->AddVisitor(qv);
        // Now ask the mesh to accept the multivisitor which
        // will Call Visit for each cell in the mesh that matches the
        // cell types of the visitors added to the MultiVisitor
        mesh->Accept(mv);

        // Now set the cells on the vtk grid with the type array and cell array
        vgrid->SetCells(types, cells);

        // Clean up vtk objects (no vtkSmartPointer ... )
        cells->Delete();
        vpoints->Delete();

}

---