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

#include "DefOrgViewer.h"

//class pickCallback
//      : public vtkCommand
//{
//public:
//      static pickCallback *New() { return new pickCallback; }
//      void Delete() { delete this; }
//
//      void Execute(vtkObject *caller, 
//              unsigned long event, 
//              void *vtkNotUsed(callData))
//      {
//              vtkPointPicker* p = reinterpret_cast<vtkPointPicker*>(caller);
//
//              double positions[3];
//
//              p->GetPickPosition(positions);
//              std::cout << "[" << positions[1] << ", " << positions[2] << ", " << positions[3] << "]" << std::endl;
//              return;
//      }
//      float x, y, z;
//};

// Default constructor:
DefOrgViewer
::DefOrgViewer()
: DefOrgViewerGUI()
{
        orgNotSet = true;
        geomLayerPointer = new GeometricType();
        mainWindow->show();
        display->show();

        isVolumeRenderingOn = false;

        scheduleFileName =              "data\\testSchedule3d.txt"; // TODO: eliminate hardcoded values here

        // note: from DefOrgViewer.h: 'renderer' is of type vtkRenderer*
        renderer = RendererType::New();
        renderer->SetBackground(0.0, 0.0, 0.0);

        renderWindow = vtkRenderWindow::New();
        renderWindow->AddRenderer( renderer );

        // note: 'display' is of type vtkFlRenderWindowInteractor*
        display->SetRenderWindow( renderWindow );

        image = NULL;

        planeX = vtkImagePlaneWidget::New();
        //planeX->RestrictPlaneToVolumeOn();
        //planeX->SetResliceInterpolateToCubic();
        //planeX->SetInput( static_cast<vtkDataSet*>(vtkImporter->GetOutput()) );
        //planeX->SetPlaneOrientationToXAxes();
        //planeX->SetSliceIndex( floor(static_cast<double>(imageSize[0]/2)) );
        //planeX->SetInteractor( display );

        opacityTransferFunction =       vtkPiecewiseFunction::New();
        colorTransferFunction =         vtkColorTransferFunction::New();
        compositeFunction =                     vtkVolumeRayCastCompositeFunction::New();
        volumeProperty =                        vtkVolumeProperty::New();
        volumeMapper =                          vtkVolumeRayCastMapper::New();

        //opacityTransferFunction->AddPoint( 20,                2 );
        //opacityTransferFunction->AddPoint( 255,               0.2 );
        opacityTransferFunction->AddPoint( 20,          0.7 );
        opacityTransferFunction->AddPoint( 255,         1.0 );
        opacityTransferFunction->AddSegment( 100, 0.8, 150, 0.2 );

        colorTransferFunction->AddRGBPoint( 0.0,        0.0,    0.0,    0.0 );
        colorTransferFunction->AddRGBPoint( 64.0,       1.0,    0.0,    0.0 );
        colorTransferFunction->AddRGBPoint( 128.0,      0.0,    0.0,    1.0 );
        //colorTransferFunction->AddRGBPoint( 255.0,    0.0,    0.2,    0.0 );
        colorTransferFunction->AddRGBPoint( 255.0,      255.0,  255.0,  255.0 );
        //colorTransferFunction->AddRGBPoint( 255.0,    1.0,    1.0,    1.0 );
        
    //compositeFunction->SetCompositeMethodToInterpolateFirst();

        volumeProperty->SetColor(                       colorTransferFunction );
        volumeProperty->SetScalarOpacity(       opacityTransferFunction );
        volumeProperty->SetInterpolationTypeToLinear();

        //compositeFunction = vtkVolumeRayCastMIPFunction::New();

        volumeMapper->SetVolumeRayCastFunction( compositeFunction );
        //volumeMapper->SetInput( vtkImporter->GetOutput() );
        
        volume = vtkVolume::New();
        volume->SetMapper( volumeMapper );
        volume->SetProperty( volumeProperty );

        meshMapper = vtkDataSetMapper::New();

        axes = vtkCubeAxesActor2D::New();
        
        display->Initialize();

        //renderWindow->Render();

        return;
}

// Constructor:
DefOrgViewer
::DefOrgViewer( MeshTypePointer itkMesh )
{
        orgNotSet=true;
        geomLayerPointer = new GeometricType();
        mainWindow->show();
        display->show();

        // note: from DefOrgViewer.h: 'renderer' is of type vtkRenderer*
        renderer = RendererType::New();
        renderer->SetBackground(0.0, 0.0, 0.0);

        renderWindow = vtkRenderWindow::New();
        renderWindow->AddRenderer( renderer );

        // note: 'display' is of type vtkFlRenderWindowInteractor*
        display->SetRenderWindow( renderWindow );

        //-----------------------------------------------------------------------
        // DEBUG: TEST USING SPHERE MESH SOURCE
        //typedef itk::RegularSphereMeshSource< MeshType > SphereMeshSourceType;
        //SphereMeshSourceType::Pointer sphereMesh = SphereMeshSourceType::New();

        //SphereMeshSourceType::PointType centerPoint;
        //for( unsigned int i=0; i<N_DIMS; i++ )
        //{
        //      centerPoint[i] = 50.0;
        //}

        //sphereMesh->SetCenter( centerPoint );
        //sphereMesh->SetScale( 20 );
        //sphereMesh->SetResolution( 4 );
        //
        //sphereMesh->Update();

        //MeshType::Pointer myMesh = sphereMesh->GetOutput();


        // convert ITK mesh into VTK grid:
        //vtkUnstructuredGrid* vtkGrid = MeshToUnstructuredGrid( myMesh );
        vtkUnstructuredGrid* vtkGrid = MeshToUnstructuredGrid( itkMesh );


        //-----------------------------------------------------
        // Image stuff:
        typedef itk::ImageFileReader< ImageType > ImageReaderType;
        ImageReaderType::Pointer imageReader = ImageReaderType::New();
        itk::MetaImageIOFactory::RegisterOneFactory();

        char* inputImageFileName = fl_file_chooser("Pick an image file to load", "*.*", 0, 0);

        imageReader->SetFileName( inputImageFileName );
        //typedef itk::CastImageFilter< ImageType, ImageType >                  UCharCastFilterType;
        //UCharCastFilterType::Pointer castFilter = UCharCastFilterType::New();
        //castFilter->SetInput( imageReader->GetOutput() );
        //castFilter->Update();

        //image = castFilter->GetOutput();
        image = imageReader->GetOutput();

        //vtkJPEGReader* vtkImageReader = vtkJPEGReader::New();
        //vtkImageReader->SetFileName( "data\\baseball.jpg" );
        //vtkImageReader->Update();

        //vtkMetaImageReader* vtkMetaReader = vtkMetaImageReader::New();
        //vtkMetaReader->SetFileName( "data\\test.mhd" );

        itkExporter = itkImageExportType::New();
        itkExporter->SetInput( image );

        vtkImporter = vtkImageImportType::New();

        std::cout << "Starting to connect ITK pipeline->VTK pipeline..." << std::endl;
        ConnectPipelines( itkExporter, vtkImporter );
        std::cout << "Finished connecting ITK pipeline->VTK pipeline..." << std::endl;

        itkExporter->Update();
        vtkImporter->Update();

        //vtkJPEGWriter* vtkImageWriter = vtkJPEGWriter::New();
        //vtkImageWriter->SetFileName( "data\\VTK_TEST_WRITE.jpg" );
        //vtkImageWriter->SetInput( vtkImporter->GetOutput() );
        //try
        //{
        //      vtkImageWriter->Write();
        //}
        //catch( ... )
        //{
        //      std::cout << "Error writing VTK JPEG." << std::endl;
        //}

        itk::Size< N_DIMS > imageSize = image->GetLargestPossibleRegion().GetSize();

        vtkImagePlaneWidget* planeX = vtkImagePlaneWidget::New();
        planeX->RestrictPlaneToVolumeOn();
        planeX->SetResliceInterpolateToCubic();
        planeX->SetInput( static_cast<vtkDataSet*>(vtkImporter->GetOutput()) );
        planeX->SetPlaneOrientationToXAxes();
        planeX->SetSliceIndex( floor(static_cast<double>(imageSize[0]/2)) );
        planeX->SetInteractor( display );

        vtkImagePlaneWidget* planeY = vtkImagePlaneWidget::New();
        planeY->RestrictPlaneToVolumeOn();
        planeY->SetResliceInterpolateToCubic();
        planeY->SetInput( static_cast<vtkDataSet*>(vtkImporter->GetOutput()) );
        planeY->SetPlaneOrientationToYAxes();
        planeY->SetSliceIndex( floor(static_cast<double>(imageSize[1]/2)) );
        planeY->SetInteractor( display );

        vtkImagePlaneWidget* planeZ = vtkImagePlaneWidget::New();
        planeZ->RestrictPlaneToVolumeOn();
        planeZ->SetResliceInterpolateToCubic();
        planeZ->SetInput( static_cast<vtkDataSet*>(vtkImporter->GetOutput()) );
        planeZ->SetPlaneOrientationToZAxes();
        planeZ->SetSliceIndex( floor(static_cast<double>(imageSize[2]/2)) );
        planeZ->SetInteractor( display );

        //-----------------------------------------------------
        // DEBUG: VOLUME RENDERING TEST
        // note: declared in DefOrgViewer.h:
        //vtkPiecewiseFunction*                 opacityTransferFunction;
        //vtkColorTransferFunction*             colorTransferFunction;
        //vtkVolumeRayCastCompositeFunction* compositeFunction;
        //vtkVolumeProperty*                            volumeProperty;
        //vtkVolumeRayCastMapper*                       volumeMapper;

        opacityTransferFunction =       vtkPiecewiseFunction::New();
        colorTransferFunction =         vtkColorTransferFunction::New();
        compositeFunction =                     vtkVolumeRayCastCompositeFunction::New();
        volumeProperty =                        vtkVolumeProperty::New();
        volumeMapper =                          vtkVolumeRayCastMapper::New();

        //opacityTransferFunction->AddPoint( 20,                2 );
        //opacityTransferFunction->AddPoint( 255,               0.2 );
        //opacityTransferFunction->AddPoint( 20,                0.7 );
        //opacityTransferFunction->AddPoint( 255,               1.0 );
        opacityTransferFunction->AddSegment( 0, 0.2, 150, 0.8 );

        colorTransferFunction->AddRGBPoint( 0.0,        0.0,    0.0,    0.0 );
        colorTransferFunction->AddRGBPoint( 64.0,       1.0,    0.0,    0.0 );
        colorTransferFunction->AddRGBPoint( 128.0,      0.0,    0.0,    1.0 );
        //colorTransferFunction->AddRGBPoint( 255.0,    0.0,    0.2,    0.0 );
        colorTransferFunction->AddRGBPoint( 255.0,      255.0,  255.0,  255.0 );
        //colorTransferFunction->AddRGBPoint( 255.0,    1.0,    1.0,    1.0 );
        
    //compositeFunction->SetCompositeMethodToInterpolateFirst();

        volumeProperty->SetColor(                       colorTransferFunction );
        volumeProperty->SetScalarOpacity(       opacityTransferFunction );
        volumeProperty->SetInterpolationTypeToLinear();

        //compositeFunction = vtkVolumeRayCastMIPFunction::New();

        volumeMapper->SetVolumeRayCastFunction( compositeFunction );
        volumeMapper->SetInput( vtkImporter->GetOutput() );
        
        volume = vtkVolume::New();
        volume->SetMapper( volumeMapper );
        volume->SetProperty( volumeProperty );
        volume->VisibilityOn();
        
        renderer->AddVolume( volume );

        //vtkActor* volumeActor = vtkActor::New();
        //volumeActor->SetMapper( volumeMapper );
        //renderer->AddActor( volumeActor );

        //-----------------------------------------------------
        // DEBUG: IMPLICIT PLANE WIDGET TEST

        //vtkImplicitPlaneWidget* planeWidget = vtkImplicitPlaneWidget::New();
        //planeWidget->SetInteractor( display );

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

        vtkDataSetMapper* mapper = vtkDataSetMapper::New();
        mapper->SetInput( vtkGrid );
        vtkActor* actor = vtkActor::New();
        actor->SetMapper( mapper );

        renderer->AddActor( actor );
        //renderer->AddActor( imgActor );

        planeX->On();
        planeY->On();
        planeZ->On();

        //trackBallInteractor = vtkInteractorStyleTrackballActor::New();
        //display->SetInteractorStyle( trackBallInteractor );

        display->Initialize();

        renderWindow->Render();

        return;
}

//void
//DefOrgViewer
//::ChangeRepresentation( )
//{
//
//      /*      GroupType::ChildrenListPointer children = group->GetChildren();
//      GroupType::ChildrenListType::iterator it = children->begin();
//
//      while( it != children->end() )
//      {
//      renderer->GetVisualObject(*it)->GetProperty()->SetRepresentationType( rep );
//      it++;
//      }
//
//      renderer->Update();
//      display->Update();
//      */   
//      return;
//}


void
DefOrgViewer
::Quit()
{
        this->Hide();
        exit( 0 );
}

void
DefOrgViewer
::Show()
{
        mainWindow->show();
}

void
DefOrgViewer
::Update()
{
        //display->Update();
}

void
DefOrgViewer
::LoadImage()
{
        imageReader = ImageReaderType::New();
        //itk::MetaImageIOFactory::RegisterOneFactory();

        char* inputImageFileName = fl_file_chooser("Pick an image file to load", "*.mh*", 0, 0);
        if( inputImageFileName == NULL){ return; };

        imageReader->SetFileName( inputImageFileName );

        image = imageReader->GetOutput();

        itkExporter = itkImageExportType::New();
        itkExporter->SetInput( image );

        vtkImporter = vtkImageImportType::New();

        std::cout << "Starting to connect ITK pipeline->VTK pipeline..." << std::endl;
        ConnectPipelines( itkExporter, vtkImporter );
        std::cout << "Finished connecting ITK pipeline->VTK pipeline..." << std::endl;

        itkExporter->Update();
        vtkImporter->Update();

        itk::Size< N_DIMS > imageSize = image->GetLargestPossibleRegion().GetSize();
        planeX->RestrictPlaneToVolumeOn();
        planeX->SetInput( static_cast<vtkDataSet*>(vtkImporter->GetOutput()) );
        planeX->SetSliceIndex( floor(static_cast<double>( imageSize[2] / 2 )) );
        planeX->SetPlaneOrientationToZAxes();
        planeX->SetInteractor( display );

        planeX->On();

        volumeMapper->SetInput( vtkImporter->GetOutput() );
        isVolumeRenderingOn ? volume->VisibilityOn() : volume->VisibilityOff();

        renderer->AddVolume( volume );
        //camera = renderer->GetActiveCamera();
        //light = vtkLight::New();
        //light->SetColor( 1.0, 1.0, 1.0 ); // white light
        //light->SetFocalPoint( camera->GetFocalPoint() );
        //light->SetPosition( camera->GetPosition() );
        //renderer->AddLight( light );
        //double halfX, halfY, halfZ;
        //halfX = floor(static_cast<double>( imageSize[0] / 2 ));
        //halfY = floor(static_cast<double>( imageSize[1] / 2 ));
        //halfZ = floor(static_cast<double>( imageSize[2] / 2 ));
        //camera->SetFocalPoint( halfX, halfY, halfZ );
        //camera->SetPosition( halfX, halfY, -4*halfZ );

        axes->SetInput( vtkImporter->GetOutput() );
        axes->SetCamera( renderer->GetActiveCamera() );
        axes->SetLabelFormat( "%4.3g" );
        axes->SetFlyModeToOuterEdges();
        axes->SetFontFactor( 0.8 );
        axes->GetProperty()->SetColor( 1.0, 1.0, 1.0 );

        renderer->ResetCamera();

        renderWindow->Render();

        return;
}

void
DefOrgViewer
::LoadMeta()
{
        char* fcResult = fl_file_chooser("Pick a mesh file to load", "*.{meta,BYU}", 0, 0);
        if( fcResult == NULL){ return; };
        std::string choiceStr = fcResult;
        std::string inputTopologyFileName;

        std::string prefix = choiceStr.substr( 0, choiceStr.length()-4 );
        std::string suffix = choiceStr.substr( choiceStr.length()-4, 4 );
        if( suffix == ".BYU" || suffix == ".byu" ) // TODO: use toupper() to simplify comparison
        {
                inputTopologyFileName = prefix+".meta";
                int converted = BYUToMeta( choiceStr, inputTopologyFileName );
                if( converted < 0 )
                {
                        std::cerr << "Error attempting to convert BYU file to meta format. Do you have write permissions in the directory containing "
                                << choiceStr << "?" << std::endl;
                        return;
                }
        }
        else if( suffix == "META" || suffix == "meta" )
        {
                inputTopologyFileName = choiceStr;
        }
        else
        {
                std::cerr << "Error loading mesh. Currently only .meta and .BYU files are supported." << std::endl;
        }
        
        geomLayerPointer->readTopologyFromFile( inputTopologyFileName );
        std::cout << "Topology read from '" << inputTopologyFileName << "'..." << std::endl;

        vtkUnstructuredGrid* vtkGrid = MeshToUnstructuredGrid( geomLayerPointer->theMesh );

        meshMapper->SetInput( vtkGrid );
        vtkActor* meshActor = vtkActor::New();
        meshActor->SetMapper( meshMapper );

        // TEMP: SET THE RGB VALUE OF THE MESH SURFACE HERE:
        meshActor->GetProperty()->SetColor( 0.3, 1.0, 0.4 ); // e.g. green

        renderer->AddActor( meshActor );

        renderer->ResetCamera();
        renderer->Render();

        return;
}

void
DefOrgViewer
::ToggleVolumeRendering()
{
        isVolumeRenderingOn = !isVolumeRenderingOn;
        (isVolumeRenderingOn) ? volume->VisibilityOn() : volume->VisibilityOff();
}

//typedef DefOrgViewer::MeshType::Pointer MeshTypePointer;
vtkUnstructuredGrid* 
DefOrgViewer
::MeshToUnstructuredGrid( MeshTypePointer mesh )
{
        // 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;
                exit(-1);
        }
        // Create a vtkUnstructuredGrid
        vtkUnstructuredGrid* vgrid = vtkUnstructuredGrid::New();

        // 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();
        // return the vtkUnstructuredGrid
        return vgrid;
}
void
DefOrgViewer::TogglePlayPause()
{
        //Call the base class
        DefOrgViewerGUI::TogglePlayPause();

        //if the Organism has not been setup, then set it up.
        if(orgNotSet)
        {
                orgNotSet = false;
                this->SetupOrganism();
        }
}

void
DefOrgViewer::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;
        scheduleFileName =              "data\\testSchedule3d.txt"; // TODO: eliminate hardcoded values here

        //Setup the sensor
        GradientSensorType::sensorIn input;
                
        input.sigma = 1.0;
        this->imageReader->Update();
        input.imageIn = this->imageReader->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(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(imageReader->GetOutput());
}
void
DefOrgViewer
::UpdateOrganism()
{
        //Cause the organism to simulate!
        //testOrg->Update();
        testOrg->run();
        //geomLayerPointer->writeObjectToFile("C:\\test.meta");
        //Update the mesh
        vtkUnstructuredGrid* vtkGrid = MeshToUnstructuredGrid( geomLayerPointer->theMesh );

        meshMapper->SetInput( vtkGrid );
        renderer->Render();
}

void 
DefOrgViewer
::ConnectPipelines( itkImageExportType::Pointer exporter, 
                                   vtkImageImportType* 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());
}

---