# 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.

        }

    }