Exemplo n.º 1
0
        static void Main(string[] args)
        {
            string VTK_DATA_ROOT = vtk.vtkDotNetUtil.vtkGetDataRoot();

            // Create the reader and read a data file.  Connect the mapper and
            // actor.
            vtk.vtkSTLReader sr = new vtk.vtkSTLReader();
            sr.SetFileName(VTK_DATA_ROOT + "/Data/42400-IDGH.stl");

            vtk.vtkPolyDataMapper stlMapper = new vtk.vtkPolyDataMapper();
            stlMapper.SetInputConnection(sr.GetOutputPort());

            vtk.vtkLODActor stlActor = new vtk.vtkLODActor();
            stlActor.SetMapper(stlMapper);

            // Create the Renderer, RenderWindow, and RenderWindowInteractor
            vtk.vtkRenderer ren = new vtk.vtkRenderer();
            vtk.vtkRenderWindow renWin = new vtk.vtkRenderWindow();
            renWin.AddRenderer(ren);
            vtk.vtkRenderWindowInteractor iren = new vtk.vtkRenderWindowInteractor();
            iren.SetRenderWindow(renWin);

            // Add the actors to the render; set the background and size
            ren.AddActor(stlActor);
            ren.SetBackground(0.1, 0.2, 0.4);
            renWin.SetSize(500, 500);

            // Zoom in closer
            ren.ResetCamera();
            vtk.vtkCamera cam1 = ren.GetActiveCamera();
            cam1.Zoom(1.4);

            iren.Initialize();
            renWin.Render();
            iren.Start();

            vtk.vtkWin32OpenGLRenderWindow win32win =
                vtk.vtkWin32OpenGLRenderWindow.SafeDownCast(renWin);
            if (null != win32win) win32win.Clean();
        }
Exemplo n.º 2
0
        public void ShowVTKV3d()
        {
            renWin.AddRenderer(aRenderer);
            iren.SetRenderWindow(renWin);

            vtk.vtkSmoothPolyDataFilter smoother = new vtk.vtkSmoothPolyDataFilter();
            smoother.SetInputConnection(mc.GetOutputPort());
            smoother.SetRelaxationFactor(0.05);
            smoother.SetNumberOfIterations(30);

            vtk.vtkDecimatePro deci = new vtk.vtkDecimatePro();
            deci.SetInputConnection(smoother.GetOutputPort());
            deci.SetTargetReduction(0.9);
            deci.PreserveTopologyOn();
            deci.Update();

            int marchingNumberOfPoints = deci.GetOutput().GetNumberOfPoints();
            int marchingNumberOfPolys  = deci.GetOutput().GetNumberOfPolys();

            info += "marching number of points : " + marchingNumberOfPoints + "\r\n";
            info += "marching number of polys : " + marchingNumberOfPolys + "\r\n";

            vtk.vtkSmoothPolyDataFilter smoother2 = new vtk.vtkSmoothPolyDataFilter();
            smoother2.SetInputConnection(deci.GetOutputPort());
            smoother2.SetRelaxationFactor(0.05);
            smoother2.SetNumberOfIterations(30);

            mcmap.SetInputConnection(smoother2.GetOutputPort());
            mcmap.ScalarVisibilityOff();
            mcactor.SetMapper(mcmap);
            mcactor.GetProperty().SetColor(1, 1, 1);

            aRenderer.AddActor(mcactor);
            aRenderer.SetBackground(0.0f, 0.0f, 0.0f);
            aRenderer.ResetCamera();
            renWin.Render();
            addBusyObservers();
            iren.Initialize(); iren.Enable();
        }
Exemplo n.º 3
0
        void AddConeToWindow(vtk.vtkRenderWindow renWin)
        {
            //
            // 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.
            //
            vtk.vtkConeSource cone = new vtk.vtkConeSource();
            cone.SetHeight(3.0f);
            cone.SetRadius(1.0f);
            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.
            //
            vtk.vtkPolyDataMapper coneMapper = new vtk.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.
            //
            vtk.vtkActor coneActor = new vtk.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
            //
            vtk.vtkRenderer ren1 = new vtk.vtkRenderer();
            ren1.AddActor(coneActor);
            ren1.SetBackground(0.1f, 0.2f, 0.4f);

            //
            // 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
            //
            renWin.AddRenderer(ren1);

            vtk.vtkRenderWindowInteractor iren = renWin.GetInteractor();

            {
                m_boxWidget = new vtk.vtkBoxWidget();
                m_boxWidget.SetInteractor(iren);
                m_boxWidget.SetPlaceFactor(1.25f);

                m_boxWidget.SetProp3D(coneActor);
                m_boxWidget.PlaceWidget();

                m_boxWidget.AddObserver((uint)vtk.EventIds.InteractionEvent,
                                        new vtk.vtkDotNetCallback(myCallback));

                m_boxWidget.On();
            }
        }
Exemplo n.º 4
0
        void Run()
        {
            // Create a selection window.  We will display the point and cell ids
            // that lie within this window.
            int xmin = 200;
            xLength = 100;
            xmax = xmin + xLength;
            int ymin = 200;
            yLength = 100;
            ymax = ymin + yLength;

            pts = new vtk.vtkPoints();
            pts.InsertPoint(0, xmin, ymin, 0);
            pts.InsertPoint(1, xmax, ymin, 0);
            pts.InsertPoint(2, xmax, ymax, 0);
            pts.InsertPoint(3, xmin, ymax, 0);
            vtk.vtkCellArray rect = new vtk.vtkCellArray();
            rect.InsertNextCell(5);
            rect.InsertCellPoint(0);
            rect.InsertCellPoint(1);
            rect.InsertCellPoint(2);
            rect.InsertCellPoint(3);
            rect.InsertCellPoint(0);
            vtk.vtkPolyData selectRect = new vtk.vtkPolyData();
            selectRect.SetPoints(pts);
            selectRect.SetLines(rect);
            vtk.vtkPolyDataMapper2D rectMapper = new vtk.vtkPolyDataMapper2D();
            rectMapper.SetInput(selectRect);
            vtk.vtkActor2D rectActor = new vtk.vtkActor2D();
            rectActor.SetMapper(rectMapper);

            // Create a sphere and its associated mapper and actor.
            vtk.vtkSphereSource sphere = new vtk.vtkSphereSource();
            vtk.vtkPolyDataMapper sphereMapper = new vtk.vtkPolyDataMapper();
            sphereMapper.SetInputConnection(sphere.GetOutputPort());
            vtk.vtkPolyDataMapper.GlobalImmediateModeRenderingOn();
            vtk.vtkActor sphereActor = new vtk.vtkActor();
            sphereActor.SetMapper(sphereMapper);

            // Generate data arrays containing point and cell ids
            vtk.vtkIdFilter ids = new vtk.vtkIdFilter();
            ids.SetInputConnection(sphere.GetOutputPort());
            ids.PointIdsOn();
            ids.CellIdsOn();
            ids.FieldDataOn();

            // Create the renderer here because vtkSelectVisiblePoints needs it.
            vtk.vtkRenderer ren = new vtk.vtkRenderer();

            // Create labels for points
            visPts = new vtk.vtkSelectVisiblePoints();
            visPts.SetInputConnection(ids.GetOutputPort());
            visPts.SetRenderer(ren);
            visPts.SelectionWindowOn();
            visPts.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength);

            // Create the mapper to display the point ids.  Specify the format to
            // use for the labels.  Also create the associated actor.
            vtk.vtkLabeledDataMapper ldm = new vtk.vtkLabeledDataMapper();
            ldm.SetInputConnection(visPts.GetOutputPort());
            ldm.SetLabelFormat("%g");
            ldm.SetLabelModeToLabelFieldData();
            vtk.vtkActor2D pointLabels = new vtk.vtkActor2D();
            pointLabels.SetMapper(ldm);

            // Create labels for cells
            vtk.vtkCellCenters cc = new vtk.vtkCellCenters();
            cc.SetInputConnection(ids.GetOutputPort());
            visCells = new vtk.vtkSelectVisiblePoints();
            visCells.SetInputConnection(cc.GetOutputPort());
            visCells.SetRenderer(ren);
            visCells.SelectionWindowOn();
            visCells.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength);

            // Create the mapper to display the cell ids.  Specify the format to
            // use for the labels.  Also create the associated actor.
            vtk.vtkLabeledDataMapper cellMapper = new vtk.vtkLabeledDataMapper();
            cellMapper.SetInputConnection(visCells.GetOutputPort());
            cellMapper.SetLabelFormat("%g");
            cellMapper.SetLabelModeToLabelFieldData();
            cellMapper.GetLabelTextProperty().SetColor(0, 1, 0);
            vtk.vtkActor2D cellLabels = new vtk.vtkActor2D();
            cellLabels.SetMapper(cellMapper);

            // Create the RenderWindow and RenderWindowInteractor
            renWin = new vtk.vtkRenderWindow();
            renWin.AddRenderer(ren);
            vtk.vtkRenderWindowInteractor iren = new vtk.vtkRenderWindowInteractor();
            iren.SetRenderWindow(renWin);

            // Add the actors to the renderer; set the background and size;
            // render
            ren.AddActor(sphereActor);
            ren.AddActor2D(rectActor);
            ren.AddActor2D(pointLabels);
            ren.AddActor2D(cellLabels);

            ren.SetBackground(1, 1, 1);
            renWin.SetSize(500, 500);

            // Initialize the interactor.
            iren.Initialize();
            renWin.Render();

            // Move the selection window across the data set.
            MoveWindow();

            // Put the selection window in the center of the render window.
            // This works because the xmin = ymin = 200, xLength = yLength = 100, and
            // the render window size is 500 x 500.
            PlaceWindow(xmin, ymin);

            // Now start normal interaction.
            iren.Start();
            vtk.vtkWin32OpenGLRenderWindow win32win =
                vtk.vtkWin32OpenGLRenderWindow.SafeDownCast(renWin);
            if (null != win32win) win32win.Clean();
        }
Exemplo n.º 5
0
        // Function: Calculate en render Histogram in window
        public void renderHistogram(vtk.vtkImageData VoxelData)
        {
            // Get size of histogram window
            int[] size = renHist.GetSize();
            width = size[0]; height = size[1];


            //Setup parameters histogram Accumulate Filter
            numBins    = width / 2;
            inputRange = VoxelData.GetScalarRange();
            double origin  = inputRange[0];
            double spacing = 1.0 * (inputRange[1] - origin) / numBins;

            // Setup Accumulate filter
            vtk.vtkImageAccumulate accumulate = new vtk.vtkImageAccumulate();
            accumulate.SetInput(VoxelData); //Get input voxeldata
            accumulate.SetComponentExtent(0, numBins - 1, 0, 0, 0, 0);
            accumulate.SetComponentOrigin(origin, 0.0, 0.0);
            accumulate.SetComponentSpacing(spacing, 1.0, 1.0);

            // Make Data object from Accumulated object
            data = accumulate.GetOutput();
            data.Update();

            // Initialize first and last point of the transferfunction.
            npoints    = 2;
            pointsx[0] = 0; pointsy[0] = 0;
            pointsx[1] = width - 1; pointsy[1] = height - 1;
            pointsc[0] = 1; pointsc[1] = 1;

            // Draw the histogram in a canvas and add the transferfunction to it
            drawhisto();
            drawcurve();

            // Create a color table
            vtk.vtkColorTransferFunction colorTransferFunction = new vtk.vtkColorTransferFunction();
            for (int i = 0; i < 14; i++)
            {
                colorTransferFunction.AddRGBPoint(i, colortable[i, 0], colortable[i, 1], colortable[i, 2]);
            }



            // Use the color table to color the histogram window objects
            vtk.vtkImageMapToColors sColors = new vtk.vtkImageMapToColors();
            sColors.SetInputConnection(canvas.GetOutputPort());
            sColors.SetLookupTable(colorTransferFunction);

            // Convert the histogram image to a histogram imagemap
            vtk.vtkImageMapper histmap = new vtk.vtkImageMapper();
            histmap.SetInputConnection(sColors.GetOutputPort());
            histmap.RenderToRectangleOn();
            histmap.SetColorWindow(256);
            histmap.SetColorLevel(127);

            // Create the actor needed to draw the histogram image
            vtk.vtkActor2D imageactor = new vtk.vtkActor2D();
            imageactor.SetMapper(histmap);
            imageactor.SetPosition(0, 0); // Fit the histogram to the window
            imageactor.SetPosition2(1, 1);

            // Add the Histogram Image Render to the window object
            ren1.AddActor(imageactor);
            ren1.SetViewport(0, 0, 1, 1); // Fit the histogram to the window
            renHist.AddRenderer(ren1);

            // Add a Window (mouse) interactor to the window
            iren.SetRenderWindow(renHist);

            // Add mouse events to the window
            iren.RemoveObserver((uint)vtk.EventIds.LeftButtonPressEvent);
            iren.AddObserver((uint)vtk.EventIds.LeftButtonPressEvent, new vtk.vtkDotNetCallback(LeftButtonPress));

            iren.RemoveObserver((uint)vtk.EventIds.LeftButtonReleaseEvent);
            iren.AddObserver((uint)vtk.EventIds.LeftButtonReleaseEvent, new vtk.vtkDotNetCallback(LeftButtonRelease));

            iren.RemoveObserver((uint)vtk.EventIds.MouseMoveEvent);
            iren.AddObserver((uint)vtk.EventIds.MouseMoveEvent, new vtk.vtkDotNetCallback(MouseMove));

            iren.RemoveObserver((uint)vtk.EventIds.RightButtonPressEvent);
            iren.AddObserver((uint)vtk.EventIds.RightButtonPressEvent, new vtk.vtkDotNetCallback(RightButtonPress));

            iren.RemoveObserver((uint)vtk.EventIds.MiddleButtonPressEvent);
            iren.AddObserver((uint)vtk.EventIds.MiddleButtonPressEvent, new vtk.vtkDotNetCallback(MiddleButtonPress));

            // Set the (display) update rate of the histogram
            iren.SetStillUpdateRate(5);
            iren.SetDesiredUpdateRate(5);

            // Initialize interactor and render histogram
            iren.Initialize();
            renHist.Render();

            // Debug output
            info = "Histogram is created \r\n";
        }