// First we import the VTK package that will make available all
// of the VTK commands to Java.
import vtk.*;
public class animDataCone {
/**
* @param args
*/
// load the necessary interface libraries on first reference to the
// class.
static {
System.loadLibrary("vtkCommonJava");
System.loadLibrary("vtkFilteringJava");
System.loadLibrary("vtkIOJava");
System.loadLibrary("vtkGeovisJava");
System.loadLibrary("vtkImagingJava");
System.loadLibrary("vtkGraphicsJava");
System.loadLibrary("vtkRenderingJava");
System.loadLibrary("vtkWidgetsJava");
}
// declare the interactor as an instance variable so we can refer to it
// in the timer callback. we will pass the instance pointer to this
// class for the callback to be invoked on.
vtkRenderWindowInteractor iren = null;
// create an instance polydata object to hold the animated polydata
vtkAppendPolyData pd = null;
// create the Transform as an instance variable so we can interact
// with it from the interaction call back.
vtkTransform Transform = null;
// animState is how we manage the transform choices.
// each animState is a frame of animation. in this case
// a selected scale transform in the array of scale settings
// in the moves array.
int animState = 0;
// this is an array of transforms to apply to the vtkPolyData.
static double moves[][] = { { 1.11, 1., 1. }, // expand on x
{ 1.11, 1., 1. }, // expand on x
{ 1.11, 1., 1. }, // expand on x
{ .9009, 1., 1. }, // contract on x
{ .9009, 1., 1. }, // contract on x
{ .9009, 1., 1. }, // contract on x
{ 1., 1.11, 1. }, // expand on y
{ 1., 1.11, 1. }, // expand on y
{ 1., 1.11, 1. }, // expand on y
{ 1., .9009, 1. }, // contract on y
{ 1., .9009, 1. }, // contract on y
{ 1., .9009, 1. }, // contract on y
{ 1., 1., 1.11 }, // expand on z
{ 1., 1., 1.11 }, // expand on z
{ 1., 1., 1.11 }, // expand on z
{ 1., 1., .9009 }, // contract on z
{ 1., 1., .9009 }, // contract on z
{ 1., 1., .9009 } // contract on z
};
public static void main(String[] args) {
// We will start by creating an instance of our animDataCone example
// This example uses callbacks, and for Java that requires an instance
// object to own the callback logic.
animDataCone myCone = new animDataCone();
myCone.doit();
}
/*
* The TimerEvent is specified as the TimerEvent callback
* to the RenderWindowInteractor. The polydata modification
* is done here as well as the call to the renderWindow to
* render the updated scene.
*/
void StartRender() {
vtkPolyData mpd = pd.GetPolyDataInput(0);
vtkPoints pts = mpd.GetPoints();
int ptct = pts.GetNumberOfPoints();
Transform.Identity();
Transform.Scale(animDataCone.moves[animState]);
// this would probably be better done with a property or assembly,
// but this clearly illustrates the modification of point data
for (int i = 0; i < ptct; i++) {
double[] xpt = pts.GetPoint(i);
xpt = Transform.TransformDoublePoint(xpt);
pts.SetPoint(i, xpt);
}
// cycle through the animation frames
animState = (++animState) % 18;
// Actually, marking the polydata as modified
// is the key to the animation.
// Comment the following pd.modified() and nothing
// will appear to happen, inspite of all the preceding.
// the pipeline UpdateExtent() only processes data that
// a modification time stamp more recent than the last render.
pd.Modified();
// Uncomment the following to get a log of time in milliseconds
// for each rendered frame.
// System.out.println("Render:" + System.currentTimeMillis());
}
/*
* The doit() function is simply the instance function to perform the
* construction of the vtk pipeline for this example.
*/
void doit() {
// This example illustrates animation via the startrender callback/
//
Transform = new vtkTransform();
// Next we create an instance of vtkConeSource and set some of its
// properties. The instance of vtkConeSource "cone" is part of a
// visualization pipeline (it is a source process object); it produces
// data (output type is vtkPolyData) which other filters may process.
vtkConeSource cone = new vtkConeSource();
cone.SetHeight(3.0);
cone.SetRadius(1.0);
cone.SetResolution(10);
pd = new vtkAppendPolyData();
pd.SetInput(cone.GetOutput());
// In this example we terminate the pipeline with a mapper process
// object.
// (Intermediate filters such as vtkShrinkPolyData could be inserted in
// between the source and the mapper.) We create an instance of
// vtkPolyDataMapper to map the polygonal data into graphics primitives.
// We connect the output of the cone source to the input of this mapper.
vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
coneMapper.SetInput(pd.GetOutput());
// Create an actor to represent the cone. The actor orchestrates
// rendering of
// the mapper's graphics primitives. An actor also refers to properties
// via a
// vtkProperty instance, and includes an internal transformation matrix.
// We
// set this actor's mapper to be coneMapper which we created above.
vtkActor coneActor = new vtkActor();
coneActor.SetMapper(coneMapper);
// Create the Renderer and assign actors to it. A renderer is like a
// viewport. It is part or all of a window on the screen and it is
// responsible for drawing the actors it has. We also set the
// background color here.
vtkRenderer ren1 = new vtkRenderer();
ren1.AddActor(coneActor);
ren1.SetBackground(0.1, 0.2, 0.4);
// Finally we create the render window which will show up on the screen
// We put our renderer into the render window using AddRenderer. We
// also set the size to be 300 pixels by 300.
vtkRenderWindow renWin = new vtkRenderWindow();
renWin.AddRenderer(ren1);
renWin.SetSize(600, 600);
// The vtkRenderWindowInteractor class watches for events (e.g.,
// keypress,
// mouse) in the vtkRenderWindow. These events are translated into
// event invocations that VTK understands (see VTK/Common/vtkCommand.h
// for all events that VTK processes). Then observers of these VTK
// events can process them as appropriate.
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
// By default the vtkRenderWindowInteractor instantiates an instance
// of vtkInteractorStyle. vtkInteractorStyle translates a set of events
// it observes into operations on the camera, actors, and/or properties
// in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
// Here we specify a particular interactor style.
vtkInteractorStyleTrackballCamera style = new vtkInteractorStyleTrackballCamera();
iren.SetInteractorStyle(style);
// Start the event loop.
iren.Initialize();
// Now for every window render we call our callback function to update
// the model
// resulting in another render.
ren1.AddObserver("StartEvent", this, "StartRender");
iren.CreateRepeatingTimer(50);
iren.Start();
// There is no explicit need to free any objects at this point.
// Once Python exits, memory is automatically freed.
}
}
