// Draw poly data: earth demo
        private void earthToolStripMenuItem_Click(object sender, EventArgs e)
        {
            vtkEarthSource    source = new vtkEarthSource();
            vtkPolyDataMapper map    = vtkPolyDataMapper.New();
            vtkPolyData       poly   = new vtkPolyData();
            vtkActor          actor  = new vtkActor();

            vtkPoints    pts   = new vtkPoints();
            vtkCellArray strip = new vtkCellArray();

            // 定义三个点
            pts.InsertNextPoint(0, 0, 0);
            pts.InsertNextPoint(1, 0, 0);
            pts.InsertNextPoint(1, 1, 0);

            // 定义一个单元
            strip.InsertCellPoint(3);
            strip.InsertNextCell(0);
            strip.InsertNextCell(1);
            strip.InsertNextCell(2);
            // 定义vtkPolyData为点集
            poly.SetPoints(pts);
            poly.SetVerts(strip);// 用SetVerts函数定义点, Verts即Vertices(顶点,Vertex的复数)
            // 定义mapper
            map.SetInput(poly);
            map.SetInput(source.GetOutput());
            actor.SetMapper(map);
            m_Renderer.SetBackground(.5, .5, 1);
            imgPropList.Add(actor);
            m_Renderer.AddActor(actor);
            //Rerender the screen
            m_RenderWindow.Render();
            m_Renderer.Render();
        }
Ejemplo n.º 2
0
Archivo: Part.cs Proyecto: ovevans/STAN
        public void ExtractFeatures()
        {
            Filter = vtkDataSetSurfaceFilter.New();
            Filter.SetInput(Grid);
            Filter.Update();
            Faces = Filter.GetOutput();

            vtkFeatureEdges FeatureEdges = vtkFeatureEdges.New();

            FeatureEdges.SetInput(Filter.GetOutput());
            FeatureEdges.Update();

            FeatureEdges.BoundaryEdgesOn();
            FeatureEdges.FeatureEdgesOn();
            FeatureEdges.ManifoldEdgesOn();
            FeatureEdges.NonManifoldEdgesOn();

            // Change Edge color
            FeatureEdges.SetColoring(0);

            // Update
            FeatureEdges.Update();

            vtkPolyDataMapper EdgeMapper = vtkPolyDataMapper.New();

            EdgeMapper.SetInput(FeatureEdges.GetOutput());
            EdgeMapper.ScalarVisibilityOff();

            Edges.SetMapper(EdgeMapper);
            Edges.GetProperty().SetEdgeColor(0, 0, 0);
            Edges.GetProperty().SetColor(0.0, 0.0, 0.0);
            Edges.GetProperty().SetLineWidth((float)1.0);   // Set default edge thickness
            Edges.SetVisibility(0);
        }
Ejemplo n.º 3
0
        private void renderScene()
        {
            vtkCamera camera;

            if (toShow != null)
            {
                this.geometryPoints();

                vtkPolyData polydata = vtkPolyData.New();
                polydata.SetPoints(pontosVTK);

                vtkDelaunay2D del = vtkDelaunay2D.New();
                del.AddInput(polydata);

                vtkPolyDataMapper mapMesh = vtkPolyDataMapper.New();
                mapMesh.SetInput(del.GetOutput());

                vtkActor meshActor = vtkActor.New();
                meshActor.SetMapper(mapMesh);
                meshActor.GetProperty().SetColor(0.5d, 0.5d, 0d);

                windowVTK.AddRenderer(rendererVTK);
                rendererVTK.AddActor(meshActor);

                windowVTK.Render();
                rendererVTK.Render();

                meshActor.Render(rendererVTK, mapMesh);
                camera = rendererVTK.GetActiveCamera();
                camera.Zoom(1.0d);

                rendererVTK.ResetCamera();
            }
        }
Ejemplo n.º 4
0
        public void ReplacePolyData(vtkPolyData polyData)
        {
            this.PolyData = polyData;

            _polyDataMapper.SetInput(polyData);
            _polyDataMapper.Modified();
        }
Ejemplo n.º 5
0
        public IVtkPreprocess SetMapper()
        {
            polyDataMapper = vtkPolyDataMapper.New();
            polyDataMapper.SetInput(reader.GetOutput());
            polyDataMapper.Update();

            return(this);
        }
Ejemplo n.º 6
0
        static private void init()
        {
            vtkSTLReader rdr = vtkSTLReader.New();

            rdr.SetFileName("BODY-EXTRUDEUR-WADE.stl");



            // Créer une géométrie sphérique

            /*vtkSphereSource sphere = vtkSphereSource.New();
             * sphere.SetRadius(1.0);
             * sphere.SetThetaResolution(18);
             * sphere.SetPhiResolution(18);*/

            // Transforme la géométrie en primitives graphiques (OpenGL dans notre cas)
            vtkPolyDataMapper map = vtkPolyDataMapper.New();

            map.SetInput(rdr.GetOutput());

            // L'acteur représente l'entitée géométrique.
            // Il permet de définir sa position, son orientation, sa couleur, etc.
            vtkActor aSphere = new vtkActor();

            aSphere.SetMapper(map);
            aSphere.GetProperty().SetColor(0.8, 0.8, 0.8); // color blue

            // Nous créons un renderer qui va faire le rendu de notre entitée.
            vtkRenderer ren1 = vtkRenderer.New();

            ren1.AddActor(aSphere);
            ren1.SetBackground(1, 1, 1); // background color white

            // Nous créons une fenêtre de rendu
            vtkRenderWindow renWin = vtkRenderWindow.New();

            renWin.AddRenderer(ren1);
            renWin.SetSize(300, 300);

            // Nous créons un interactor qui permet de bouger la caméra.
            vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();

            iren.SetRenderWindow(renWin);

            // Nous lançons le rendu et l'interaction
            renWin.Render();
            iren.Start();


            ////// CLEANUP ///////
            rdr.Dispose();
            map.Dispose();
            aSphere.Dispose();
            ren1.Dispose();
            renWin.Dispose();
            iren.Dispose();
        }
Ejemplo n.º 7
0
        public XmlPolyDataPackage(string vtpFile, vtkRenderer renderer)
        {
            //Console.WriteLine(string.Format("VTP文件 = {0}", vtpFile));

            if (File.Exists(vtpFile))
            {
                if (vtpFile.EndsWith(".vtp"))
                {
                    //Console.WriteLine(string.Format("VTP文件 = {0}已存在", vtpFile));
                    reader = vtkXMLPolyDataReader.New();
                    reader.SetFileName(vtpFile);
                    reader.Update();

                    PolyData = reader.GetOutput();
                }
                else if (vtpFile.EndsWith(".stl"))
                {
                    PolyData = VTKUtil.ReadSTLPolyData(vtpFile);
                }

                vtkCamera camera = vtkCamera.New();

                var sortPolydata = new vtkDepthSortPolyData();
                sortPolydata.SetInput(PolyData);
                sortPolydata.SetCamera(camera);
                sortPolydata.SetDirectionToFrontToBack();
                sortPolydata.SetVector(1, 1, 1);
                sortPolydata.SetSortScalars(1);
                sortPolydata.Update();

                _polyDataMapper = vtkPolyDataMapper.New();
                _polyDataMapper.ScalarVisibilityOff();
                _polyDataMapper.SetInput(sortPolydata.GetOutput());
                _polyDataMapper.Update();

                actor = vtkActor.New();
                actor.SetMapper(_polyDataMapper);
                actor.GetProperty().SetColor(1, 1, 1);

                //marchingCubeActor.GetProperty().BackfaceCullingOn();
                //marchingCubeActor.GetProperty().FrontfaceCullingOn();
                //marchingCubeActor.GetProperty().BackfaceCullingOff();

                // now, tell the renderer our actors
                renderer.AddActor(actor);

                this.renderer = renderer;
            }
            else
            {
                throw new Exception(string.Format("VTP文件 = {0}不存在。", vtpFile));
            }

            //正面观();
        }
Ejemplo n.º 8
0
        /// <summary>
        /// 进行三维结构的转换
        /// </summary>
        /// <param name="degree"></param>
        /// <param name="polyData"></param>
        /// <param name="info"></param>
        /// <returns></returns>
        private static vtkActor FormActor3D(float degree, vtkPolyData polyData, ModelingBaseInfo info)
        {//旋转拉伸一个截面, 先绕Z拉伸后旋转一定攻角,再平移
            vtkActor actor = vtkActor.New();

            vtkPolyData       polydata = Extrude3DSection(degree, polyData, info);
            vtkPolyDataMapper mapper   = vtkPolyDataMapper.New();

            mapper.SetInput(polyData);
            actor.SetMapper(mapper);
            return(actor);
        }
Ejemplo n.º 9
0
        private void PolyLine()
        {
            // Create five points
            double[,] p = new double[, ] {
                { 0.0, 0.0, 0.0 },
                { 1.0, 0.0, 0.0 },
                { 0.0, 1.0, 0.0 },
                { 0.0, 1.0, 2.0 },
                { 0.0, 3.0, 3.0 }
            };

            // Create the points
            vtkPoints points = vtkPoints.New();

            for (int i = 0; i < 5; i++)
            {
                points.InsertNextPoint(p[i, 0], p[i, 1], p[i, 2]);
            }


            vtkPolyLine polyLine = vtkPolyLine.New();

            polyLine.GetPointIds().SetNumberOfIds(5);
            for (int i = 0; i < 5; i++)
            {
                polyLine.GetPointIds().SetId(i, i);
            }

            // Create a cell array to store the lines in and add the lines to it
            vtkCellArray cells = vtkCellArray.New();

            cells.InsertNextCell(polyLine);

            // Create a polydata to store everything in
            vtkPolyData polyData = vtkPolyData.New();

            // Add the points to the dataset
            polyData.SetPoints(points);

            // Add the lines to the dataset
            polyData.SetLines(cells);
            //Create an actor and mapper
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();

            renderer.SetBackground(0.2, 0.3, 0.4);
            renderer.AddActor(actor);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Crée le nécessaire pour l'affichage du volume
        /// </summary>
        private void createVolumeObjects()
        {
            _volumeMapper = vtkPolyDataMapper.New();
            _volumeMapper.SetInput(_stlReader.GetOutput());
            _volumeActor = vtkActor.New();

            //couleur du volume
            double[] rgb = colorToRGB(VolumeColor);
            _volumeActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]);
            _volumeActor.SetMapper(_volumeMapper);
        }
Ejemplo n.º 11
0
        private void LongLine()
        {
            // Create five points
            double[,] p = new double[, ] {
                { 0.0, 0.0, 0.0 },
                { 1.0, 0.0, 0.0 },
                { 0.0, 1.0, 0.0 },
                { 0.0, 1.0, 2.0 },
                { 1.0, 2.0, 3.0 }
            };

            // Create a vtkPoints object and store the points in it
            vtkPoints points = vtkPoints.New();

            for (int i = 0; i < 5; i++)
            {
                points.InsertNextPoint(p[i, 0], p[i, 1], p[i, 2]);
            }

            // Create a cell array to store the lines in and add the lines to it
            vtkCellArray lines = vtkCellArray.New();

            for (int i = 0; i < 4; i++)
            {
                vtkLine line = vtkLine.New();
                line.GetPointIds().SetId(0, i);
                line.GetPointIds().SetId(1, i + 1);
                lines.InsertNextCell(line);
            }

            // Create a polydata to store everything in
            vtkPolyData linesPolyData = vtkPolyData.New();

            // Add the points to the dataset
            linesPolyData.SetPoints(points);

            // Add the lines to the dataset
            linesPolyData.SetLines(lines);
            // Visualize
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(linesPolyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            actor.GetProperty().SetLineWidth(4);
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();

            renderer.SetBackground(0.2, 0.3, 0.4);
            renderer.AddActor(actor);
            renderer.ResetCamera();
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Crée un acteur pour l'objet fourni et l'ajoute au renderer
        /// </summary>
        /// <param name="polydata"></param>
        private void addActor(vtkPolyData polydata)
        {
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polydata);

            vtkActor act = vtkActor.New();

            act.SetMapper(mapper);

            _renderer.AddActor(act);
        }
Ejemplo n.º 13
0
        //private vtkActor DrawVehicleID(float curX, float ySign)
        //{

        //				// Create text
        //				vtkVectorText textSource = new vtkVectorText();
        //				textSource.SetText("Hello");
        //				textSource.Update();

        //				// Visualize
        //				vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
        //				mapper.SetInputConnection(textSource.GetOutputPort());


        //				vtkActor textActor = vtkActor.New();

        //				textActor.SetScale(Constants.INDICATOR_TEXT_SIZE_X, Constants.INDICATOR_TEXT_SIZE_Y, 1);

        //				double[] bounds = textActor.GetXRange();

        //				Console.WriteLine(bounds[0]);
        //				Console.WriteLine(bounds[1]);

        //				double halfSize = (bounds[1] - bounds[0]) / 2d;

        //				textActor.SetPosition(curX - halfSize, Constants.INDICATOR_LINE_OFFSET * ySign, 0);

        //				textActor.SetMapper(mapper);
        //				textActor.GetProperty().SetColor(1, 0, 0);

        //				return textActor;
        //}

        private vtkActor DrawLineSector(float startX, float yOffset, float size, Color color, float deltaY)
        {
            float topY = yOffset + Constants.TUBE_DEFAULT_HALFSIZE_Y;
            float botY = yOffset - Constants.TUBE_DEFAULT_HALFSIZE_Y;

            if (deltaY > 0)
            {
                topY += deltaY;
            }
            else
            {
                botY += deltaY;
            }

            vtkPoints points = new vtkPoints();

            points.InsertNextPoint(startX, botY, 0.0);
            points.InsertNextPoint(startX + size, botY, 0.0);
            points.InsertNextPoint(startX + size, topY, 0.0);
            points.InsertNextPoint(startX, topY, 0.0);

            vtkPolygon rectangle = new vtkPolygon();

            rectangle.GetPointIds().SetNumberOfIds(4);
            rectangle.GetPointIds().SetId(0, 0);
            rectangle.GetPointIds().SetId(1, 1);
            rectangle.GetPointIds().SetId(2, 2);
            rectangle.GetPointIds().SetId(3, 3);

            vtkCellArray polygons = new vtkCellArray();

            polygons.InsertNextCell(rectangle);

            vtkPolyData polygonPolyData = new vtkPolyData();

            polygonPolyData.SetPoints(points);
            polygonPolyData.SetPolys(polygons);


            // Visualize
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polygonPolyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            actor.GetProperty().SetColor(color.r, color.g, color.b);

            return(actor);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Crée le nécessaire pour l'affichage des  arêtes
        /// </summary>
        private void createEdgeObjects()
        {
            _edgeExtractor = vtkExtractEdges.New();
            _edgeExtractor.SetInput(_stlReader.GetOutput());
            _edgeMapper = vtkPolyDataMapper.New();
            _edgeMapper.SetInput(_edgeExtractor.GetOutput());
            _edgeActor = vtkActor.New();

            double[] rgb = colorToRGB(EdgeColor);

            //couleurs des aretes
            _edgeActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]);
            _edgeActor.SetMapper(_edgeMapper);
        }
Ejemplo n.º 15
0
        private void Point()
        {
            // Create the geometry of the points (the coordinate)
            vtkPoints points = vtkPoints.New();

            double[,] p = new double[, ] {
                { 1.0, 2.0, 3.0 },
                { 3.0, 1.0, 2.0 },
                { 2.0, 3.0, 1.0 }
            };

            // Create topology of the points (a vertex per point)
            vtkCellArray vertices = vtkCellArray.New();
            int          nPts     = 3;

            int[] ids = new int[nPts];
            for (int i = 0; i < nPts; i++)
            {
                ids[i] = points.InsertNextPoint(p[i, 0], p[i, 1], p[i, 2]);
            }

            int    size = Marshal.SizeOf(typeof(int)) * nPts;
            IntPtr pIds = Marshal.AllocHGlobal(size);

            Marshal.Copy(ids, 0, pIds, nPts);
            vertices.InsertNextCell(nPts, pIds);
            Marshal.FreeHGlobal(pIds);

            // Create a polydata object
            vtkPolyData pointPoly = vtkPolyData.New();

            // Set the points and vertices we created as the geometry and topology of the polydata
            pointPoly.SetPoints(points);
            pointPoly.SetVerts(vertices);

            // Visualize
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(pointPoly);

            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            actor.GetProperty().SetPointSize(20);
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();

            renderer.SetBackground(0.3, 0.2, 0.1);
            renderer.AddActor(actor);
        }
Ejemplo n.º 16
0
        private void Quad()
        {
            double[,] p = new double[, ] {
                { 0.0, 0.0, 0.0 },
                { 1.0, 0.0, 0.0 },
                { 1.0, 1.0, 0.0 },
                { 0.0, 1.0, 0.0 }
            };

            // Create the points
            vtkPoints points = vtkPoints.New();

            for (int i = 0; i < 4; i++)
            {
                points.InsertNextPoint(p[i, 0], p[i, 1], p[i, 2]);
            }


            vtkQuad quad = vtkQuad.New();

            quad.GetPointIds().SetNumberOfIds(4);
            for (int i = 0; i < 4; i++)
            {
                quad.GetPointIds().SetId(i, i);
            }

            // Create a cell array to store the quad in and add the quad to it
            vtkCellArray cells = vtkCellArray.New();

            cells.InsertNextCell(quad);

            // Create a polydata to store everything in
            vtkPolyData polyData = vtkPolyData.New();

            // Add the points to the dataset
            polyData.SetPoints(points);

            // Add the quad to the dataset
            polyData.SetPolys(cells);

            //Create an actor and mapper
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);

            RenderAddActor(actor);
        }
Ejemplo n.º 17
0
        private void Polygon()
        {
            // Setup four points
            vtkPoints points = vtkPoints.New();
            double    c      = Math.Cos(Math.PI / 6); // helper variable

            points.InsertNextPoint(0.0, -1.0, 0.0);
            points.InsertNextPoint(c, -0.5, 0.0);
            points.InsertNextPoint(c, 0.5, 0.0);
            points.InsertNextPoint(0.0, 1.0, 0.0);
            points.InsertNextPoint(-c, 0.5, 0.0);
            points.InsertNextPoint(-c, -0.5, 0.0);

            // Create the polygon
            vtkPolygon polygon = vtkPolygon.New();

            polygon.GetPointIds().SetNumberOfIds(6); //make a six-sided figure
            polygon.GetPointIds().SetId(0, 0);
            polygon.GetPointIds().SetId(1, 1);
            polygon.GetPointIds().SetId(2, 2);
            polygon.GetPointIds().SetId(3, 3);
            polygon.GetPointIds().SetId(4, 4);
            polygon.GetPointIds().SetId(5, 5);

            // Add the polygon to a list of polygons
            vtkCellArray polygons = vtkCellArray.New();

            polygons.InsertNextCell(polygon);

            // Create a PolyData
            vtkPolyData polygonPolyData = vtkPolyData.New();

            polygonPolyData.SetPoints(points);
            polygonPolyData.SetPolys(polygons);

            // Create a mapper and actor
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polygonPolyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();

            renderer.SetBackground(0.2, 0.3, 0.4);
            renderer.AddActor(actor);
            renderer.ResetCamera();
        }
Ejemplo n.º 18
0
        private void Frustum()
        {
            // Create a frustum.
            // in this example we need the renderer first to retrieve the active camera
            // in order to get camera's frustum planes
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();
            vtkCamera       camera       = renderer.GetActiveCamera();

            double[] aspect      = renderer.GetAspect();
            double   aspectRatio = aspect[0] / aspect[1];

            // allocate memory for 24 unmanaged doubles
            int    size = Marshal.SizeOf(typeof(double)) * 24;
            IntPtr ptr  = Marshal.AllocHGlobal(size);

            camera.GetFrustumPlanes(aspectRatio, ptr);
            // in case we would need this values directly we could copy
            // the unmanaged double array to a managed array like so:

            // double[] planesArray = new double[24];
            // Marshal.Copy(ptr, planesArray, 0, 24);

            // but fortunately we can forward the IntPtr directly to the function
            // SetFrustumPlanes()
            vtkPlanes planes = vtkPlanes.New();

            planes.SetFrustumPlanes(ptr);
            // free unmanaged memory
            Marshal.FreeHGlobal(ptr);

            vtkFrustumSource frustumSource = vtkFrustumSource.New();

            frustumSource.SetPlanes(planes);
            frustumSource.Update();

            vtkPolyData frustum = frustumSource.GetOutput();
            // Visualize
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(frustum);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);

            renderer.SetBackground(.2, .1, .3); // Background color dark purple
            renderer.AddActor(actor);
            renderer.ResetCamera();
        }
Ejemplo n.º 19
0
        public LinePackage(RendererPackage rendererPackage)
        {
            line = vtkLineSource.New();
            line.SetResolution(100);

            vtkPolyDataMapper sphereMapper = vtkPolyDataMapper.New();

            sphereMapper.SetInput(line.GetOutput());
            _lineActor = vtkActor.New();

            _lineActor.SetMapper(sphereMapper);
            rendererPackage.Renderer.AddActor(_lineActor);

            this._rendererPackage = rendererPackage;
        }
Ejemplo n.º 20
0
        public void BasicVTKBuilderWithoutRunning(ref vtkActor actor, ref vtkPoints points, ref vtkCellArray polys,
                                                  ref vtkFloatArray scalars, ref vtkLookupTable Luk)
        {
            int pointsNum = 0;

            TowerModelInstance.VTKDrawModel(ref points, ref polys, ref scalars, ref pointsNum, paras);

            vtkPolyData profile = vtkPolyData.New();

            profile.SetPoints(points);
            profile.SetPolys(polys);

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            if (paras.RotateAngle == 0)
            {
                profile.GetCellData().SetScalars(scalars);
                mapper.SetInput(profile);
            }
            else
            {
                vtkRotationalExtrusionFilter refilter = vtkRotationalExtrusionFilter.New();
                profile.Update();
                profile.GetCellData().SetScalars(scalars);
                //profile.GetPointData().SetScalars(scalars);
                refilter.SetInput(profile);
                refilter.SetResolution(50);
                refilter.SetAngle(paras.RotateAngle);
                refilter.SetTranslation(0);
                refilter.SetDeltaRadius(0);

                mapper.SetInputConnection(refilter.GetOutputPort());
            }
            mapper.SetScalarRange(0, 5);
            mapper.SetLookupTable(Luk);
            actor.SetMapper(mapper);

            Luk.SetNumberOfTableValues(7);
            Luk.SetTableValue(0, 0, 1, 0, 1);   //
            Luk.SetTableValue(1, 0, 0, 0.8, 1); //inner surface
            Luk.SetTableValue(2, 0, 1, 0, 1);   //
            Luk.SetTableValue(3, 0, 0, 1, 1);
            Luk.SetTableValue(4, 0, 0, 0.8, 1); //insider
            Luk.SetTableValue(5, 0, 0.8, 0, 1); //outer surface
            Luk.Build();
        }
Ejemplo n.º 21
0
        public void SetPosition(double[] xyz1, double[] xyz2)
        {
            vtkPoints points = vtkPoints.New();

            points.InsertPoint(0, xyz1[0], xyz1[1], xyz1[2]);
            points.InsertPoint(1, xyz2[0], xyz2[1], xyz2[2]);

            vtkCellArray lines = vtkCellArray.New();

            lines.InsertNextCell(2);

            lines.InsertCellPoint(0);
            lines.InsertCellPoint(1);

            vtkPolyData profileData = new vtkPolyData();

            profileData.SetPoints(points);
            profileData.SetLines(lines);
            profileData.SetVerts(lines);
            profileData.Update();

            vtkCleanPolyData cleanFilter = new vtkCleanPolyData();

            cleanFilter.SetInput(profileData);
            cleanFilter.Update();

            vtkTubeFilter profileTubes = new vtkTubeFilter();

            profileTubes.SetNumberOfSides(10);
            profileTubes.SetInput(cleanFilter.GetOutput());
            //profileTubes.SetVaryRadiusToVaryRadiusByVector();
            profileTubes.SetRadius(1);
            profileTubes.SetInputArrayToProcess(1, 0, 0, 0, "vectors");

            //vtkPolyDataMapper profileMapper = new vtkPolyDataMapper();
            //profileMapper.SetInputConnection(profileTubes.GetOutputPort());

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(profileTubes.GetOutput());

            centerLineActor.SetMapper(mapper);
            centerLineActor.GetProperty().SetOpacity(0.5);
        }
Ejemplo n.º 22
0
        public static void ShowPolydata(string airwayPath)
        {
            if (!File.Exists(airwayPath))
            {
                MessageBox.Show("文件不存在!");
                return;
            }
            vtkRenderWindow renWin = vtkRenderWindow.New();

            renWin.SetSize(600, 600);

            vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();

            renWin.SetInteractor(iren);

            vtkInteractorStyleTrackballCamera interactorStyle = new vtkInteractorStyleTrackballCamera();

            iren.SetInteractorStyle(interactorStyle);

            vtkRenderer renderer = vtkRenderer.New();

            renderer.GradientBackgroundOn();
            renderer.SetBackground(0, 0, 0);
            renderer.SetBackground2(0, 0, 1);
            renWin.AddRenderer(renderer);
            vtkXMLPolyDataReader reader = new vtkXMLPolyDataReader();

            reader.SetFileName(airwayPath);
            reader.Update();

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.ScalarVisibilityOff();
            mapper.SetInput(reader.GetOutput());
            reader.Dispose();
            vtkActor actor = new vtkActor();

            actor.SetMapper(mapper);

            renderer.AddActor(actor);

            renWin.Render();
        }
Ejemplo n.º 23
0
        private void Triangle()
        {
            // Create a triangle
            vtkPoints points = vtkPoints.New();

            points.InsertNextPoint(1.0, 0.0, 0.0);
            points.InsertNextPoint(0.0, 0.0, 0.0);
            points.InsertNextPoint(0.0, 1.0, 0.0);

            vtkTriangle triangle = vtkTriangle.New();

            triangle.GetPointIds().SetId(0, 0);
            triangle.GetPointIds().SetId(1, 1);
            triangle.GetPointIds().SetId(2, 2);

            // Create a cell array to store the triangle in and add the triangle to it
            vtkCellArray cells = vtkCellArray.New();

            cells.InsertNextCell(triangle);

            // Create a polydata to store everything in
            vtkPolyData polyData = vtkPolyData.New();

            // Add the points to the dataset
            polyData.SetPoints(points);

            // Add the quad to the dataset
            polyData.SetPolys(cells);

            //Create an actor and mapper
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(polyData);
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            vtkRenderer     renderer     = renderWindow.GetRenderers().GetFirstRenderer();

            renderer.SetBackground(0.2, 0.3, 0.4);
            renderer.AddActor(actor);
        }
Ejemplo n.º 24
0
        public XmlPolyDataPackage(vtkPolyData polyData, vtkRenderer renderer)
        {
            this.PolyData   = polyData;
            _polyDataMapper = vtkPolyDataMapper.New();
            _polyDataMapper.ScalarVisibilityOff();
            _polyDataMapper.SetInput(PolyData);
            _polyDataMapper.Update();

            actor = vtkActor.New();
            actor.SetMapper(_polyDataMapper);

            //marchingCubeActor.GetProperty().BackfaceCullingOn();
            //marchingCubeActor.GetProperty().FrontfaceCullingOn();
            //marchingCubeActor.GetProperty().BackfaceCullingOff();

            // now, tell the renderer our actors
            renderer.AddActor(actor);

            this.renderer = renderer;
        }
Ejemplo n.º 25
0
        void ConstructActor(vtkPolyData polydata)
        {
            //vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
            //colors.SetNumberOfComponents(3);

            //Console.WriteLine("pointnum:{0},linenum:{1},numPieces:{2},numstrips:{3}", polydata.GetNumberOfPoints(),polydata .GetNumberOfLines()
            //    ,polydata .GetNumberOfPieces(),polydata .GetNumberOfPolys(),polydata .GetNumberOfStrips());

            //int cellnum = polydata.GetNumberOfCells();
            //colors.SetNumberOfTuples(cellnum);
            //for (int i = 0; i < cellnum; ++i)
            //    colors.SetTuple3(i, m_defaultColor[0], m_defaultColor[1], m_defaultColor[2]);
            //polydata.GetCellData().SetScalars(colors);

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            // mapper.SetScalarModeToUseCellData();
            mapper.SetInput(polydata);
            // float[] color = { 23f, 23f, 100f };
            m_defaultColor = ModelUtils.GetRandomColor01();//获取随机颜色
            SetColor(m_defaultColor);
            this.SetMapper(mapper);
        }
Ejemplo n.º 26
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVmergeFilter(String [] argv)
    {
        //Prefix Content is: ""

          // Create the RenderWindow, Renderer and both Actors[]
          //[]
          ren1 = vtkRenderer.New();
          ren2 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          renWin.AddRenderer((vtkRenderer)ren2);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // create pipeline[]
          //[]
          pl3d = new vtkPLOT3DReader();
          pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
          pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
          pl3d.SetScalarFunctionNumber((int)110);
          pl3d.SetVectorFunctionNumber((int)202);
          pl3d.Update();
          probeLine = new vtkLineSource();
          probeLine.SetPoint1((double)1,(double)1,(double)29);
          probeLine.SetPoint2((double)16.5,(double)5,(double)31.7693);
          probeLine.SetResolution((int)500);
          probe = new vtkProbeFilter();
          probe.SetInputConnection((vtkAlgorithmOutput)probeLine.GetOutputPort());
          probe.SetSource((vtkDataObject)pl3d.GetOutput());
          probeTube = new vtkTubeFilter();
          probeTube.SetInput((vtkDataObject)probe.GetPolyDataOutput());
          probeTube.SetNumberOfSides((int)5);
          probeTube.SetRadius((double).05);
          probeMapper = vtkPolyDataMapper.New();
          probeMapper.SetInputConnection((vtkAlgorithmOutput)probeTube.GetOutputPort());
          probeMapper.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
          (double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
          probeActor = new vtkActor();
          probeActor.SetMapper((vtkMapper)probeMapper);
          displayLine = new vtkLineSource();
          displayLine.SetPoint1((double)0,(double)0,(double)0);
          displayLine.SetPoint2((double)1,(double)0,(double)0);
          displayLine.SetResolution((int)probeLine.GetResolution());
          displayMerge = new vtkMergeFilter();
          displayMerge.SetGeometry((vtkDataSet)displayLine.GetOutput());
          displayMerge.SetScalars((vtkDataSet)probe.GetPolyDataOutput());
          displayWarp = new vtkWarpScalar();
          displayWarp.SetInput((vtkDataObject)displayMerge.GetPolyDataOutput());
          displayWarp.SetNormal((double)0,(double)1,(double)0);
          displayWarp.SetScaleFactor((double).000001);
          displayMapper = vtkPolyDataMapper.New();
          displayMapper.SetInput((vtkPolyData)displayWarp.GetPolyDataOutput());
          displayMapper.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
          (double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
          displayActor = new vtkActor();
          displayActor.SetMapper((vtkMapper)displayMapper);
          outline = new vtkStructuredGridOutlineFilter();
          outline.SetInputConnection((vtkAlgorithmOutput)pl3d.GetOutputPort());
          outlineMapper = vtkPolyDataMapper.New();
          outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
          outlineActor = new vtkActor();
          outlineActor.SetMapper((vtkMapper)outlineMapper);
          outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
          ren1.AddActor((vtkProp)outlineActor);
          ren1.AddActor((vtkProp)probeActor);
          ren1.SetBackground((double)1,(double)1,(double)1);
          ren1.SetViewport((double)0,(double).25,(double)1,(double)1);
          ren2.AddActor((vtkProp)displayActor);
          ren2.SetBackground((double)0,(double)0,(double)0);
          ren2.SetViewport((double)0,(double)0,(double)1,(double).25);
          renWin.SetSize((int)300,(int)300);
          ren1.ResetCamera();
          cam1 = ren1.GetActiveCamera();
          cam1.SetClippingRange((double)3.95297,(double)50);
          cam1.SetFocalPoint((double)8.88908,(double)0.595038,(double)29.3342);
          cam1.SetPosition((double)9.9,(double)-26,(double)41);
          cam1.SetViewUp((double)0.060772,(double)-0.319905,(double)0.945498);
          ren2.ResetCamera();
          cam2 = ren2.GetActiveCamera();
          cam2.ParallelProjectionOn();
          cam2.SetParallelScale((double).15);
          iren.Initialize();
          // render the image[]
          //[]
          // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
Ejemplo n.º 27
0
        static public vtkProp3D genRayActor(List <RayLineCluster> data)
        {
            vtkPoints    points    = vtkPoints.New();
            vtkCellArray pLineCell = vtkCellArray.New();

            vtkLine p1   = vtkLine.New();
            int     cout = 0;

            System.Windows.Forms.MessageBox.Show("cluster.start_radius:" + data.Count.ToString());
            for (int i = 0; i < data.Count; i++)
            {
                RayLineCluster cluster = data[i];
                if (i != data.Count - 1)
                {
                    // 第一个的起点连第二次的起点
                    List <RayLine> rays_start = cluster.ray_cluster;
                    List <RayLine> rays_end   = data[i + 1].ray_cluster;
                    for (int j = 0; j < rays_start.Count; j++)
                    {
                        points.InsertNextPoint(rays_start[j].start_point.x,
                                               rays_start[j].start_point.y, rays_start[j].start_point.z);
                        points.InsertNextPoint(rays_end[j].start_point.x,
                                               rays_end[j].start_point.y, rays_end[j].start_point.z);

                        p1.GetPointIds().SetId(0, cout++);
                        p1.GetPointIds().SetId(1, cout++);
                        pLineCell.InsertNextCell(p1);
                    }
                }
                else
                {
                    foreach (var line in cluster.ray_cluster)
                    {
                        points.InsertNextPoint(line.start_point.x,
                                               line.start_point.y, line.start_point.z);
                        points.InsertNextPoint(
                            line.start_point.x + 0.5 * line.normal_line.x,
                            line.start_point.y + 0.5 * line.normal_line.y,
                            line.start_point.z + 0.5 * line.normal_line.z);
                        p1.GetPointIds().SetId(0, cout++);
                        p1.GetPointIds().SetId(1, cout++);
                        pLineCell.InsertNextCell(p1);
                    }
                }
            }

            vtkPolyData pointsData = vtkPolyData.New();

            pointsData.SetPoints(points); //获得网格模型中的几何数据:点集
            pointsData.SetLines(pLineCell);

            vtkPolyDataMapper pointMapper = vtkPolyDataMapper.New();

            pointMapper.SetInput(pointsData);
            pointMapper.Update();

            vtkActor actor = vtkActor.New();

            actor.SetMapper(pointMapper);
            actor.GetProperty().SetColor(1, 0, 0);
            return(actor);
        }
Ejemplo n.º 28
0
        private void ColoredLines()
        {
            // Create three points. Join (Origin and P0) with a red line and
            // (Origin and P1) with a green line
            double[] origin = new double[] { 0.0, 0.0, 0.0 };
            double[] p0     = new double[] { 1.0, 0.0, 0.0 };
            double[] p1     = new double[] { 0.0, 1.0, 0.0 };

            // Create a vtkPoints object and store the points in it
            vtkPoints pts = vtkPoints.New();

            pts.InsertNextPoint(origin[0], origin[1], origin[2]);
            pts.InsertNextPoint(p0[0], p0[1], p0[2]);
            pts.InsertNextPoint(p1[0], p1[1], p1[2]);

            // Setup two colors - one for each line
            byte[] red   = new byte[] { 255, 0, 0 };
            byte[] green = new byte[] { 0, 255, 0 };

            // Setup the colors array
            vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();

            colors.SetNumberOfComponents(3);
            colors.SetName("Colors");

            // Add the colors we created to the colors array
            colors.InsertNextValue(red[0]);
            colors.InsertNextValue(red[1]);
            colors.InsertNextValue(red[2]);

            colors.InsertNextValue(green[0]);
            colors.InsertNextValue(green[1]);
            colors.InsertNextValue(green[2]);

            // Create the first line (between Origin and P0)
            vtkLine line0 = vtkLine.New();

            line0.GetPointIds().SetId(0, 0); //the second 0 is the index of the Origin in the vtkPoints
            line0.GetPointIds().SetId(1, 1); //the second 1 is the index of P0 in the vtkPoints

            // Create the second line (between Origin and P1)
            vtkLine line1 = vtkLine.New();

            line1.GetPointIds().SetId(0, 0); //the second 0 is the index of the Origin in the vtkPoints
            line1.GetPointIds().SetId(1, 2); //2 is the index of P1 in the vtkPoints

            // Create a cell array to store the lines in and add the lines to it
            vtkCellArray lines = vtkCellArray.New();

            lines.InsertNextCell(line0);
            lines.InsertNextCell(line1);

            // Create a polydata to store everything in
            vtkPolyData linesPolyData = vtkPolyData.New();

            // Add the points to the dataset
            linesPolyData.SetPoints(pts);

            // Add the lines to the dataset
            linesPolyData.SetLines(lines);

            // Color the lines - associate the first component (red) of the
            // colors array with the first component of the cell array (line 0)
            // and the second component (green) of the colors array with the
            // second component of the cell array (line 1)
            linesPolyData.GetCellData().SetScalars(colors);

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            mapper.SetInput(linesPolyData);
            // create an actor
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);

            RenderAddActor(actor);
        }
Ejemplo n.º 29
0
        private void CapClip(string filePath)
        {
            // PolyData to process
            vtkPolyData polyData;

            if (filePath != null)
            {
                vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();
                reader.SetFileName(filePath);
                reader.Update();
                polyData = reader.GetOutput();
            }
            else
            {
                // Create a sphere
                vtkSphereSource sphereSource = vtkSphereSource.New();
                sphereSource.SetThetaResolution(20);
                sphereSource.SetPhiResolution(11);

                vtkPlane plane = vtkPlane.New();
                plane.SetOrigin(0, 0, 0);
                plane.SetNormal(1.0, -1.0, -1.0);

                vtkClipPolyData clipper = vtkClipPolyData.New();
                clipper.SetInputConnection(sphereSource.GetOutputPort());
                clipper.SetClipFunction(plane);
                clipper.SetValue(0);
                clipper.Update();

                polyData = clipper.GetOutput();
            }

            vtkDataSetMapper clipMapper = vtkDataSetMapper.New();

#if VTK_MAJOR_VERSION_5
            clipMapper.SetInput(polyData);
#else
            clipMapper.SetInputData(polyData);
#endif

            vtkActor clipActor = vtkActor.New();
            clipActor.SetMapper(clipMapper);
            clipActor.GetProperty().SetColor(1.0000, 0.3882, 0.2784);
            clipActor.GetProperty().SetInterpolationToFlat();

            // Now extract feature edges
            vtkFeatureEdges boundaryEdges = vtkFeatureEdges.New();
#if VTK_MAJOR_VERSION_5
            boundaryEdges.SetInput(polyData);
#else
            boundaryEdges.SetInputData(polyData);
#endif
            boundaryEdges.BoundaryEdgesOn();
            boundaryEdges.FeatureEdgesOff();
            boundaryEdges.NonManifoldEdgesOff();
            boundaryEdges.ManifoldEdgesOff();

            vtkStripper boundaryStrips = vtkStripper.New();
            boundaryStrips.SetInputConnection(boundaryEdges.GetOutputPort());
            boundaryStrips.Update();

            // Change the polylines into polygons
            vtkPolyData boundaryPoly = vtkPolyData.New();
            boundaryPoly.SetPoints(boundaryStrips.GetOutput().GetPoints());
            boundaryPoly.SetPolys(boundaryStrips.GetOutput().GetLines());

            vtkPolyDataMapper boundaryMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
            boundaryMapper.SetInput(boundaryPoly);
#else
            boundaryMapper.SetInputData(boundaryPoly);
#endif

            vtkActor boundaryActor = vtkActor.New();
            boundaryActor.SetMapper(boundaryMapper);
            boundaryActor.GetProperty().SetColor(0.8900, 0.8100, 0.3400);
            // get a reference to the renderwindow of our renderWindowControl1
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            // renderer
            vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
            // set background color
            renderer.SetBackground(.2, .3, .4);
            // add our actor to the renderer
            renderer.AddActor(clipActor);
            renderer.AddActor(boundaryActor);
            // Generate an interesting view
            //
            renderer.ResetCamera();
            renderer.GetActiveCamera().Azimuth(30);
            renderer.GetActiveCamera().Elevation(30);
            renderer.GetActiveCamera().Dolly(1.2);
            renderer.ResetCameraClippingRange();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVfieldToPolyData(String [] argv)
    {
        //Prefix Content is: ""

          // This example demonstrates the reading of a field and conversion to PolyData[]
          // The output should be the same as polyEx.tcl.[]
          // get the interactor ui[]
          // Create a reader and write out the field[]
          reader = new vtkPolyDataReader();
          reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/polyEx.vtk");
          ds2do = new vtkDataSetToDataObjectFilter();
          ds2do.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          try
          {
         channel = new StreamWriter("PolyField.vtk");
          tryCatchError = "NOERROR";
          }
          catch(Exception)
          {tryCatchError = "ERROR";}

        if(tryCatchError.Equals("NOERROR"))
          {
          channel.Close();
          writer = new vtkDataObjectWriter();
          writer.SetInputConnection((vtkAlgorithmOutput)ds2do.GetOutputPort());
          writer.SetFileName((string)"PolyField.vtk");
          writer.Write();
          // create pipeline[]
          //[]
          dor = new vtkDataObjectReader();
          dor.SetFileName((string)"PolyField.vtk");
          do2ds = new vtkDataObjectToDataSetFilter();
          do2ds.SetInputConnection((vtkAlgorithmOutput)dor.GetOutputPort());
          do2ds.SetDataSetTypeToPolyData();
          do2ds.SetPointComponent((int)0,(string)"Points",(int)0);
          do2ds.SetPointComponent((int)1,(string)"Points",(int)1);
          do2ds.SetPointComponent((int)2,(string)"Points",(int)2);
          do2ds.SetPolysComponent((string)"Polys",(int)0);
          fd2ad = new vtkFieldDataToAttributeDataFilter();
          fd2ad.SetInput((vtkDataObject)do2ds.GetPolyDataOutput());
          fd2ad.SetInputFieldToDataObjectField();
          fd2ad.SetOutputAttributeDataToPointData();
          fd2ad.SetScalarComponent((int)0,(string)"my_scalars",(int)0);
          mapper = vtkPolyDataMapper.New();
          mapper.SetInput((vtkPolyData)fd2ad.GetPolyDataOutput());
          mapper.SetScalarRange((double)((vtkDataSet)fd2ad.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)fd2ad.GetOutput()).GetScalarRange()[1]);
          actor = new vtkActor();
          actor.SetMapper((vtkMapper)mapper);
          // Create the RenderWindow, Renderer and both Actors[]
          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          ren1.AddActor((vtkProp)actor);
          ren1.SetBackground((double)1,(double)1,(double)1);
          renWin.SetSize((int)300,(int)300);
          ren1.ResetCamera();
          cam1 = ren1.GetActiveCamera();
          cam1.SetClippingRange((double).348,(double)17.43);
          cam1.SetPosition((double)2.92,(double)2.62,(double)-0.836);
          cam1.SetViewUp((double)-0.436,(double)-0.067,(double)-0.897);
          cam1.Azimuth((double)90);
          // render the image[]
          //[]
          renWin.Render();
          File.Delete("PolyField.vtk");

        }

          // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
Ejemplo n.º 31
0
        //Parameters for building a model

        private void BasicVTKBuilder(ref vtkActor actor, ref vtkPoints points, ref vtkCellArray polys,
                                     ref vtkFloatArray scalars, ref vtkLookupTable Luk, ref vtkActor2D actor2D)
        {
            int pointsNum = 0;

            TowerModelInstance.VTKDrawModel(ref points, ref polys, ref scalars, ref pointsNum, paras);

            vtkPolyData profile = vtkPolyData.New();

            profile.SetPoints(points);
            profile.SetPolys(polys);

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            if (paras.RotateAngle == 0)
            {
                profile.GetCellData().SetScalars(scalars);
                mapper.SetInput(profile);
            }
            else
            {
                vtkRotationalExtrusionFilter refilter = vtkRotationalExtrusionFilter.New();
                profile.Update();
                profile.GetCellData().SetScalars(scalars);
                //profile.GetPointData().SetScalars(scalars);
                refilter.SetInput(profile);
                refilter.SetResolution(50);
                refilter.SetAngle(paras.RotateAngle);
                refilter.SetTranslation(0);
                refilter.SetDeltaRadius(0);

                mapper.SetInputConnection(refilter.GetOutputPort());
            }

            mapper.SetScalarRange(TowerModelInstance.GetColorGenColorTableMinvalue(),
                                  TowerModelInstance.GetColorGenColorTableMaxValue());
            actor.SetMapper(mapper);

            // This text property is for scalarBar
            vtkTextProperty textProperty = vtkTextProperty.New();

            //textProperty.SetFontFamilyToCourier();
            //textProperty.SetColor(1.0, 1.0, 0.5);
            textProperty.SetFontSize(10);

            vtkScalarBarActor scalarBar = vtkScalarBarActor.New();

            scalarBar.SetLookupTable(mapper.GetLookupTable());
            scalarBar.SetTitle("Color Table");
            scalarBar.SetNumberOfLabels(TowerModelInstance.GetColorGenColorTableSize());
            scalarBar.SetTitleTextProperty(textProperty);
            scalarBar.SetLabelTextProperty(textProperty);
            scalarBar.SetWidth(0.07);
            scalarBar.SetHeight(0.6);
            //scalarBar.SetDrawFrame(1);

            vtkLookupTable hueLut = vtkLookupTable.New();

            hueLut.SetTableRange(TowerModelInstance.GetColorGenColorTableMinvalue(),
                                 TowerModelInstance.GetColorGenColorTableMaxValue());
            hueLut.SetHueRange(0.667, 0);
            hueLut.SetSaturationRange(1, 1);
            hueLut.SetValueRange(1, 1);
            hueLut.SetNumberOfTableValues(TowerModelInstance.GetColorGenColorTableSize());
            hueLut.Build();

            mapper.SetLookupTable(hueLut);
            scalarBar.SetLookupTable(hueLut);

            // The actor links the data pipeline to the rendering subsystem
            actor2D = scalarBar;
            //actor.GetProperty().SetColor(0.388, 0.388, 0.388);
        }
Ejemplo n.º 32
0
        static void Main(string[] args)
        {
            //
            // 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.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.
            //
            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.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
            //
            vtkRenderWindow renWin = new vtkRenderWindow();
            renWin.AddRenderer( ren1 );
            renWin.SetSize( 300, 300 );

            vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
            iren.SetRenderWindow(renWin);

            vtkInteractorStyleTrackballCamera style =
                new vtkInteractorStyleTrackballCamera();
            iren.SetInteractorStyle(style);

            vtkBoxWidget boxWidget = new vtkBoxWidget();
            boxWidget.SetInteractor(iren);
            boxWidget.SetPlaceFactor(1.25f);

            boxWidget.SetProp3D(coneActor);
            boxWidget.PlaceWidget();

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

            boxWidget.On();

            iren.Initialize();
            iren.Start();

            vtkWin32OpenGLRenderWindow win32win =
                vtkWin32OpenGLRenderWindow.SafeDownCast(renWin);
            if ( null != win32win ) win32win.Clean();
        }
        //切片模式_绘制
        private void DrawMode_Slice()
        {
            int[]    xyz = m_ImageData.GetDimensions();
            double[] sp  = m_ImageData.GetSpacing();

            double[] pos = new double[] { m_XPos, m_YPos, m_ZPos };

            #region -------------------XOY切片(垂直Z轴)-------------------

            m_ImageResliceXOY = vtkImageReslice.New();
            m_ImageResliceXOY.SetInput(m_ImageData);
            m_ImageResliceXOY.SetResliceAxesDirectionCosines(
                1, 0, 0,
                0, 1, 0,
                0, 0, 1
                );
            m_ImageResliceXOY.InterpolateOn();
            m_ImageResliceXOY.SetInterpolationModeToNearestNeighbor();
            m_ImageResliceXOY.SetResliceAxesOrigin(pos[0], pos[1], pos[2]);
            m_ImageResliceXOY.SetOutputDimensionality(2);
            m_ImageResliceXOY.Update();

            m_TextureXOY = vtkTexture.New();
            m_TextureXOY.InterpolateOff();
            m_TextureXOY.SetInput(m_ImageResliceXOY.GetOutput());
            m_TextureXOY.SetLookupTable(m_LookupTable);
            m_TextureXOY.MapColorScalarsThroughLookupTableOn();

            //---------------------set plane position----------
            m_PlaneSourceXOY = vtkPlaneSource.New();
            m_PlaneSourceXOY.SetXResolution(xyz[0]);
            m_PlaneSourceXOY.SetYResolution(xyz[1]);
            m_PlaneSourceXOY.SetOrigin(0, 0, 0);
            m_PlaneSourceXOY.SetPoint1((xyz[0] - 1) * sp[0], 0, 0);
            m_PlaneSourceXOY.SetPoint2(0, (xyz[1] - 1) * sp[1], 0);
            m_PlaneSourceXOY.Push(pos[2]);

            //---------------------pipeline--------------------
            m_PlaneMapperXOY = vtkPolyDataMapper.New();
            m_PlaneMapperXOY.SetInput(m_PlaneSourceXOY.GetOutput());

            m_ActorXOY = vtkActor.New();
            m_ActorXOY.SetMapper(m_PlaneMapperXOY);
            m_ActorXOY.SetTexture(m_TextureXOY);

            #endregion

            #region -------------------XOZ切片(垂直Y轴)-------------------

            m_ImageResliceXOZ = vtkImageReslice.New();
            m_ImageResliceXOZ.SetInput(m_ImageData);
            m_ImageResliceXOZ.SetResliceAxesDirectionCosines(
                1, 0, 0,
                0, 0, -1,
                0, 1, 0
                );
            m_ImageResliceXOZ.InterpolateOn();
            m_ImageResliceXOZ.SetInterpolationModeToNearestNeighbor();
            m_ImageResliceXOZ.SetResliceAxesOrigin(pos[0], pos[1], pos[2]);
            m_ImageResliceXOZ.SetOutputDimensionality(2);
            m_ImageResliceXOZ.Update();

            m_TextureXOZ = vtkTexture.New();
            m_TextureXOZ.SetInput(m_ImageResliceXOZ.GetOutput());
            m_TextureXOZ.SetLookupTable(m_LookupTable);
            m_TextureXOZ.MapColorScalarsThroughLookupTableOn();

            //---------------------set plane position--------------------
            m_PlaneSourceXOZ = vtkPlaneSource.New();
            m_PlaneSourceXOZ.SetXResolution(xyz[0]);
            m_PlaneSourceXOZ.SetYResolution(xyz[2]);
            m_PlaneSourceXOZ.SetOrigin(0, 0, (xyz[2] - 1) * sp[2]);
            m_PlaneSourceXOZ.SetPoint1((xyz[0] - 1) * sp[0], 0, (xyz[2] - 1) * sp[2]);
            m_PlaneSourceXOZ.SetPoint2(0, 0, 0);
            m_PlaneSourceXOZ.Push(pos[1]);

            //---------------------pipeline------------------------------
            m_PlaneMapperXOZ = vtkPolyDataMapper.New();
            m_PlaneMapperXOZ.SetInput(m_PlaneSourceXOZ.GetOutput());

            m_ActorXOZ = vtkActor.New();
            m_ActorXOZ.SetMapper(m_PlaneMapperXOZ);
            m_ActorXOZ.SetTexture(m_TextureXOZ);

            #endregion

            #region -------------------YOZ切片(垂直X轴)-------------------

            m_ImageResliceYOZ = vtkImageReslice.New();
            m_ImageResliceYOZ.SetInput(m_ImageData);
            m_ImageResliceYOZ.SetResliceAxesDirectionCosines(
                0, 0, -1,
                0, 1, 0,
                1, 0, 0
                );
            m_ImageResliceYOZ.InterpolateOn();
            m_ImageResliceYOZ.SetInterpolationModeToNearestNeighbor();
            m_ImageResliceYOZ.SetResliceAxesOrigin(pos[0], pos[1], pos[2]);
            m_ImageResliceYOZ.SetOutputDimensionality(2);
            m_ImageResliceYOZ.Update();

            m_TextureYOZ = vtkTexture.New();
            m_TextureYOZ.SetInput(m_ImageResliceYOZ.GetOutput());
            m_TextureYOZ.SetLookupTable(m_LookupTable);
            m_TextureYOZ.MapColorScalarsThroughLookupTableOn();

            //---------------------set plane position--------------------
            m_PlaneSourceYOZ = vtkPlaneSource.New();
            m_PlaneSourceYOZ.SetXResolution(xyz[2]);
            m_PlaneSourceYOZ.SetYResolution(xyz[1]);
            m_PlaneSourceYOZ.SetOrigin(0, 0, (xyz[2] - 1) * sp[2]);
            m_PlaneSourceYOZ.SetPoint1(0, 0, 0);
            m_PlaneSourceYOZ.SetPoint2(0, (xyz[1] - 1) * sp[1], (xyz[2] - 1) * sp[2]);
            m_PlaneSourceYOZ.Push(pos[0]);

            //---------------------pipeline------------------------------
            m_PlaneMapperYOZ = vtkPolyDataMapper.New();
            m_PlaneMapperYOZ.SetInput(m_PlaneSourceYOZ.GetOutput());

            m_ActorYOZ = vtkActor.New();
            m_ActorYOZ.SetMapper(m_PlaneMapperYOZ);
            m_ActorYOZ.SetTexture(m_TextureYOZ);

            #endregion

            m_Renderer.AddActor(m_ActorXOY);
            m_Renderer.AddActor(m_ActorXOZ);
            m_Renderer.AddActor(m_ActorYOZ);
        }