AnimDataCone
VTKExamples/Java/Visualization/AnimDataCone
Code¶
AnimDataCone.java
// 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. } }