Cone6
VTKExamples/Java/Miscellaneous/Cone6
Code¶
Cone6.java
// First we import the VTK package that will make available all // of the VTK commands to Java. import vtk.*; public class Cone6 { /** * @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("vtkImagingJava"); System.loadLibrary("vtkGraphicsJava"); System.loadLibrary("vtkRenderingJava"); System.loadLibrary("vtkWidgetsJava"); } // create the box widget as an instance variable so we can interact // with it from the interaction call back. vtkBoxWidget boxWidget = null; public static void main(String[] args) { // We will start by creating an instance of our Cone6 example // This example uses callbacks, and for Java that requires an instance // object to own the callback logic. Cone6 myCone = new Cone6(); myCone.doit(); } // Similar to Step2/Java/Cone2.java, we define a callback for // interaction. In this case we will apply the box transform to the its prop3D. // Java callbacks do not have parameters. void myCallback() { vtkTransform t = new vtkTransform(); boxWidget.GetTransform(t); boxWidget.GetProp3D().SetUserTransform(t); } /* * The doit() function is simply the instance function to perform the * construction of the vtk pipeline for this example. */ void doit() { // This example introduces 3D widgets. 3D widgets take advantage of the // event/observer design pattern introduced previously. They typically // have a particular representation in the scene which can be // interactively // selected and manipulated using the mouse and keyboard. As the widgets // are manipulated, they in turn invoke events such as // StartInteractionEvent, // InteractionEvent, and EndInteractionEvent which can be used to // manipulate // the scene that the widget is embedded in. 3D widgets work in the // context // of the event loop which was set up in the previous example. // // 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); // 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 souece to the input of this mapper. vtkPolyDataMapper coneMapper = new vtkPolyDataMapper(); coneMapper.SetInput(cone.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(300, 300); // 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. vtkRenderWindowInteractor 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); // Here we use a vtkBoxWidget to transform the underlying coneActor (by // manipulating its transformation matrix). Many other types of widgets // are available for use, see the documentation for more details. // // The SetInteractor method is how 3D widgets are associated with the // render // window interactor. Internally, SetInteractor sets up a bunch of // callbacks // using the Command/Observer mechanism (AddObserver()). The place // factor // controls the initial size of the widget with respect to the bounding // box // of the input to the widget. boxWidget = new vtkBoxWidget(); boxWidget.SetInteractor(iren); boxWidget.SetPlaceFactor(1.25); // Place the interactor initially. The input to a 3D widget is used to // initially position and scale the widget. The EndInteractionEvent is // observed which invokes the SelectPolygons callback. boxWidget.SetProp3D(coneActor); boxWidget.PlaceWidget(); // Now for every interaction event that is generated by the boxWidget, // call our callback function. boxWidget.AddObserver("InteractionEvent", this, "myCallback"); // Normally the user presses the "i" key to bring a 3D widget to // life. Here we will manually enable it so it appears with the cone. boxWidget.On(); // Start the event loop. iren.Initialize(); iren.Start(); // There is no explicit need to free any objects at this point. // Once Java exits, memory is automatically freed. } }