demos/VtkDemo.cpp

Go to the documentation of this file.

/*=========================================================================

  Using Visualization Toolkit...

  Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen 
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderer.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkBoxWidget.h"
#include "vtkTransform.h"
#include "vtkConeSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkCommand.h"
#include "vtkOpenGLActor.h"
#include "vtkActor2D.h"
#include "vtkMapper2D.h"
#include "vtkOpenGLProperty.h"
#include "vtkCallbackCommand.h"
#include "vtkPolyData.h"
#include "vtkTimerLog.h"

// VOLUME RENDERING INCLUDES
#include "vtkVolumeRayCastCompositeFunction.h"
#include "vtkVolumeRayCastMapper.h"
#include "vtkVolume.h"
#include "vtkVolumeProperty.h"
#include "vtkColorTransferFunction.h"
#include "vtkPiecewiseFunction.h"
#include "vtkStructuredPointsReader.h"

#include "DemoConfig.h"

#include <string>


// Callback for box widget interaction
class vtkMyCallback : public vtkCommand
{
public:
        static vtkMyCallback *New() { return new vtkMyCallback; }
        void Execute(vtkObject *caller, unsigned long, void*)
    {
                if (!this->actor || !this->transform) return;
                vtkBoxWidget *boxWidget = reinterpret_cast<vtkBoxWidget*>(caller);
                boxWidget->GetTransform(this->transform);
                this->actor->SetUserTransform(this->transform);
    }
        vtkMyCallback(): transform(0), actor(0) {}

        void SetActor(vtkActor * actor) { this->actor = actor; }
        void SetTransform(vtkTransform * transform) { this->transform = transform; }

private:
        vtkActor     * actor;
        vtkTransform * transform;
};

class glwxWidgetMapper : public vtkMapper2D
{
public:
        static glwxWidgetMapper *New() { return new glwxWidgetMapper; }
        void Render(vtkRenderer *ren, vtkActor *act) { }
        void SetGui( GuiWrapper * gui ) { this->gui = gui; }

        int RenderGui() {

                double time = timer->GetUniversalTime();
                gui->Update(time-oldTime);
                oldTime = time;

                if (gui->IsActive()) {
                        gui->RenderScene();
                        return 1;
                }
                return 0;
        }

        ~glwxWidgetMapper()
        {
                timer->Delete();
        }

protected:
        glwxWidgetMapper()
        {
                timer = vtkTimerLog::New();
                oldTime = timer->GetUniversalTime();
        }
private:
        GuiWrapper * gui;
        vtkTimerLog * timer;
        double oldTime;

};

class glwxWidgetActor : public vtkActor2D
{
public:
        static glwxWidgetActor * New()
        {
                return new glwxWidgetActor;
        }

        int RenderOverlay (vtkViewport * vp)
        {
                glwxWidgetMapper * widgetMapper = (glwxWidgetMapper*)this->GetMapper();
                return widgetMapper->RenderGui();
        }

        //void Render(vtkRenderer *ren, vtkMapper *mapper) { }
        //int RenderOpaqueGeometry(vtkViewport * vp) { return 0; }
        //int RenderTranslucentPolygonalGeometry(vtkViewport *vp) { return 0; }

};




void MyCallback( vtkObject* vtkNotUsed(object),
                 unsigned long eid,
                 void* clientdata,
                 void* vtkNotUsed(calldata) );


DemoEventHandler handler;
GuiWrapper gui(&handler);

vtkCallbackCommand * eventCallback;

vtkRenderer *renderer; 
vtkInteractorStyleTrackballCamera *style;
vtkRenderWindow *renWin;
vtkRenderWindowInteractor *iren;

vtkConeSource *coneSource;
vtkPolyDataMapper *coneMapper;
vtkActor *coneActor;

glwxWidgetMapper * widgetMapper;
glwxWidgetActor * widgetActor;

vtkBoxWidget *boxWidget;
vtkTransform * widgetTransform;
vtkMyCallback *myCallback;


int main( int argc, char *argv[] )
{

        std::string DataDir = DEMO_DATA_DIR;
        if (argc == 2) DataDir = argv[1];

        // Create all the objects we'll need.
        renWin = vtkRenderWindow::New();
        renderer = vtkRenderer::New();
        iren = vtkRenderWindowInteractor::New();
        style = vtkInteractorStyleTrackballCamera::New();
        eventCallback = vtkCallbackCommand::New();
        coneSource = vtkConeSource::New();
        coneMapper = vtkPolyDataMapper::New();
        coneActor = vtkActor::New();
        widgetMapper = glwxWidgetMapper::New();
        widgetActor = glwxWidgetActor::New();
        boxWidget = vtkBoxWidget::New();
        widgetTransform = vtkTransform::New();
        myCallback = vtkMyCallback::New();

        boxWidget->SetInteractor( iren );

        // Set up event observers and callback function.
        eventCallback->SetClientData(style);
        eventCallback->SetCallback(MyCallback);
        style->AddObserver(vtkCommand::MouseMoveEvent, eventCallback);
        style->AddObserver(vtkCommand::LeftButtonPressEvent, eventCallback);
        style->AddObserver(vtkCommand::LeftButtonReleaseEvent, eventCallback);
        style->AddObserver(vtkCommand::CharEvent, eventCallback);
        style->AddObserver(vtkCommand::KeyPressEvent, eventCallback);

        // Set up render window and interactor style.
        renWin->AddRenderer(renderer);
        iren->SetInteractorStyle(style);
        iren->SetRenderWindow(renWin);

        // Set up widget, transform, and callback.
        //boxWidget->SetInteractor( iren );
        boxWidget->SetPlaceFactor( 0.8 );
        boxWidget->SetProp3D(coneActor);
        boxWidget->PlaceWidget();
        myCallback->SetTransform(widgetTransform);
        myCallback->SetActor(coneActor);
        boxWidget->AddObserver(vtkCommand::InteractionEvent, myCallback);

        // Set up cone source, mapper, and actor.
        coneSource->SetResolution(6);
        coneMapper->SetInputConnection(coneSource->GetOutputPort());
        coneActor->SetMapper(coneMapper);

        // Set up widget actor and mapper.
        widgetMapper->SetInputConnection(NULL); //FIX ME!
        widgetMapper->SetGui(&gui);
        widgetActor->SetMapper(widgetMapper);

        // Add actors to renderer.
        renderer->AddActor(coneActor);
        renderer->AddActor(widgetActor);

// VOLUME RENDERING
        /*vtkStructuredPointsReader * reader = vtkStructuredPointsReader::New();
        reader->SetFileName("/home/ramble/vtk/VTKData/Data/ironProt.vtk");

        vtkPiecewiseFunction * opacityTransferFunction = vtkPiecewiseFunction::New();
        opacityTransferFunction->AddPoint(20, 0.0);
        opacityTransferFunction->AddPoint(255, 0.2);

        vtkColorTransferFunction * colorTransferFunction = vtkColorTransferFunction::New();
        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(192.0, 0.0, 1.0, 0.0);
        colorTransferFunction->AddRGBPoint(255.0, 0.0, 0.2, 0.0);

        vtkVolumeProperty * volumeProperty = vtkVolumeProperty::New();
        volumeProperty->SetColor(colorTransferFunction);
        volumeProperty->SetScalarOpacity(opacityTransferFunction);
        volumeProperty->ShadeOn();
        volumeProperty->SetInterpolationTypeToLinear();

        vtkVolumeRayCastCompositeFunction * compositeFunction = vtkVolumeRayCastCompositeFunction::New();
        vtkVolumeRayCastMapper * volumeMapper = vtkVolumeRayCastMapper::New();
        volumeMapper->SetVolumeRayCastFunction(compositeFunction);
        volumeMapper->SetInputConnection(reader->GetOutputPort());

        vtkVolume * volume = vtkVolume::New();
        volume->SetMapper(volumeMapper);
        volume->SetProperty(volumeProperty);

        renderer->AddVolume(volume);*/

        // Initialize the render window and renderer.
        renderer->SetBackground(handler.red, handler.green, handler.blue);
        renWin->SetSize(700,500);
        renWin->Render();

        // Initialize the gui.
        // This must be called AFTER renWin->Render().
        gui.Init(DataDir.c_str());
        gui.SetDimensions(700,500);

        // Render the scene once, then start the interactor.
        iren->Render();
        iren->Start();

        // Clean up.
        renderer->Delete();
        renWin->Delete();
        iren->Delete();
        style->Delete();
        eventCallback->Delete();
        coneSource->Delete();
        coneMapper->Delete();
        coneActor->Delete();
        widgetActor->Delete();
        widgetMapper->Delete();
        boxWidget->Delete();
        widgetTransform->Delete();
        myCallback->Delete();

        return 0;
}





void MyCallback( vtkObject* vtkNotUsed(object),
                                       unsigned long eid,
                                       void* clientdata,
                                       void* vtkNotUsed(calldata) )
{
        int x = iren->GetEventPosition()[0];
        int y = 500 - iren->GetEventPosition()[1];

        switch (eid) {
        case vtkCommand::MouseMoveEvent:
                gui.MouseMoved(x, y);
                style->OnMouseMove();
                break;
        case vtkCommand::LeftButtonPressEvent:
                // Only forward the mouse click to the
                // interactor if it was not used by the gui.
                if ( !gui.MouseClicked(1, true, x, y) )
                        style->OnLeftButtonDown();
                break;
        case vtkCommand::LeftButtonReleaseEvent:
                // Only forward the mouse release to the
                // interactor if it was not used by the gui.
                if ( !gui.MouseClicked(1, false, x, y) )
                        style->OnLeftButtonUp();
                break;
        case vtkCommand::CharEvent:
                // Only forward the key press to the
                // interactor if it was not used by the gui.
                if ( !gui.AsciiKeyDown( iren->GetKeyCode() ))
                        style->OnChar();
                break;
        }
        renderer->SetBackground(handler.red, handler.green, handler.blue);

        // FIX ME!  Right now I re-render the screen when
        // this callback is triggered (event detected).
        // This is NOT what I want to do.  I only want to
        // update/redraw the gui actor, not ALL actors.
        iren->Render();
}

---