Example #1
0
File: Form1.cs Project: Bundzu/TOM
        // wyświetlenie stożka i jego zapis
        private void buttonSave_Click(object sender, EventArgs e)
        {
            vtkConeSource coneSource = vtkConeSource.New();
            coneSource.SetResolution(30);

            vtkPolyDataNormals phongFilter = vtkPolyDataNormals.New();          // jeżeli chcemy olać wyświetlanie stożka i od razu go zapisać można zakomentować od tej linii
            phongFilter.SetInputConnection(coneSource.GetOutputPort());             // tutaj jest filtr do stożka

            vtkPolyDataMapper coneMapper = vtkPolyDataMapper.New();
            coneMapper.SetInputConnection(phongFilter.GetOutputPort());             //mapper musi wskazywać na filtr

            this.coneActor = vtkActor.New();
            this.coneActor.SetMapper(coneMapper);

            vtkRenderWindow renWin = this.renderWindowControl1.RenderWindow;
            vtkRenderer renderer = renWin.GetRenderers().GetFirstRenderer();
            renderer.AddActor(coneActor);

            this.renderWindowControl1.Refresh();                                // do tej. Stożek zostanie zapisany bez wyświetlania

            vtkSTLWriter stlWriter = vtkSTLWriter.New();
            stlWriter.SetInputConnection(coneSource.GetOutputPort());
            stlWriter.SetFileName("C:\\Users\\Killy\\stozek.stl");              // 2 sposób zapisywania (lewe ukośniki \), nie jest możliwe proste skopiowanie i wklejenie ścieżki dostępu
            stlWriter.SetFileTypeToASCII();                                     // zapisujemy to jako zwykły plik.
            stlWriter.Write();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVEnSightOfficeBin(String [] argv)
    {
        //Prefix Content is: ""

          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // read data[]
          //[]
          reader = new vtkGenericEnSightReader();
          // Make sure all algorithms use the composite data pipeline[]
          cdp = new vtkCompositeDataPipeline();
          vtkGenericEnSightReader.SetDefaultExecutivePrototype((vtkExecutive)cdp);
          reader.SetCaseFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/EnSight/office_bin.case");
          reader.Update();
          // to add coverage for vtkOnePieceExtentTranslator[]
          translator = new vtkOnePieceExtentTranslator();
          vtkStreamingDemandDrivenPipeline.SetExtentTranslator(reader.GetOutputInformation(0), (vtkExtentTranslator)translator);
          outline = new vtkStructuredGridOutlineFilter();
          //    outline SetInputConnection [reader GetOutputPort][]
          outline.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
          mapOutline = vtkPolyDataMapper.New();
          mapOutline.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
          outlineActor = new vtkActor();
          outlineActor.SetMapper((vtkMapper)mapOutline);
          outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
          // Create source for streamtubes[]
          streamer = new vtkStreamPoints();
          //    streamer SetInputConnection [reader GetOutputPort][]
          streamer.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
          streamer.SetStartPosition((double)0.1,(double)2.1,(double)0.5);
          streamer.SetMaximumPropagationTime((double)500);
          streamer.SetTimeIncrement((double)0.5);
          streamer.SetIntegrationDirectionToForward();
          cone = new vtkConeSource();
          cone.SetResolution((int)8);
          cones = new vtkGlyph3D();
          cones.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
          cones.SetSourceConnection(cone.GetOutputPort());
          cones.SetScaleFactor((double)0.9);
          cones.SetScaleModeToScaleByVector();
          mapCones = vtkPolyDataMapper.New();
          mapCones.SetInputConnection((vtkAlgorithmOutput)cones.GetOutputPort());
          //    eval mapCones SetScalarRange [[reader GetOutput] GetScalarRange][]
          mapCones.SetScalarRange((double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetScalarRange()[0],
          (double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetScalarRange()[1]);
          conesActor = new vtkActor();
          conesActor.SetMapper((vtkMapper)mapCones);
          ren1.AddActor((vtkProp)outlineActor);
          ren1.AddActor((vtkProp)conesActor);
          ren1.SetBackground((double)0.4,(double)0.4,(double)0.5);
          renWin.SetSize((int)300,(int)300);
          iren.Initialize();
          // interact with data[]
          vtkGenericEnSightReader.SetDefaultExecutivePrototype(null);

        //deleteAllVTKObjects();
    }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestExtrudePiece(String [] argv)
    {
        //Prefix Content is: ""

          disk = new vtkDiskSource();
          disk.SetRadialResolution((int)2);
          disk.SetCircumferentialResolution((int)9);
          clean = new vtkCleanPolyData();
          clean.SetInputConnection((vtkAlgorithmOutput)disk.GetOutputPort());
          clean.SetTolerance((double)0.01);
          piece = new vtkExtractPolyDataPiece();
          piece.SetInputConnection((vtkAlgorithmOutput)clean.GetOutputPort());
          extrude = new vtkPLinearExtrusionFilter();
          extrude.SetInputConnection((vtkAlgorithmOutput)piece.GetOutputPort());
          extrude.PieceInvariantOn();
          // Create the RenderWindow, Renderer and both Actors[]
          //[]
          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          mapper = vtkPolyDataMapper.New();
          mapper.SetInputConnection((vtkAlgorithmOutput)extrude.GetOutputPort());
          mapper.SetNumberOfPieces((int)2);
          mapper.SetPiece((int)1);
          bf = new vtkProperty();
          bf.SetColor((double)1,(double)0,(double)0);
          actor = new vtkActor();
          actor.SetMapper((vtkMapper)mapper);
          actor.GetProperty().SetColor((double)1,(double)1,(double)0.8);
          actor.SetBackfaceProperty((vtkProperty)bf);
          // Add the actors to the renderer, set the background and size[]
          //[]
          ren1.AddActor((vtkProp)actor);
          ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
          renWin.SetSize((int)300,(int)300);
          // render the image[]
          //[]
          cam1 = ren1.GetActiveCamera();
          cam1.Azimuth((double)20);
          cam1.Elevation((double)40);
          ren1.ResetCamera();
          cam1.Zoom((double)1.2);
          iren.Initialize();
          // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
Example #4
0
File: Form1.cs Project: Bundzu/TOM
        private void buttonCreateCone_Click(object sender, EventArgs e)
        {
            vtkConeSource coneSource = vtkConeSource.New();
            vtkPolyDataMapper coneMapper = vtkPolyDataMapper.New();
            coneMapper.SetInputConnection(coneSource.GetOutputPort());

            this.coneActor = vtkActor.New();
            this.coneActor.SetMapper(coneMapper);

            vtkRenderWindow renWin = this.renderWindowControl1.RenderWindow;
            vtkRenderer renderer = renWin.GetRenderers().GetFirstRenderer();
            renderer.AddActor(coneActor);

            this.renderWindowControl1.Refresh();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestExtractVOI(String [] argv)
    {
        //Prefix Content is: ""

          // to mark the origin[]
          sphere = new vtkSphereSource();
          sphere.SetRadius((double)2.0);
          sphereMapper = vtkPolyDataMapper.New();
          sphereMapper.SetInputConnection((vtkAlgorithmOutput)sphere.GetOutputPort());
          sphereMapper.ImmediateModeRenderingOn();
          sphereActor = new vtkActor();
          sphereActor.SetMapper((vtkMapper)sphereMapper);
          rt = new vtkRTAnalyticSource();
          rt.SetWholeExtent((int)-50,(int)50,(int)-50,(int)50,(int)0,(int)0);
          voi = new vtkExtractVOI();
          voi.SetInputConnection((vtkAlgorithmOutput)rt.GetOutputPort());
          voi.SetVOI((int)-11,(int)39,(int)5,(int)45,(int)0,(int)0);
          voi.SetSampleRate((int)5,(int)5,(int)1);
          // Get rid ambiguous triagulation issues.[]
          surf = new vtkDataSetSurfaceFilter();
          surf.SetInputConnection((vtkAlgorithmOutput)voi.GetOutputPort());
          tris = new vtkTriangleFilter();
          tris.SetInputConnection((vtkAlgorithmOutput)surf.GetOutputPort());
          mapper = vtkPolyDataMapper.New();
          mapper.SetInputConnection((vtkAlgorithmOutput)tris.GetOutputPort());
          mapper.ImmediateModeRenderingOn();
          mapper.SetScalarRange((double)130,(double)280);
          actor = new vtkActor();
          actor.SetMapper((vtkMapper)mapper);
          ren = vtkRenderer.New();
          ren.AddActor((vtkProp)actor);
          ren.AddActor((vtkProp)sphereActor);
          ren.ResetCamera();
          camera = ren.GetActiveCamera();
          //$camera SetPosition 68.1939 -23.4323 12.6465[]
          //$camera SetViewUp 0.46563 0.882375 0.0678508  []
          //$camera SetFocalPoint 3.65707 11.4552 1.83509 []
          //$camera SetClippingRange 59.2626 101.825 []
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          iren.Initialize();

        //deleteAllVTKObjects();
    }
Example #6
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVRectOutline(String [] argv)
    {
        //Prefix Content is: ""

          // create pipeline[]
          //[]
          reader = new vtkDataSetReader();
          reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/RectGrid2.vtk");
          reader.Update();
          // here to force exact extent[]
          elev = new vtkElevationFilter();
          elev.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          outline = new vtkRectilinearGridOutlineFilter();
          outline.SetInput((vtkDataObject)elev.GetRectilinearGridOutput());
          outlineMapper = vtkPolyDataMapper.New();
          outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
          outlineMapper.SetNumberOfPieces((int)2);
          outlineMapper.SetPiece((int)1);
          outlineActor = new vtkActor();
          outlineActor.SetMapper((vtkMapper)outlineMapper);
          outlineActor.GetProperty().SetColor((double) 0.0000, 0.0000, 0.0000 );
          // Graphics stuff[]
          // Create the RenderWindow, Renderer and both Actors[]
          //[]
          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // Add the actors to the renderer, set the background and size[]
          //[]
          ren1.AddActor((vtkProp)outlineActor);
          ren1.SetBackground((double)1,(double)1,(double)1);
          renWin.SetSize((int)400,(int)400);
          cam1 = ren1.GetActiveCamera();
          cam1.SetClippingRange((double)3.76213,(double)10.712);
          cam1.SetFocalPoint((double)-0.0842503,(double)-0.136905,(double)0.610234);
          cam1.SetPosition((double)2.53813,(double)2.2678,(double)-5.22172);
          cam1.SetViewUp((double)-0.241047,(double)0.930635,(double)0.275343);
          iren.Initialize();
          // render the image[]
          //[]
          // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
    // Static void method with same signature as "Main" is always
    // file base name:
    //
    /// <summary>
    /// VTK test Main method
    /// </summary>
    public static void vtkConeSourceTest(string[] args)
    {
        bool interactive = false;
        foreach (string s in args)
        {
          // -I means "interactive" test -- do not automatically quit:
          //
          if (s == "-I")
          {
        interactive = true;
          }
        }

        vtkConeSource source = new vtkConeSource();

        vtkMapper mapper = vtkPolyDataMapper.New();
        mapper.SetInputConnection(source.GetOutputPort());

        vtkActor actor = new vtkActor();
        actor.SetMapper(mapper);

        vtkRenderer ren1 = vtkRenderer.New();
        ren1.AddActor(actor);
        ren1.SetBackground(0.1, 0.2, 0.4);

        vtkRenderWindow renWin = vtkRenderWindow.New();
        renWin.AddRenderer(ren1);
        renWin.SetSize(400, 300);

        vtkRenderWindowInteractor iren = vtkRenderWindowInteractor.New();
        iren.SetRenderWindow(renWin);
        iren.Initialize();

        Kitware.mummy.Runtime.Methods.Print(false);
        Kitware.mummy.Runtime.Methods.PrintWrappedObjectsTable();

        if (interactive)
        {
          iren.Start();
        }

        ren1.SetRenderWindow(null);
        iren.SetRenderWindow(null);

        renWin.Dispose();
    }
Example #8
0
File: Form1.cs Project: Bundzu/TOM
        // wczytujemy plik vtk i go wyświetlamy
        private void buttonLoadvtk_Click(object sender, EventArgs e)
        {
            vtkPolyDataReader cylinderReader = vtkPolyDataReader.New();
            cylinderReader.SetFileName(@"C:\Users\Killy\cylinder.vtk");

            vtkPolyDataMapper cylinderMapper = vtkPolyDataMapper.New();
            cylinderMapper.SetInputConnection(cylinderReader.GetOutputPort());

            cylinderActor = vtkActor.New();
            cylinderActor.SetMapper(cylinderMapper);

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

            renderer.AddActor(cylinderActor);

            this.renderWindowControl1.Refresh();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestUnstructuredPieces(String [] argv)
    {
        //Prefix Content is: ""

          math = new vtkMath();
          vtkMath.RandomSeed((int)22);
          pf = new vtkParallelFactory();
          vtkParallelFactory.RegisterFactory((vtkObjectFactory)pf);
          pl3d = new vtkMultiBlockPLOT3DReader();
          pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
          pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
          pl3d.SetScalarFunctionNumber((int)100);
          dst = new vtkDataSetTriangleFilter();
          dst.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
          extract = new vtkExtractUnstructuredGridPiece();
          extract.SetInputConnection((vtkAlgorithmOutput)dst.GetOutputPort());
          cf = new vtkContourFilter();
          cf.SetInputConnection((vtkAlgorithmOutput)extract.GetOutputPort());
          cf.SetValue((int)0,(double)0.24);
          pdn = new vtkPolyDataNormals();
          pdn.SetInputConnection((vtkAlgorithmOutput)cf.GetOutputPort());
          ps = new vtkPieceScalars();
          ps.SetInputConnection((vtkAlgorithmOutput)pdn.GetOutputPort());
          mapper = vtkPolyDataMapper.New();
          mapper.SetInputConnection((vtkAlgorithmOutput)ps.GetOutputPort());
          mapper.SetNumberOfPieces((int)3);
          actor = new vtkActor();
          actor.SetMapper((vtkMapper)mapper);
          ren = vtkRenderer.New();
          ren.AddActor((vtkProp)actor);
          ren.ResetCamera();
          camera = ren.GetActiveCamera();
          //$camera SetPosition 68.1939 -23.4323 12.6465[]
          //$camera SetViewUp 0.46563 0.882375 0.0678508  []
          //$camera SetFocalPoint 3.65707 11.4552 1.83509 []
          //$camera SetClippingRange 59.2626 101.825 []
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          iren.Initialize();

        //deleteAllVTKObjects();
    }
Example #10
0
        ///<summary>Entry Point</summary>
        static void Main(string[] args)
        {
            // Create a simple sphere. A pipeline is created.
            sphere = vtkSphereSource.New();
            sphere.SetThetaResolution(8);
            sphere.SetPhiResolution(16);

            shrink = vtkShrinkPolyData.New();
            shrink.SetInputConnection(sphere.GetOutputPort());
            shrink.SetShrinkFactor(0.9);

            mapper = vtkPolyDataMapper.New();
            mapper.SetInputConnection(shrink.GetOutputPort());

            // The actor links the data pipeline to the rendering subsystem
            actor = vtkActor.New();
            actor.SetMapper(mapper);
            actor.GetProperty().SetColor(1, 0, 0);

            // Create components of the rendering subsystem
            //
            ren1 = vtkRenderer.New();
            renWin = vtkRenderWindow.New();
            renWin.AddRenderer(ren1);
            iren = vtkRenderWindowInteractor.New();
            iren.SetRenderWindow(renWin);

            // Add the actors to the renderer, set the window size
            //
            ren1.AddViewProp(actor);
            renWin.SetSize(250, 250);
            renWin.Render();
            camera = ren1.GetActiveCamera();
            camera.Zoom(1.5);

            // render the image and start the event loop
            //
            renWin.Render();

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

            deleteAllVTKObjects();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestSpherePuzzle(String [] argv)
    {
        //Prefix Content is: ""

          // prevent the tk window from showing up then start the event loop[]
          renWin = vtkRenderWindow.New();
          // create a rendering window and renderer[]
          ren1 = vtkRenderer.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          renWin.SetSize((int)400,(int)400);
          puzzle = new vtkSpherePuzzle();
          mapper = vtkPolyDataMapper.New();
          mapper.SetInputConnection((vtkAlgorithmOutput)puzzle.GetOutputPort());
          actor = new vtkActor();
          actor.SetMapper((vtkMapper)mapper);
          arrows = new vtkSpherePuzzleArrows();
          mapper2 = vtkPolyDataMapper.New();
          mapper2.SetInputConnection((vtkAlgorithmOutput)arrows.GetOutputPort());
          actor2 = new vtkActor();
          actor2.SetMapper((vtkMapper)mapper2);
          // Add the actors to the renderer, set the background and size[]
          //[]
          ren1.AddActor((vtkProp)actor);
          ren1.AddActor((vtkProp)actor2);
          ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
          LastVal = -1;
          //method moved
          //method moved
          renWin.Render();
          cam = ren1.GetActiveCamera();
          cam.Elevation((double)-40);
          puzzle.MoveHorizontal((int)0,(int)100,(int)0);
          puzzle.MoveHorizontal((int)1,(int)100,(int)1);
          puzzle.MoveHorizontal((int)2,(int)100,(int)0);
          puzzle.MoveVertical((int)2,(int)100,(int)0);
          puzzle.MoveVertical((int)1,(int)100,(int)0);
          renWin.Render();

        //deleteAllVTKObjects();
    }
Example #12
0
		private void CreateSurfaceRendering()
		{
			_contourFilter = new vtk.vtkContourFilter();
			_contourFilter.SetInput(_volumeGraphic.GetImageData());
			_contourFilter.SetValue(0, _volumeGraphic.GetRescaledLevel());

			vtkPolyDataNormals normals = new vtk.vtkPolyDataNormals();
			normals.SetInputConnection(_contourFilter.GetOutputPort());
			normals.SetFeatureAngle(60.0);

			vtkStripper stripper = new vtk.vtkStripper();
			stripper.SetInputConnection(normals.GetOutputPort());

			vtkPolyDataMapper mapper = new vtk.vtkPolyDataMapper();
			mapper.SetInputConnection(stripper.GetOutputPort());
			mapper.ScalarVisibilityOff();

			_vtkActor = new vtk.vtkActor();
			_vtkActor.SetMapper(mapper);
			_vtkActor.GetProperty().SetSpecular(.3);
			_vtkActor.GetProperty().SetSpecularPower(20);
			ApplySetting("Opacity");
			ApplySetting("Level");
		}
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVofficeStreamPoints(String [] argv)
    {
        //Prefix Content is: ""

          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // read data[]
          //[]
          reader = new vtkStructuredGridReader();
          reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/office.binary.vtk");
          reader.Update();
          //force a read to occur[]
          // to add coverage for vtkOnePieceExtentTranslator[]
          translator = new vtkOnePieceExtentTranslator();
          vtkStreamingDemandDrivenPipeline.SetExtentTranslator(reader.GetOutputInformation(0), (vtkExtentTranslator)translator);
          length = reader.GetOutput().GetLength();
          maxVelocity = reader.GetOutput().GetPointData().GetVectors().GetMaxNorm();
          maxTime = 35.0*length/maxVelocity;
          table1 = new vtkStructuredGridGeometryFilter();
          table1.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          table1.SetExtent((int)11,(int)15,(int)7,(int)9,(int)8,(int)8);
          mapTable1 = vtkPolyDataMapper.New();
          mapTable1.SetInputConnection((vtkAlgorithmOutput)table1.GetOutputPort());
          mapTable1.ScalarVisibilityOff();
          table1Actor = new vtkActor();
          table1Actor.SetMapper((vtkMapper)mapTable1);
          table1Actor.GetProperty().SetColor((double).59,(double).427,(double).392);
          table2 = new vtkStructuredGridGeometryFilter();
          table2.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          table2.SetExtent((int)11,(int)15,(int)10,(int)12,(int)8,(int)8);
          mapTable2 = vtkPolyDataMapper.New();
          mapTable2.SetInputConnection((vtkAlgorithmOutput)table2.GetOutputPort());
          mapTable2.ScalarVisibilityOff();
          table2Actor = new vtkActor();
          table2Actor.SetMapper((vtkMapper)mapTable2);
          table2Actor.GetProperty().SetColor((double).59,(double).427,(double).392);
          FilingCabinet1 = new vtkStructuredGridGeometryFilter();
          FilingCabinet1.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          FilingCabinet1.SetExtent((int)15,(int)15,(int)7,(int)9,(int)0,(int)8);
          mapFilingCabinet1 = vtkPolyDataMapper.New();
          mapFilingCabinet1.SetInputConnection((vtkAlgorithmOutput)FilingCabinet1.GetOutputPort());
          mapFilingCabinet1.ScalarVisibilityOff();
          FilingCabinet1Actor = new vtkActor();
          FilingCabinet1Actor.SetMapper((vtkMapper)mapFilingCabinet1);
          FilingCabinet1Actor.GetProperty().SetColor((double).8,(double).8,(double).6);
          FilingCabinet2 = new vtkStructuredGridGeometryFilter();
          FilingCabinet2.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          FilingCabinet2.SetExtent((int)15,(int)15,(int)10,(int)12,(int)0,(int)8);
          mapFilingCabinet2 = vtkPolyDataMapper.New();
          mapFilingCabinet2.SetInputConnection((vtkAlgorithmOutput)FilingCabinet2.GetOutputPort());
          mapFilingCabinet2.ScalarVisibilityOff();
          FilingCabinet2Actor = new vtkActor();
          FilingCabinet2Actor.SetMapper((vtkMapper)mapFilingCabinet2);
          FilingCabinet2Actor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1Top = new vtkStructuredGridGeometryFilter();
          bookshelf1Top.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1Top.SetExtent((int)13,(int)13,(int)0,(int)4,(int)0,(int)11);
          mapBookshelf1Top = vtkPolyDataMapper.New();
          mapBookshelf1Top.SetInputConnection((vtkAlgorithmOutput)bookshelf1Top.GetOutputPort());
          mapBookshelf1Top.ScalarVisibilityOff();
          bookshelf1TopActor = new vtkActor();
          bookshelf1TopActor.SetMapper((vtkMapper)mapBookshelf1Top);
          bookshelf1TopActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1Bottom = new vtkStructuredGridGeometryFilter();
          bookshelf1Bottom.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1Bottom.SetExtent((int)20,(int)20,(int)0,(int)4,(int)0,(int)11);
          mapBookshelf1Bottom = vtkPolyDataMapper.New();
          mapBookshelf1Bottom.SetInputConnection((vtkAlgorithmOutput)bookshelf1Bottom.GetOutputPort());
          mapBookshelf1Bottom.ScalarVisibilityOff();
          bookshelf1BottomActor = new vtkActor();
          bookshelf1BottomActor.SetMapper((vtkMapper)mapBookshelf1Bottom);
          bookshelf1BottomActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1Front = new vtkStructuredGridGeometryFilter();
          bookshelf1Front.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1Front.SetExtent((int)13,(int)20,(int)0,(int)0,(int)0,(int)11);
          mapBookshelf1Front = vtkPolyDataMapper.New();
          mapBookshelf1Front.SetInputConnection((vtkAlgorithmOutput)bookshelf1Front.GetOutputPort());
          mapBookshelf1Front.ScalarVisibilityOff();
          bookshelf1FrontActor = new vtkActor();
          bookshelf1FrontActor.SetMapper((vtkMapper)mapBookshelf1Front);
          bookshelf1FrontActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1Back = new vtkStructuredGridGeometryFilter();
          bookshelf1Back.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1Back.SetExtent((int)13,(int)20,(int)4,(int)4,(int)0,(int)11);
          mapBookshelf1Back = vtkPolyDataMapper.New();
          mapBookshelf1Back.SetInputConnection((vtkAlgorithmOutput)bookshelf1Back.GetOutputPort());
          mapBookshelf1Back.ScalarVisibilityOff();
          bookshelf1BackActor = new vtkActor();
          bookshelf1BackActor.SetMapper((vtkMapper)mapBookshelf1Back);
          bookshelf1BackActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1LHS = new vtkStructuredGridGeometryFilter();
          bookshelf1LHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1LHS.SetExtent((int)13,(int)20,(int)0,(int)4,(int)0,(int)0);
          mapBookshelf1LHS = vtkPolyDataMapper.New();
          mapBookshelf1LHS.SetInputConnection((vtkAlgorithmOutput)bookshelf1LHS.GetOutputPort());
          mapBookshelf1LHS.ScalarVisibilityOff();
          bookshelf1LHSActor = new vtkActor();
          bookshelf1LHSActor.SetMapper((vtkMapper)mapBookshelf1LHS);
          bookshelf1LHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf1RHS = new vtkStructuredGridGeometryFilter();
          bookshelf1RHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf1RHS.SetExtent((int)13,(int)20,(int)0,(int)4,(int)11,(int)11);
          mapBookshelf1RHS = vtkPolyDataMapper.New();
          mapBookshelf1RHS.SetInputConnection((vtkAlgorithmOutput)bookshelf1RHS.GetOutputPort());
          mapBookshelf1RHS.ScalarVisibilityOff();
          bookshelf1RHSActor = new vtkActor();
          bookshelf1RHSActor.SetMapper((vtkMapper)mapBookshelf1RHS);
          bookshelf1RHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2Top = new vtkStructuredGridGeometryFilter();
          bookshelf2Top.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2Top.SetExtent((int)13,(int)13,(int)15,(int)19,(int)0,(int)11);
          mapBookshelf2Top = vtkPolyDataMapper.New();
          mapBookshelf2Top.SetInputConnection((vtkAlgorithmOutput)bookshelf2Top.GetOutputPort());
          mapBookshelf2Top.ScalarVisibilityOff();
          bookshelf2TopActor = new vtkActor();
          bookshelf2TopActor.SetMapper((vtkMapper)mapBookshelf2Top);
          bookshelf2TopActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2Bottom = new vtkStructuredGridGeometryFilter();
          bookshelf2Bottom.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2Bottom.SetExtent((int)20,(int)20,(int)15,(int)19,(int)0,(int)11);
          mapBookshelf2Bottom = vtkPolyDataMapper.New();
          mapBookshelf2Bottom.SetInputConnection((vtkAlgorithmOutput)bookshelf2Bottom.GetOutputPort());
          mapBookshelf2Bottom.ScalarVisibilityOff();
          bookshelf2BottomActor = new vtkActor();
          bookshelf2BottomActor.SetMapper((vtkMapper)mapBookshelf2Bottom);
          bookshelf2BottomActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2Front = new vtkStructuredGridGeometryFilter();
          bookshelf2Front.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2Front.SetExtent((int)13,(int)20,(int)15,(int)15,(int)0,(int)11);
          mapBookshelf2Front = vtkPolyDataMapper.New();
          mapBookshelf2Front.SetInputConnection((vtkAlgorithmOutput)bookshelf2Front.GetOutputPort());
          mapBookshelf2Front.ScalarVisibilityOff();
          bookshelf2FrontActor = new vtkActor();
          bookshelf2FrontActor.SetMapper((vtkMapper)mapBookshelf2Front);
          bookshelf2FrontActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2Back = new vtkStructuredGridGeometryFilter();
          bookshelf2Back.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2Back.SetExtent((int)13,(int)20,(int)19,(int)19,(int)0,(int)11);
          mapBookshelf2Back = vtkPolyDataMapper.New();
          mapBookshelf2Back.SetInputConnection((vtkAlgorithmOutput)bookshelf2Back.GetOutputPort());
          mapBookshelf2Back.ScalarVisibilityOff();
          bookshelf2BackActor = new vtkActor();
          bookshelf2BackActor.SetMapper((vtkMapper)mapBookshelf2Back);
          bookshelf2BackActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2LHS = new vtkStructuredGridGeometryFilter();
          bookshelf2LHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2LHS.SetExtent((int)13,(int)20,(int)15,(int)19,(int)0,(int)0);
          mapBookshelf2LHS = vtkPolyDataMapper.New();
          mapBookshelf2LHS.SetInputConnection((vtkAlgorithmOutput)bookshelf2LHS.GetOutputPort());
          mapBookshelf2LHS.ScalarVisibilityOff();
          bookshelf2LHSActor = new vtkActor();
          bookshelf2LHSActor.SetMapper((vtkMapper)mapBookshelf2LHS);
          bookshelf2LHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          bookshelf2RHS = new vtkStructuredGridGeometryFilter();
          bookshelf2RHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          bookshelf2RHS.SetExtent((int)13,(int)20,(int)15,(int)19,(int)11,(int)11);
          mapBookshelf2RHS = vtkPolyDataMapper.New();
          mapBookshelf2RHS.SetInputConnection((vtkAlgorithmOutput)bookshelf2RHS.GetOutputPort());
          mapBookshelf2RHS.ScalarVisibilityOff();
          bookshelf2RHSActor = new vtkActor();
          bookshelf2RHSActor.SetMapper((vtkMapper)mapBookshelf2RHS);
          bookshelf2RHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
          window = new vtkStructuredGridGeometryFilter();
          window.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          window.SetExtent((int)20,(int)20,(int)6,(int)13,(int)10,(int)13);
          mapWindow = vtkPolyDataMapper.New();
          mapWindow.SetInputConnection((vtkAlgorithmOutput)window.GetOutputPort());
          mapWindow.ScalarVisibilityOff();
          windowActor = new vtkActor();
          windowActor.SetMapper((vtkMapper)mapWindow);
          windowActor.GetProperty().SetColor((double).3,(double).3,(double).5);
          outlet = new vtkStructuredGridGeometryFilter();
          outlet.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          outlet.SetExtent((int)0,(int)0,(int)9,(int)10,(int)14,(int)16);
          mapOutlet = vtkPolyDataMapper.New();
          mapOutlet.SetInputConnection((vtkAlgorithmOutput)outlet.GetOutputPort());
          mapOutlet.ScalarVisibilityOff();
          outletActor = new vtkActor();
          outletActor.SetMapper((vtkMapper)mapOutlet);
          outletActor.GetProperty().SetColor((double)0,(double)0,(double)0);
          inlet = new vtkStructuredGridGeometryFilter();
          inlet.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          inlet.SetExtent((int)0,(int)0,(int)9,(int)10,(int)0,(int)6);
          mapInlet = vtkPolyDataMapper.New();
          mapInlet.SetInputConnection((vtkAlgorithmOutput)inlet.GetOutputPort());
          mapInlet.ScalarVisibilityOff();
          inletActor = new vtkActor();
          inletActor.SetMapper((vtkMapper)mapInlet);
          inletActor.GetProperty().SetColor((double)0,(double)0,(double)0);
          outline = new vtkStructuredGridOutlineFilter();
          outline.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          mapOutline = vtkPolyDataMapper.New();
          mapOutline.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
          outlineActor = new vtkActor();
          outlineActor.SetMapper((vtkMapper)mapOutline);
          outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
          // Create source for streamtubes[]
          streamer = new vtkStreamPoints();
          streamer.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          streamer.SetStartPosition((double)0.1,(double)2.1,(double)0.5);
          streamer.SetMaximumPropagationTime((double)500);
          streamer.SetTimeIncrement((double)0.5);
          streamer.SetIntegrationDirectionToForward();
          cone = new vtkConeSource();
          cone.SetResolution((int)8);
          cones = new vtkGlyph3D();
          cones.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
          cones.SetSourceConnection(cone.GetOutputPort());
          cones.SetScaleFactor((double)0.5);
          cones.SetScaleModeToScaleByVector();
          mapCones = vtkPolyDataMapper.New();
          mapCones.SetInputConnection((vtkAlgorithmOutput)cones.GetOutputPort());
          mapCones.SetScalarRange((double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[1]);
          conesActor = new vtkActor();
          conesActor.SetMapper((vtkMapper)mapCones);
          ren1.AddActor((vtkProp)table1Actor);
          ren1.AddActor((vtkProp)table2Actor);
          ren1.AddActor((vtkProp)FilingCabinet1Actor);
          ren1.AddActor((vtkProp)FilingCabinet2Actor);
          ren1.AddActor((vtkProp)bookshelf1TopActor);
          ren1.AddActor((vtkProp)bookshelf1BottomActor);
          ren1.AddActor((vtkProp)bookshelf1FrontActor);
          ren1.AddActor((vtkProp)bookshelf1BackActor);
          ren1.AddActor((vtkProp)bookshelf1LHSActor);
          ren1.AddActor((vtkProp)bookshelf1RHSActor);
          ren1.AddActor((vtkProp)bookshelf2TopActor);
          ren1.AddActor((vtkProp)bookshelf2BottomActor);
          ren1.AddActor((vtkProp)bookshelf2FrontActor);
          ren1.AddActor((vtkProp)bookshelf2BackActor);
          ren1.AddActor((vtkProp)bookshelf2LHSActor);
          ren1.AddActor((vtkProp)bookshelf2RHSActor);
          ren1.AddActor((vtkProp)windowActor);
          ren1.AddActor((vtkProp)outletActor);
          ren1.AddActor((vtkProp)inletActor);
          ren1.AddActor((vtkProp)outlineActor);
          ren1.AddActor((vtkProp)conesActor);
          ren1.SetBackground((double)0.4,(double)0.4,(double)0.5);
          aCamera = new vtkCamera();
          aCamera.SetClippingRange((double)0.7724,(double)39);
          aCamera.SetFocalPoint((double)1.14798,(double)3.08416,(double)2.47187);
          aCamera.SetPosition((double)-2.64683,(double)-3.55525,(double)3.55848);
          aCamera.SetViewUp((double)0.0511273,(double)0.132773,(double)0.989827);
          aCamera.SetViewAngle((double)15.5033);
          ren1.SetActiveCamera((vtkCamera)aCamera);
          renWin.SetSize((int)500,(int)300);
          iren.Initialize();
          // interact with data[]

        //deleteAllVTKObjects();
    }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestPDataSetReaderGrid(String [] argv)
    {
        //Prefix Content is: ""

        // Create the RenderWindow, Renderer and both Actors[]
        //[]
        ren1   = vtkRenderer.New();
        renWin = vtkRenderWindow.New();
        renWin.AddRenderer((vtkRenderer)ren1);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);
        //[]
        // If the current directory is writable, then test the witers[]
        //[]
        try
        {
            channel       = new StreamWriter("test.tmp");
            tryCatchError = "NOERROR";
        }
        catch (Exception)
        {
            tryCatchError = "ERROR";
        }
        if (tryCatchError.Equals("NOERROR"))
        {
            channel.Close();
            File.Delete("test.tmp");
            // ====== Structured Grid ======[]
            // First save out a grid in parallel form.[]
            reader = new vtkMultiBlockPLOT3DReader();
            reader.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
            reader.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
            writer = new vtkPDataSetWriter();
            writer.SetFileName((string)"comb.pvtk");
            writer.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
            writer.SetNumberOfPieces((int)4);
            writer.Write();
            pReader = new vtkPDataSetReader();
            pReader.SetFileName((string)"comb.pvtk");
            surface = new vtkDataSetSurfaceFilter();
            surface.SetInputConnection((vtkAlgorithmOutput)pReader.GetOutputPort());
            mapper = vtkPolyDataMapper.New();
            mapper.SetInputConnection((vtkAlgorithmOutput)surface.GetOutputPort());
            mapper.SetNumberOfPieces((int)2);
            mapper.SetPiece((int)0);
            mapper.SetGhostLevel((int)1);
            mapper.Update();
            File.Delete("comb.pvtk");
            File.Delete("comb.0.vtk");
            File.Delete("comb.1.vtk");
            File.Delete("comb.2.vtk");
            File.Delete("comb.3.vtk");
            actor = new vtkActor();
            actor.SetMapper((vtkMapper)mapper);
            actor.SetPosition((double)-5, (double)0, (double)-29);
            // Add the actors to the renderer, set the background and size[]
            //[]
            ren1.AddActor((vtkProp)actor);
            // ====== ImageData ======[]
            // First save out a grid in parallel form.[]
            fractal = new vtkImageMandelbrotSource();
            fractal.SetWholeExtent((int)0, (int)9, (int)0, (int)9, (int)0, (int)9);
            fractal.SetSampleCX((double)0.1, (double)0.1, (double)0.1, (double)0.1);
            fractal.SetMaximumNumberOfIterations((ushort)10);
            writer2 = new vtkPDataSetWriter();
            writer.SetFileName((string)"fractal.pvtk");
            writer.SetInputConnection((vtkAlgorithmOutput)fractal.GetOutputPort());
            writer.SetNumberOfPieces((int)4);
            writer.Write();
            pReader2 = new vtkPDataSetReader();
            pReader2.SetFileName((string)"fractal.pvtk");
            iso = new vtkContourFilter();
            iso.SetInputConnection((vtkAlgorithmOutput)pReader2.GetOutputPort());
            iso.SetValue((int)0, (double)4);
            mapper2 = vtkPolyDataMapper.New();
            mapper2.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
            mapper2.SetNumberOfPieces((int)3);
            mapper2.SetPiece((int)0);
            mapper2.SetGhostLevel((int)0);
            mapper2.Update();
            File.Delete("fractal.pvtk");
            File.Delete("fractal.0.vtk");
            File.Delete("fractal.1.vtk");
            File.Delete("fractal.2.vtk");
            File.Delete("fractal.3.vtk");
            actor2 = new vtkActor();
            actor2.SetMapper((vtkMapper)mapper2);
            actor2.SetScale((double)5, (double)5, (double)5);
            actor2.SetPosition((double)6, (double)6, (double)6);
            // Add the actors to the renderer, set the background and size[]
            //[]
            ren1.AddActor((vtkProp)actor2);
            // ====== PolyData ======[]
            // First save out a grid in parallel form.[]
            sphere = new vtkSphereSource();
            sphere.SetRadius((double)2);
            writer3 = new vtkPDataSetWriter();
            writer3.SetFileName((string)"sphere.pvtk");
            writer3.SetInputConnection((vtkAlgorithmOutput)sphere.GetOutputPort());
            writer3.SetNumberOfPieces((int)4);
            writer3.Write();
            pReader3 = new vtkPDataSetReader();
            pReader3.SetFileName((string)"sphere.pvtk");
            mapper3 = vtkPolyDataMapper.New();
            mapper3.SetInputConnection((vtkAlgorithmOutput)pReader3.GetOutputPort());
            mapper3.SetNumberOfPieces((int)2);
            mapper3.SetPiece((int)0);
            mapper3.SetGhostLevel((int)1);
            mapper3.Update();
            File.Delete("sphere.pvtk");
            File.Delete("sphere.0.vtk");
            File.Delete("sphere.1.vtk");
            File.Delete("sphere.2.vtk");
            File.Delete("sphere.3.vtk");
            actor3 = new vtkActor();
            actor3.SetMapper((vtkMapper)mapper3);
            actor3.SetPosition((double)6, (double)6, (double)6);
            // Add the actors to the renderer, set the background and size[]
            //[]
            ren1.AddActor((vtkProp)actor3);
        }


        ren1.SetBackground((double)0.1, (double)0.2, (double)0.4);
        renWin.SetSize((int)300, (int)300);
        // render the image[]
        //[]
        cam1 = ren1.GetActiveCamera();
        cam1.Azimuth((double)20);
        cam1.Elevation((double)40);
        ren1.ResetCamera();
        cam1.Zoom((double)1.2);
        iren.Initialize();
        // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
Example #15
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetboundsActor(vtkActor toSet)
 {
     boundsActor = toSet;
 }
Example #16
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetisoActor(vtkActor toSet)
 {
     isoActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetsphereActor(vtkActor toSet)
 {
     sphereActor = toSet;
 }
Example #18
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVpolyConn(String [] argv)
    {
        //Prefix Content is: ""

          // Create the RenderWindow, Renderer and both Actors[]
          //[]
          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // read data[]
          //[]
          pl3d = new vtkMultiBlockPLOT3DReader();
          pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
          pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
          pl3d.SetScalarFunctionNumber((int)100);
          pl3d.SetVectorFunctionNumber((int)202);
          pl3d.Update();
          // planes to connect[]
          plane1 = new vtkStructuredGridGeometryFilter();
          plane1.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
          plane1.SetExtent((int)20,(int)20,(int)0,(int)100,(int)0,(int)100);
          conn = new vtkPolyDataConnectivityFilter();
          conn.SetInputConnection((vtkAlgorithmOutput)plane1.GetOutputPort());
          conn.ScalarConnectivityOn();
          conn.SetScalarRange((double)0.19,(double)0.25);
          plane1Map = vtkPolyDataMapper.New();
          plane1Map.SetInputConnection((vtkAlgorithmOutput)conn.GetOutputPort());
          plane1Map.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[0],
          (double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[1]);
          plane1Actor = new vtkActor();
          plane1Actor.SetMapper((vtkMapper)plane1Map);
          plane1Actor.GetProperty().SetOpacity((double)0.999);
          // outline[]
          outline = new vtkStructuredGridOutlineFilter();
          outline.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
          outlineMapper = vtkPolyDataMapper.New();
          outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
          outlineActor = new vtkActor();
          outlineActor.SetMapper((vtkMapper)outlineMapper);
          outlineProp = outlineActor.GetProperty();
          outlineProp.SetColor((double)0,(double)0,(double)0);
          // Add the actors to the renderer, set the background and size[]
          //[]
          ren1.AddActor((vtkProp)outlineActor);
          ren1.AddActor((vtkProp)plane1Actor);
          ren1.SetBackground((double)1,(double)1,(double)1);
          renWin.SetSize((int)300,(int)300);
          cam1 = new vtkCamera();
          cam1.SetClippingRange((double)14.29,(double)63.53);
          cam1.SetFocalPoint((double)8.58522,(double)1.58266,(double)30.6486);
          cam1.SetPosition((double)37.6808,(double)-20.1298,(double)35.4016);
          cam1.SetViewAngle((double)30);
          cam1.SetViewUp((double)-0.0566235,(double)0.140504,(double)0.98846);
          ren1.SetActiveCamera((vtkCamera)cam1);
          iren.Initialize();
          // render the image[]
          //[]
          // prevent the tk window from showing up then start the event loop[]

        //deleteAllVTKObjects();
    }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setbookshelf1TopActor(vtkActor toSet)
 {
     bookshelf1TopActor = toSet;
 }
Example #20
0
        private void WriteVTUFile()
        {
            // Path to vtk data must be set as an environment variable
            // VTK_DATA_ROOT = "C:\VTK\vtkdata-5.8.0"
            vtkTesting test     = vtkTesting.New();
            string     root     = test.GetDataRoot();
            string     filePath = System.IO.Path.Combine(root, @"Data\tetra_test.vtu");

            vtkPoints points = vtkPoints.New();

            points.InsertNextPoint(0, 0, 0);
            points.InsertNextPoint(1, 0, 0);
            points.InsertNextPoint(1, 1, 0);
            points.InsertNextPoint(0, 1, 1);

            vtkTetra tetra = vtkTetra.New();

            tetra.GetPointIds().SetId(0, 0);
            tetra.GetPointIds().SetId(1, 1);
            tetra.GetPointIds().SetId(2, 2);
            tetra.GetPointIds().SetId(3, 3);

            vtkCellArray cellArray = vtkCellArray.New();

            cellArray.InsertNextCell(tetra);

            vtkUnstructuredGrid unstructuredGrid = vtkUnstructuredGrid.New();

            unstructuredGrid.SetPoints(points);
            const int VTK_TETRA = 10;

            unstructuredGrid.SetCells(VTK_TETRA, cellArray);

            // Write file
            vtkXMLUnstructuredGridWriter writer = vtkXMLUnstructuredGridWriter.New();

            writer.SetFileName(filePath);
            writer.SetInput(unstructuredGrid);
            writer.Write();

            // Read and display file for verification that it was written correctly
            vtkXMLUnstructuredGridReader reader = vtkXMLUnstructuredGridReader.New();

            if (reader.CanReadFile(filePath) == 0)
            {
                MessageBox.Show("Cannot read file \"" + filePath + "\"", "Error", MessageBoxButtons.OK);
                return;
            }
            reader.SetFileName(filePath);
            reader.Update();

            vtkDataSetMapper mapper = vtkDataSetMapper.New();

            mapper.SetInputConnection(reader.GetOutputPort());

            // actor
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);

            // get a reference to the renderwindow of our renderWindowControl1
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            // renderer
            vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();

            // set background color
            renderer.SetBackground(0.2, 0.3, 0.4);
            // add our actor to the renderer
            renderer.AddActor(actor);
        }
Example #21
0
        private void WritePolyData()
        {
            // Path to vtk data must be set as an environment variable
            // VTK_DATA_ROOT = "C:\VTK\vtkdata-5.8.0"
            vtkTesting test     = vtkTesting.New();
            string     root     = test.GetDataRoot();
            string     filePath = System.IO.Path.Combine(root, @"Data\poly_test.vtp");
            // Create 4 points for a tetrahedron
            vtkPoints points = vtkPoints.New();

            points.InsertNextPoint(0, 0, 0);
            points.InsertNextPoint(0, 0, 1);
            points.InsertNextPoint(1, 0, 0);
            points.InsertNextPoint(0, 1, 0);

            // Create a polydata object and add the points to it.
            vtkPolyData polydata = vtkPolyData.New();

            polydata.SetPoints(points);

            // it's not enough only to define points
            // we need to define faces too
            // (must be defined in counter clockwise order as viewed from the outside)
            vtkTriangle face0 = vtkTriangle.New();

            face0.GetPointIds().SetId(0, 0);
            face0.GetPointIds().SetId(1, 2);
            face0.GetPointIds().SetId(2, 1);
            vtkTriangle face1 = vtkTriangle.New();

            face1.GetPointIds().SetId(0, 0);
            face1.GetPointIds().SetId(1, 3);
            face1.GetPointIds().SetId(2, 2);
            vtkTriangle face2 = vtkTriangle.New();

            face2.GetPointIds().SetId(0, 0);
            face2.GetPointIds().SetId(1, 1);
            face2.GetPointIds().SetId(2, 3);
            vtkTriangle face3 = vtkTriangle.New();

            face3.GetPointIds().SetId(0, 1);
            face3.GetPointIds().SetId(1, 2);
            face3.GetPointIds().SetId(2, 3);

            vtkCellArray faces = vtkCellArray.New();

            faces.InsertNextCell(face0);
            faces.InsertNextCell(face1);
            faces.InsertNextCell(face2);
            faces.InsertNextCell(face3);

            polydata.SetPolys(faces);

            // Write the file
            vtkXMLPolyDataWriter writer = vtkXMLPolyDataWriter.New();

            writer.SetFileName(filePath);
            writer.SetInput(polydata);

            // Optional - set the mode. The default is binary.
            //writer.SetDataModeToBinary();
            writer.SetDataModeToAscii();
            writer.Write();

            // Read and display file for verification that it was written correctly
            vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();

            if (reader.CanReadFile(filePath) == 0)
            {
                MessageBox.Show("Cannot read file \"" + filePath + "\"", "Error", MessageBoxButtons.OK);
                return;
            }
            reader.SetFileName(filePath);
            reader.Update();

            vtkDataSetMapper mapper = vtkDataSetMapper.New();

            mapper.SetInputConnection(reader.GetOutputPort());

            // actor
            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);
            // get a reference to the renderwindow of our renderWindowControl1
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            // renderer
            vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();

            // set background color
            renderer.SetBackground(0.2, 0.3, 0.4);
            // add our actor to the renderer
            renderer.AddActor(actor);
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setactor(vtkActor toSet)
 {
     actor = toSet;
 }
        /// <summary>
        /// 绘制立方体的五个面
        /// 根据index确定需要绘制哪个面
        /// </summary>
        /// <param name="index"></param>
        /// <param name="renderer"></param>
        public void PlotSurface(int index, vtkRenderer renderer)
        {
            vtkPlaneSource    pSrc   = vtkPlaneSource.New();
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
            vtkActor          actor  = vtkActor.New();

            switch (index)
            {
            case 0:
                pSrc.SetCenter(sideLen + 0.5 + offset[0], sideLen + 0.5 + offset[1], 0 + offset[2]);
                pSrc.SetNormal(0, 0, 1);
                pSrc.SetPoint1(sideLen + offset[0], 0 + offset[1], 0 + offset[2]);
                pSrc.SetPoint2(0 + offset[0], sideLen + offset[1], 0 + offset[2]);
                mapper.SetInput(pSrc.GetOutput());
                actor.SetMapper(mapper);
                renderer.AddActor(actor);

                break;

            case 1:
                pSrc.SetCenter(0 + offset[0], sideLen + 0.5 + offset[1], sideLen - 0.5 + offset[2]);
                pSrc.SetNormal(1, 0, 0);
                pSrc.SetPoint1(0 + offset[0], 0 + offset[1], sideLen + offset[2]);
                pSrc.SetPoint2(0 + offset[0], sideLen + offset[1], 0 + offset[2]);
                mapper.SetInput(pSrc.GetOutput());
                actor.SetMapper(mapper);
                renderer.AddActor(actor);

                break;

            case 2:
                pSrc.SetCenter(sideLen + offset[0], sideLen + 0.5 + offset[1], sideLen - 0.5 + offset[2]);
                pSrc.SetNormal(1, 0, 0);
                pSrc.SetPoint1(sideLen + offset[0], 0 + offset[1], sideLen + offset[2]);
                pSrc.SetPoint2(sideLen + offset[0], sideLen + offset[1], 0 + offset[2]);
                mapper.SetInput(pSrc.GetOutput());
                actor.SetMapper(mapper);
                renderer.AddActor(actor);

                break;

            case 3:
                pSrc.SetCenter(sideLen + 0.5 + offset[0], 0 + offset[1], sideLen - 0.5 + offset[2]);
                pSrc.SetNormal(0, 1, 0);
                pSrc.SetPoint1(sideLen + offset[0], 0 + offset[1], 0 + offset[2]);
                pSrc.SetPoint2(0 + offset[0], 0 + offset[1], sideLen + offset[2]);
                mapper.SetInput(pSrc.GetOutput());
                actor.SetMapper(mapper);
                renderer.AddActor(actor);

                break;

            case 4:
                pSrc.SetCenter(sideLen + 0.5 + offset[0], sideLen + offset[1], sideLen - 0.5 + offset[2]);
                pSrc.SetNormal(0, 1, 0);
                pSrc.SetPoint1(sideLen + offset[0], sideLen + offset[1], 0 + offset[2]);
                pSrc.SetPoint2(0 + offset[0], sideLen + offset[1], sideLen + offset[2]);
                mapper.SetInput(pSrc.GetOutput());
                actor.SetMapper(mapper);
                renderer.AddActor(actor);
                break;

            case 5:
                break;

            default:
                break;
            }
        }
Example #24
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVlabeledContours(String [] argv)
    {
        //Prefix Content is: ""

        // demonstrate labeling of contour with scalar value[]
        // Create the RenderWindow, Renderer and both Actors[]
        //[]
        ren1   = vtkRenderer.New();
        renWin = vtkRenderWindow.New();
        renWin.SetMultiSamples(0);
        renWin.AddRenderer((vtkRenderer)ren1);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);
        // Read a slice and contour it[]
        v16 = new vtkVolume16Reader();
        v16.SetDataDimensions((int)64, (int)64);
        v16.GetOutput().SetOrigin((double)0.0, (double)0.0, (double)0.0);
        v16.SetDataByteOrderToLittleEndian();
        v16.SetFilePrefix((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/headsq/quarter");
        v16.SetImageRange((int)45, (int)45);
        v16.SetDataSpacing((double)3.2, (double)3.2, (double)1.5);
        iso = new vtkContourFilter();
        iso.SetInputConnection((vtkAlgorithmOutput)v16.GetOutputPort());
        iso.GenerateValues((int)6, (double)500, (double)1150);
        iso.Update();
        numPts    = iso.GetOutput().GetNumberOfPoints();
        isoMapper = vtkPolyDataMapper.New();
        isoMapper.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
        isoMapper.ScalarVisibilityOn();
        isoMapper.SetScalarRange((double)((vtkDataSet)iso.GetOutput()).GetScalarRange()[0], (double)((vtkDataSet)iso.GetOutput()).GetScalarRange()[1]);
        isoActor = new vtkActor();
        isoActor.SetMapper((vtkMapper)isoMapper);
        // Subsample the points and label them[]
        mask = new vtkMaskPoints();
        mask.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
        mask.SetOnRatio((int)(numPts / 50));
        mask.SetMaximumNumberOfPoints((int)50);
        mask.RandomModeOn();
        // Create labels for points - only show visible points[]
        visPts = new vtkSelectVisiblePoints();
        visPts.SetInputConnection((vtkAlgorithmOutput)mask.GetOutputPort());
        visPts.SetRenderer((vtkRenderer)ren1);
        ldm = new vtkLabeledDataMapper();
        ldm.SetInputConnection((vtkAlgorithmOutput)mask.GetOutputPort());
        //    ldm SetLabelFormat "%g"[]
        ldm.SetLabelModeToLabelScalars();
        tprop = ldm.GetLabelTextProperty();
        tprop.SetFontFamilyToArial();
        tprop.SetFontSize((int)10);
        tprop.SetColor((double)1, (double)0, (double)0);
        contourLabels = new vtkActor2D();
        contourLabels.SetMapper((vtkMapper2D)ldm);
        // Add the actors to the renderer, set the background and size[]
        //[]
        ren1.AddActor2D((vtkProp)isoActor);
        ren1.AddActor2D((vtkProp)contourLabels);
        ren1.SetBackground((double)1, (double)1, (double)1);
        renWin.SetSize((int)500, (int)500);
        renWin.Render();
        ren1.GetActiveCamera().Zoom((double)1.5);
        // render the image[]
        //[]
        // prevent the tk window from showing up then start the event loop[]

//deleteAllVTKObjects();
    }
Example #25
0
        private void ContoursFromPolyData(string filePath)
        {
            vtkPolyData inputPolyData;

            if (filePath != null)
            {
                vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();
                reader.SetFileName(filePath);
                reader.Update();
                inputPolyData = reader.GetOutput();
            }
            else
            {
                vtkSphereSource sphereSource = vtkSphereSource.New();
                sphereSource.SetThetaResolution(30);
                sphereSource.SetPhiResolution(15);
                sphereSource.Update();
                inputPolyData = sphereSource.GetOutput();
            }

            vtkPolyDataMapper inputMapper = vtkPolyDataMapper.New();

#if VTK_MAJOR_VERSION_5
            inputMapper.SetInput(inputPolyData);
#else
            inputMapper.SetInputData(inputPolyData);
#endif

            // Create a plane to cut
            vtkPlane plane  = vtkPlane.New();
            double[] center = inputPolyData.GetCenter();
            double[] bounds = inputPolyData.GetBounds();
            plane.SetOrigin(center[0], center[1], center[2]);
            plane.SetNormal(1, 1, 1);


            float[] centerf   = new float[] { (float)center[0], (float)center[1], (float)center[2] };
            float[] minBoundf = new float[] { (float)bounds[0], (float)bounds[2], (float)bounds[4] };
            float[] maxBoundf = new float[] { (float)bounds[1], (float)bounds[3], (float)bounds[5] };
            IntPtr  pCenter   = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * 3);
            IntPtr  pMinBound = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * 3);
            IntPtr  pMaxBound = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * 3);
            Marshal.Copy(centerf, 0, pCenter, 3);
            Marshal.Copy(minBoundf, 0, pMinBound, 3);
            Marshal.Copy(maxBoundf, 0, pMaxBound, 3);

            // vtkMath.Distance2BetweenPoints accepts floats only
            double distanceMin = Math.Sqrt(vtkMath.Distance2BetweenPoints(pMinBound, pCenter));
            double distanceMax = Math.Sqrt(vtkMath.Distance2BetweenPoints(pMaxBound, pCenter));

            Marshal.FreeHGlobal(pCenter);
            Marshal.FreeHGlobal(pMinBound);
            Marshal.FreeHGlobal(pMaxBound);
            // Create cutter
            vtkCutter cutter = vtkCutter.New();
            cutter.SetCutFunction(plane);
#if VTK_MAJOR_VERSION_5
            cutter.SetInput(inputPolyData);
#else
            cutter.SetInputData(inputPolyData);
#endif
            cutter.GenerateValues(20, -distanceMin, distanceMax);
            vtkPolyDataMapper cutterMapper = vtkPolyDataMapper.New();
            cutterMapper.SetInputConnection(cutter.GetOutputPort());
            cutterMapper.ScalarVisibilityOff();

            // Create plane actor
            vtkActor planeActor = vtkActor.New();
            planeActor.GetProperty().SetColor(1.0, 0.0, 0.0);
            planeActor.GetProperty().SetLineWidth(3);
            planeActor.SetMapper(cutterMapper);

            // Create input actor
            vtkActor inputActor = vtkActor.New();
            inputActor.GetProperty().SetColor(1.0, 0.8941, 0.7686); // bisque
            inputActor.SetMapper(inputMapper);

            // 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);
            renderer.AddActor(inputActor);
            renderer.AddActor(planeActor); //display the contour lines
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetFilingCabinet2Actor(vtkActor toSet)
 {
     FilingCabinet2Actor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Settable2Actor(vtkActor toSet)
 {
     table2Actor = toSet;
 }
Example #28
0
        private void OBBDicer(string filePath)
        {
            vtkPolyData inputPolyData;

            if (filePath != null)
            {
                vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();
                reader.SetFileName(filePath);
                reader.Update();
                inputPolyData = reader.GetOutput();
            }
            else
            {
                vtkSphereSource sphereSource = vtkSphereSource.New();
                sphereSource.SetThetaResolution(30);
                sphereSource.SetPhiResolution(15);
                sphereSource.Update();
                inputPolyData = sphereSource.GetOutput();
            }

            // Create pipeline
            vtkOBBDicer dicer = vtkOBBDicer.New();

#if VTK_MAJOR_VERSION_5
            dicer.SetInput(inputPolyData);
#else
            dicer.SetInputData(inputPolyData);
#endif
            dicer.SetNumberOfPieces(4);
            dicer.SetDiceModeToSpecifiedNumberOfPieces();
            dicer.Update();

            vtkPolyDataMapper inputMapper = vtkPolyDataMapper.New();
            inputMapper.SetInputConnection(dicer.GetOutputPort());
            inputMapper.SetScalarRange(0, dicer.GetNumberOfActualPieces());

            Debug.WriteLine("Asked for: "
                            + dicer.GetNumberOfPieces() + " pieces, got: "
                            + dicer.GetNumberOfActualPieces());

            vtkActor inputActor = vtkActor.New();
            inputActor.SetMapper(inputMapper);
            inputActor.GetProperty().SetInterpolationToFlat();

            vtkOutlineCornerFilter outline = vtkOutlineCornerFilter.New();
#if VTK_MAJOR_VERSION_5
            outline.SetInput(inputPolyData);
#else
            outline.SetInputData(inputPolyData);
#endif

            vtkPolyDataMapper outlineMapper = vtkPolyDataMapper.New();
            outlineMapper.SetInputConnection(outline.GetOutputPort());

            vtkActor outlineActor = vtkActor.New();
            outlineActor.SetMapper(outlineMapper);
            outlineActor.GetProperty().SetColor(0, 0, 0);
            // 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(inputActor);
            renderer.AddActor(outlineActor);
        }
Example #29
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetoutlineActor(vtkActor toSet)
 {
     outlineActor = toSet;
 }
Example #30
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetBonds(vtkActor toSet)
 {
     Bonds = toSet;
 }
        private void Window_Activated(object sender, EventArgs e)
        {
            vtkPolyData   cube    = new vtkPolyData();
            vtkPoints     points  = new vtkPoints();
            vtkCellArray  polys   = new vtkCellArray();
            vtkFloatArray scalars = new vtkFloatArray();

            Kitware.VTK.RenderWindowControl vtkControl = new Kitware.VTK.RenderWindowControl();
            vtkControl.AddTestActors = false;
            vtkControl.Location      = new System.Drawing.Point(10, 10);
            vtkControl.Name          = "_renwin";
            vtkControl.Size          = new System.Drawing.Size(100, 100);
            vtkControl.TabIndex      = 0;
            vtkControl.TestText      = null;
            vtkControl.Dock          = System.Windows.Forms.DockStyle.Fill;
            vtkformhost.Child        = vtkControl;
            vtkformhost.Visibility   = System.Windows.Visibility.Visible;


            int i;

            float[][] x = new float[8][]
            {
                new float[] { 0, 0, 0 }, //第0个点的坐标
                new float[] { 1, 0, 0 }, //第1个点的坐标
                new float[] { 1, 1, 0 }, //第2个点的坐标
                new float[] { 0, 1, 0 }, //3
                new float[] { 0, 0, 1 }, //4
                new float[] { 1, 0, 1 }, //5
                new float[] { 1, 1, 1 }, //6
                new float[] { 0, 1, 1 } //7
            };
            for (i = 0; i < 8; i++)
            {
                points.InsertPoint(i, x[i][0], x[i][1], x[i][2]);                    //加载点,创建数据结构的几何
            }
            List <int[]> temp = new List <int[]>();

            int[] temparray0 = new int[4] {
                0, 1, 2, 3
            };                                           //第0,1,2,3个点连接在一起,成为一个单元
            int[] temparray1 = new int[4] {
                4, 5, 6, 7
            };                                           //第4,5,6,7个点连接在一起,成为一个单元
            int[] temparray2 = new int[4] {
                0, 1, 5, 4
            };
            int[] temparray3 = new int[4] {
                1, 2, 6, 5
            };
            int[] temparray4 = new int[4] {
                2, 3, 7, 6
            };
            int[] temparray5 = new int[4] {
                3, 0, 4, 7
            };
            temp.Add(temparray0);
            temp.Add(temparray1);
            temp.Add(temparray2);
            temp.Add(temparray3);
            temp.Add(temparray4);
            temp.Add(temparray5);
            //因为在activiz中没有vtkIdType这个类,所以用了其他的方法代替C++代码中的实现。
            for (int j = 0; j < temp.Count; j++)
            {
                IntPtr pP = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * 4);
                Marshal.Copy(temp[j], 0, pP, 4);
                polys.InsertNextCell(4, pP);//加载单元,定义数据集的拓扑
                Marshal.FreeHGlobal(pP);
            }
            for (i = 0; i < 8; i++)
            {
                scalars.InsertTuple1(i, i);                    //为每一个点设置点属性。
            }
            cube.SetPoints(points);
            cube.SetPolys(polys);
            cube.GetPointData().SetScalars(scalars);

            vtkPolyDataMapper cubemapper = new vtkPainterPolyDataMapper();

            cubemapper.SetInput(cube);
            cubemapper.SetScalarRange(0, 7);

            vtkActor cubeactor = new vtkActor();

            cubeactor.SetMapper(cubemapper);

            // Create components of the rendering subsystem
            //
            vtkRenderWindow _renwin = vtkControl.RenderWindow;
            vtkRenderer     ren1    = _renwin.GetRenderers().GetFirstRenderer();


            // Add the actors to the renderer, set the window size
            //
            ren1.AddViewProp(cubeactor);
            _renwin.SetSize(250, 250);
            _renwin.Render();
            ren1.ResetCamera();
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVExtractTensors(String [] argv)
    {
        //Prefix Content is: ""

        // create tensor ellipsoids[]
        // Create the RenderWindow, Renderer and interactive renderer[]
        //[]
        ren1   = vtkRenderer.New();
        renWin = vtkRenderWindow.New();
        renWin.AddRenderer((vtkRenderer)ren1);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);
        ptLoad = new vtkPointLoad();
        ptLoad.SetLoadValue((double)100.0);
        ptLoad.SetSampleDimensions((int)30, (int)30, (int)30);
        ptLoad.ComputeEffectiveStressOn();
        ptLoad.SetModelBounds((double)-10, (double)10, (double)-10, (double)10, (double)-10, (double)10);
        extractTensor = new vtkExtractTensorComponents();
        extractTensor.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
        extractTensor.ScalarIsEffectiveStress();
        extractTensor.ScalarIsComponent();
        extractTensor.ExtractScalarsOn();
        extractTensor.ExtractVectorsOn();
        extractTensor.ExtractNormalsOff();
        extractTensor.ExtractTCoordsOn();
        contour = new vtkContourFilter();
        contour.SetInputConnection((vtkAlgorithmOutput)extractTensor.GetOutputPort());
        contour.SetValue((int)0, (double)0);
        probe = new vtkProbeFilter();
        probe.SetInputConnection((vtkAlgorithmOutput)contour.GetOutputPort());
        probe.SetSourceConnection(ptLoad.GetOutputPort());
        su = new vtkLoopSubdivisionFilter();
        su.SetInputConnection((vtkAlgorithmOutput)probe.GetOutputPort());
        su.SetNumberOfSubdivisions((int)1);
        s1Mapper = vtkPolyDataMapper.New();
        s1Mapper.SetInputConnection((vtkAlgorithmOutput)probe.GetOutputPort());
        //    s1Mapper SetInputConnection [su GetOutputPort][]
        s1Actor = new vtkActor();
        s1Actor.SetMapper((vtkMapper)s1Mapper);
        //[]
        // plane for context[]
        //[]
        g = new vtkImageDataGeometryFilter();
        g.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
        g.SetExtent((int)0, (int)100, (int)0, (int)100, (int)0, (int)0);
        g.Update();
        //for scalar range[]
        gm = vtkPolyDataMapper.New();
        gm.SetInputConnection((vtkAlgorithmOutput)g.GetOutputPort());
        gm.SetScalarRange((double)((vtkDataSet)g.GetOutput()).GetScalarRange()[0], (double)((vtkDataSet)g.GetOutput()).GetScalarRange()[1]);
        ga = new vtkActor();
        ga.SetMapper((vtkMapper)gm);
        s1Mapper.SetScalarRange((double)((vtkDataSet)g.GetOutput()).GetScalarRange()[0], (double)((vtkDataSet)g.GetOutput()).GetScalarRange()[1]);
        //[]
        // Create outline around data[]
        //[]
        outline = new vtkOutlineFilter();
        outline.SetInputConnection((vtkAlgorithmOutput)ptLoad.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);
        //[]
        // Create cone indicating application of load[]
        //[]
        coneSrc = new vtkConeSource();
        coneSrc.SetRadius((double).5);
        coneSrc.SetHeight((double)2);
        coneMap = vtkPolyDataMapper.New();
        coneMap.SetInputConnection((vtkAlgorithmOutput)coneSrc.GetOutputPort());
        coneActor = new vtkActor();
        coneActor.SetMapper((vtkMapper)coneMap);
        coneActor.SetPosition((double)0, (double)0, (double)11);
        coneActor.RotateY((double)90);
        coneActor.GetProperty().SetColor((double)1, (double)0, (double)0);
        camera = new vtkCamera();
        camera.SetFocalPoint((double)0.113766, (double)-1.13665, (double)-1.01919);
        camera.SetPosition((double)-29.4886, (double)-63.1488, (double)26.5807);
        camera.SetViewAngle((double)24.4617);
        camera.SetViewUp((double)0.17138, (double)0.331163, (double)0.927879);
        camera.SetClippingRange((double)1, (double)100);
        ren1.AddActor((vtkProp)s1Actor);
        ren1.AddActor((vtkProp)outlineActor);
        ren1.AddActor((vtkProp)coneActor);
        ren1.AddActor((vtkProp)ga);
        ren1.SetBackground((double)1.0, (double)1.0, (double)1.0);
        ren1.SetActiveCamera((vtkCamera)camera);
        renWin.SetSize((int)300, (int)300);
        renWin.Render();
        // prevent the tk window from showing up then start the event loop[]

//deleteAllVTKObjects();
    }
Example #33
0
        private void ReadPlainText()
        {
            // Path to vtk data must be set as an environment variable
            // VTK_DATA_ROOT = "C:\VTK\vtkdata-5.8.0"
            vtkTesting test     = vtkTesting.New();
            string     root     = test.GetDataRoot();
            string     filePath = System.IO.Path.Combine(root, @"Data\teapot.xyz");

            FileStream   fs = null;
            StreamReader sr = null;
            String       sLineBuffer;

            String[]  sXYZ;
            char[]    chDelimiter = new char[] { ' ', '\t', ';' };
            double[]  xyz         = new double[3];
            vtkPoints points      = vtkPoints.New();
            int       cnt         = 0;

            try {
                // in case file must be open in another application too use "FileShare.ReadWrite"
                fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                sr = new StreamReader(fs);
                while (!sr.EndOfStream)
                {
                    sLineBuffer = sr.ReadLine();
                    cnt++;
                    sXYZ = sLineBuffer.Split(chDelimiter, StringSplitOptions.RemoveEmptyEntries);
                    if (sXYZ == null || sXYZ.Length != 3)
                    {
                        MessageBox.Show("data seems to be in wrong format at line " + cnt, "Format Exception", MessageBoxButtons.OK);
                        return;
                    }
                    xyz[0] = double.Parse(sXYZ[0], CultureInfo.InvariantCulture);
                    xyz[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture);
                    xyz[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);
                    points.InsertNextPoint(xyz[0], xyz[1], xyz[2]);
                }
                vtkPolyData polydata = vtkPolyData.New();
                polydata.SetPoints(points);
                vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New();
                glyphFilter.SetInputConnection(polydata.GetProducerPort());

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

                vtkActor actor = vtkActor.New();
                actor.SetMapper(mapper);
                actor.GetProperty().SetPointSize(4);
                actor.GetProperty().SetColor(1, 0.5, 0);
                // get a reference to the renderwindow of our renderWindowControl1
                vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
                // renderer
                vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
                // set background color
                renderer.SetBackground(0.2, 0.3, 0.4);
                // add our actor to the renderer
                renderer.AddActor(actor);
            }
            catch (IOException ex) {
                MessageBox.Show(ex.Message, "IOException", MessageBoxButtons.OK);
            }
            finally {
                if (sr != null)
                {
                    sr.Close();
                    sr.Dispose();
                    sr = null;
                }
            }
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Sets1Actor(vtkActor toSet)
 {
     s1Actor = toSet;
 }
Example #35
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetAtoms(vtkActor toSet)
 {
     Atoms = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setga(vtkActor toSet)
 {
     ga = toSet;
 }
Example #37
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVgaussian(String [] argv)
    {
        //Prefix Content is: ""

        ren1   = vtkRenderer.New();
        renWin = vtkRenderWindow.New();
        renWin.SetMultiSamples(0);
        renWin.AddRenderer((vtkRenderer)ren1);
        renWin.SetSize((int)300, (int)300);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);
        camera = new vtkCamera();
        camera.ParallelProjectionOn();
        camera.SetViewUp((double)0, (double)1, (double)0);
        camera.SetFocalPoint((double)12, (double)10.5, (double)15);
        camera.SetPosition((double)-70, (double)15, (double)34);
        camera.ComputeViewPlaneNormal();
        ren1.SetActiveCamera((vtkCamera)camera);
        // Create the reader for the data[]
        //vtkStructuredPointsReader reader[]
        reader = new vtkGaussianCubeReader();
        reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/m4_TotalDensity.cube");
        reader.SetHBScale((double)1.1);
        reader.SetBScale((double)10);
        reader.Update();
        range    = reader.GetGridOutput().GetPointData().GetScalars().GetRange();
        min      = (double)(lindex(range, 0));
        max      = (double)(lindex(range, 1));
        readerSS = new vtkImageShiftScale();
        readerSS.SetInputData((vtkDataObject)reader.GetGridOutput());
        readerSS.SetShift((double)min * -1);
        readerSS.SetScale((double)255 / (max - min));
        readerSS.SetOutputScalarTypeToUnsignedChar();
        bounds = new vtkOutlineFilter();
        bounds.SetInputData((vtkDataObject)reader.GetGridOutput());
        boundsMapper = vtkPolyDataMapper.New();
        boundsMapper.SetInputConnection((vtkAlgorithmOutput)bounds.GetOutputPort());
        boundsActor = new vtkActor();
        boundsActor.SetMapper((vtkMapper)boundsMapper);
        boundsActor.GetProperty().SetColor((double)0, (double)0, (double)0);
        contour = new vtkContourFilter();
        contour.SetInputData((vtkDataObject)reader.GetGridOutput());
        contour.GenerateValues((int)5, (double)0, (double).05);
        contourMapper = vtkPolyDataMapper.New();
        contourMapper.SetInputConnection((vtkAlgorithmOutput)contour.GetOutputPort());
        contourMapper.SetScalarRange((double)0, (double).1);
        ((vtkLookupTable)contourMapper.GetLookupTable()).SetHueRange(0.32, 0);
        contourActor = new vtkActor();
        contourActor.SetMapper((vtkMapper)contourMapper);
        contourActor.GetProperty().SetOpacity((double).5);
        // Create transfer mapping scalar value to opacity[]
        opacityTransferFunction = new vtkPiecewiseFunction();
        opacityTransferFunction.AddPoint((double)0, (double)0.01);
        opacityTransferFunction.AddPoint((double)255, (double)0.35);
        opacityTransferFunction.ClampingOn();
        // Create transfer mapping scalar value to color[]
        colorTransferFunction = new vtkColorTransferFunction();
        colorTransferFunction.AddHSVPoint((double)0.0, (double)0.66, (double)1.0, (double)1.0);
        colorTransferFunction.AddHSVPoint((double)50.0, (double)0.33, (double)1.0, (double)1.0);
        colorTransferFunction.AddHSVPoint((double)100.0, (double)0.00, (double)1.0, (double)1.0);
        // The property describes how the data will look[]
        volumeProperty = new vtkVolumeProperty();
        volumeProperty.SetColor((vtkColorTransferFunction)colorTransferFunction);
        volumeProperty.SetScalarOpacity((vtkPiecewiseFunction)opacityTransferFunction);
        volumeProperty.SetInterpolationTypeToLinear();
        // The mapper / ray cast function know how to render the data[]
        compositeFunction = new vtkVolumeRayCastCompositeFunction();
        volumeMapper      = new vtkVolumeRayCastMapper();
        //vtkVolumeTextureMapper2D volumeMapper[]
        volumeMapper.SetVolumeRayCastFunction((vtkVolumeRayCastFunction)compositeFunction);
        volumeMapper.SetInputConnection((vtkAlgorithmOutput)readerSS.GetOutputPort());
        // The volume holds the mapper and the property and[]
        // can be used to position/orient the volume[]
        volume = new vtkVolume();
        volume.SetMapper((vtkAbstractVolumeMapper)volumeMapper);
        volume.SetProperty((vtkVolumeProperty)volumeProperty);
        ren1.AddVolume((vtkProp)volume);
        //ren1 AddActor contourActor[]
        ren1.AddActor((vtkProp)boundsActor);
        //#####################################################################[]
        Sphere = new vtkSphereSource();
        Sphere.SetCenter((double)0, (double)0, (double)0);
        Sphere.SetRadius((double)1);
        Sphere.SetThetaResolution((int)16);
        Sphere.SetStartTheta((double)0);
        Sphere.SetEndTheta((double)360);
        Sphere.SetPhiResolution((int)16);
        Sphere.SetStartPhi((double)0);
        Sphere.SetEndPhi((double)180);
        Glyph = new vtkGlyph3D();
        Glyph.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
        Glyph.SetOrient((int)1);
        Glyph.SetColorMode((int)1);
        //Glyph ScalingOn[]
        Glyph.SetScaleMode((int)2);
        Glyph.SetScaleFactor((double).6);
        Glyph.SetSourceConnection(Sphere.GetOutputPort());
        AtomsMapper = vtkPolyDataMapper.New();
        AtomsMapper.SetInputConnection((vtkAlgorithmOutput)Glyph.GetOutputPort());
        AtomsMapper.SetImmediateModeRendering((int)1);
        AtomsMapper.UseLookupTableScalarRangeOff();
        AtomsMapper.SetScalarVisibility((int)1);
        AtomsMapper.SetScalarModeToDefault();
        Atoms = new vtkActor();
        Atoms.SetMapper((vtkMapper)AtomsMapper);
        Atoms.GetProperty().SetRepresentationToSurface();
        Atoms.GetProperty().SetInterpolationToGouraud();
        Atoms.GetProperty().SetAmbient((double)0.15);
        Atoms.GetProperty().SetDiffuse((double)0.85);
        Atoms.GetProperty().SetSpecular((double)0.1);
        Atoms.GetProperty().SetSpecularPower((double)100);
        Atoms.GetProperty().SetSpecularColor((double)1, (double)1, (double)1);
        Atoms.GetProperty().SetColor((double)1, (double)1, (double)1);
        Tube = new vtkTubeFilter();
        Tube.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
        Tube.SetNumberOfSides((int)16);
        Tube.SetCapping((int)0);
        Tube.SetRadius((double)0.2);
        Tube.SetVaryRadius((int)0);
        Tube.SetRadiusFactor((double)10);
        BondsMapper = vtkPolyDataMapper.New();
        BondsMapper.SetInputConnection((vtkAlgorithmOutput)Tube.GetOutputPort());
        BondsMapper.SetImmediateModeRendering((int)1);
        BondsMapper.UseLookupTableScalarRangeOff();
        BondsMapper.SetScalarVisibility((int)1);
        BondsMapper.SetScalarModeToDefault();
        Bonds = new vtkActor();
        Bonds.SetMapper((vtkMapper)BondsMapper);
        Bonds.GetProperty().SetRepresentationToSurface();
        Bonds.GetProperty().SetInterpolationToGouraud();
        Bonds.GetProperty().SetAmbient((double)0.15);
        Bonds.GetProperty().SetDiffuse((double)0.85);
        Bonds.GetProperty().SetSpecular((double)0.1);
        Bonds.GetProperty().SetSpecularPower((double)100);
        Bonds.GetProperty().SetSpecularColor((double)1, (double)1, (double)1);
        Bonds.GetProperty().SetColor((double)1, (double)1, (double)1);
        ren1.AddActor((vtkProp)Bonds);
        ren1.AddActor((vtkProp)Atoms);
        //###################################################[]
        ren1.SetBackground((double)1, (double)1, (double)1);
        ren1.ResetCamera();
        renWin.Render();
        //method moved

        renWin.AbortCheckEvt += new Kitware.VTK.vtkObject.vtkObjectEventHandler(TkCheckAbort_Command.Execute);
        iren.Initialize();

//deleteAllVTKObjects();
    }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetoutlineActor(vtkActor toSet)
 {
     outlineActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setbookshelf2FrontActor(vtkActor toSet)
 {
     bookshelf2FrontActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetconeActor(vtkActor toSet)
 {
     coneActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetconesActor(vtkActor toSet)
 {
     conesActor = toSet;
 }
Example #42
0
        private void renderWindowControl1_Load(object sender, EventArgs e)
        {
            // Create components of the rendering subsystem
            //
            vtkRenderer     ren1   = renderWindowControl1.RenderWindow.GetRenderers().GetFirstRenderer();
            vtkRenderWindow renWin = renderWindowControl1.RenderWindow;

            renWin.SetSize((int)paras.Height, (int)paras.Width);

            // Add the actors to the renderer, set the window size
            //
            vtkPoints      points  = vtkPoints.New();
            vtkCellArray   polys   = vtkCellArray.New();
            vtkFloatArray  scalars = vtkFloatArray.New();
            vtkLookupTable Luk     = vtkLookupTable.New();

            if (paras.Using3DTower == 1)
            {
                vtkActor   actor1  = new vtkActor();
                vtkActor2D actor2D = new vtkActor2D();
                if (paras.StageID != -1)
                {
                    if (paras.UsingEdges == 1)
                    {
                        MessageBox.Show("单元显示无法使用");
                    }
                    else
                    {
                        BasicVTKBuilder(ref actor1, ref points, ref polys, ref scalars, ref Luk, ref actor2D);
                        ren1.AddActor(actor1);
                        ren1.AddActor2D(actor2D);

                        vtkActor2D textActor = new vtkActor2D();
                        VTKInfoBuilder(ref textActor);
                        ren1.AddActor2D(textActor);
                    }
                }
                else
                {
                    if (paras.UsingEdges == 1)
                    {
                        ExtractEdgesVTKBuilderWithoutRunning(ref actor1, ref points, ref polys, ref scalars, ref Luk);
                    }
                    else
                    {
                        BasicVTKBuilderWithoutRunning(ref actor1, ref points, ref polys, ref scalars, ref Luk);
                    }
                    ren1.AddActor(actor1);
                }
            }

            if (paras.UsingVirtualHeater == 1)
            {
                //MessageBox.Show("!");
                vtkActor2D actor2 = VirtualHeaterVTKBuilder();
                ren1.AddActor(actor2);
            }


            renWin.Render();
            vtkCamera camera = ren1.GetActiveCamera();

            //camera.ParallelProjectionOn();
            //camera.Elevation(20);
            int[] camera_pos = new int[3];

            if (paras.globalEnv == 1)
            {
                camera_pos[1] = -70;
            }
            else
            {
                camera_pos[1] = -80;
            }

            if (paras.RotateAngle == 0)
            {
                camera_pos[1] = -camera_pos[1];
                camera_pos[0] = camera_pos[2] = 0;
                camera.SetRoll(-2);
            }
            else if (paras.RotateAngle == 180)
            {
                camera_pos[0] = camera_pos[2] = 0;
                camera.SetRoll(180);
            }
            else if (paras.RotateAngle == 90)
            {
                double r = (double)Math.Abs(camera_pos[1]);
                camera_pos[0] = (int)(-r * 0.707);
                camera_pos[1] = (int)(-r * 0.707);
                camera_pos[2] = 0;
                camera.SetRoll(225);
            }
            else if (paras.RotateAngle == 270)
            {
                double r = (double)Math.Abs(camera_pos[1]);
                camera_pos[0] = (int)(r * 0.707);
                camera_pos[1] = (int)(-r * 0.707);
                camera_pos[2] = 0;
                camera.SetRoll(135);
            }

            camera.SetPosition((double)camera_pos[0], (double)camera_pos[1], (double)camera_pos[2]);
            //camera.Yaw(10);
            camera.Elevation(1);
            camera.ParallelProjectionOn();
            camera.Zoom(0.9);
            StoredViewCamera = new List <vtkCamera>();
            for (int i = 0; i < 3; i++)
            {
                vtkCamera ViewCamera = new vtkCamera();


                if (i == 0)
                {
                    ViewCamera.SetPosition(camera.GetPosition()[0],
                                           camera.GetPosition()[1],
                                           camera.GetPosition()[2]);
                    ViewCamera.SetRoll(camera.GetRoll());
                }
                else if (i == 1)
                {
                    ViewCamera.SetPosition(80, 0, 0);
                    ViewCamera.SetRoll(180);
                }
                else if (i == 2)
                {
                    ViewCamera.SetPosition(0, 0, -80);
                    ViewCamera.SetRoll(camera.GetRoll());
                }
                ViewCamera.SetFocalPoint(camera.GetFocalPoint()[0],
                                         camera.GetFocalPoint()[1],
                                         camera.GetFocalPoint()[2]);
                ViewCamera.SetViewUp(camera.GetViewUp()[0],
                                     camera.GetViewUp()[1],
                                     camera.GetViewUp()[2]);
                StoredViewCamera.Add(ViewCamera);
            }

            //camera.Zoom(1.5);
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetinletActor(vtkActor toSet)
 {
     inletActor = toSet;
 }
Example #44
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);
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetwindowActor(vtkActor toSet)
 {
     windowActor = toSet;
 }
Example #46
0
        /// <summary>
        /// 绘制立长方体的边缘
        /// </summary>
        /// <param name="bgColor">边缘的颜色</param>
        /// <param name="actors">添加至该对象</param>
        public void AddContainerEdgeToActorCollection(byte[] bgColor, ref vtkActorCollection actors)
        {
            vtkProperty pp = vtkProperty.New();

            pp.SetOpacity(0.5);
            pp.SetColor(bgColor[0], bgColor[1], bgColor[2]);
            pp.SetLineWidth(5);
            pp.SetLighting(false);

            vtkCubeSource cs = vtkCubeSource.New();

            cs.SetCenter(sideLen / 2, sideLen / 2, height / 2);
            cs.SetXLength(sideLen);
            cs.SetYLength(sideLen);
            cs.SetZLength(height);

            #region 采用描点的方式绘制长方体 只需要添加到mapper.SetInput(pd);即可
            //vtkPoints points = vtkPoints.New();
            //points.InsertNextPoint(0 + offset[0], 0 + offset[1], 0 + offset[2]);
            //points.InsertNextPoint(sideLen + offset[0], 0 + offset[1], 0 + offset[2]);
            //points.InsertNextPoint(sideLen + offset[0], sideLen + offset[1], 0 + offset[2]);
            //points.InsertNextPoint(0 + offset[0], sideLen + offset[1], 0 + offset[2]);

            //points.InsertNextPoint(0 + offset[0], sideLen + offset[1], height + offset[2]);
            //points.InsertNextPoint(sideLen + offset[0], sideLen + offset[1], height + offset[2]);
            //points.InsertNextPoint(sideLen + offset[0], 0 + offset[1], height + offset[2]);
            //points.InsertNextPoint(0 + offset[0], 0 + offset[1], height + offset[2]);

            //vtkPolyData pd = vtkPolyData.New();

            //vtkLine line = vtkLine.New();

            //vtkCellArray cellArr = vtkCellArray.New();

            ////描出边框
            //for (int i = 0; i < 4; i++)
            //{
            //    line.GetPointIds().SetId(0, i);
            //    line.GetPointIds().SetId(1, (i + 1) % 4);
            //    cellArr.InsertNextCell(line);

            //    line.GetPointIds().SetId(0, i + 4);
            //    line.GetPointIds().SetId(1, (i + 1) % 4 + 4);
            //    cellArr.InsertNextCell(line);

            //    line.GetPointIds().SetId(0, i);
            //    line.GetPointIds().SetId(1, 7 - i);
            //    cellArr.InsertNextCell(line);

            //}

            //IntPtr iColor = Marshal.AllocHGlobal(bgColor.Length);
            //Marshal.Copy(bgColor, 0, iColor, bgColor.Length);

            //vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();

            //colors.SetNumberOfComponents(3);
            //for (int i = 0; i < cellArr.GetNumberOfCells(); i++)
            //{
            //    colors.InsertNextTupleValue(iColor);
            //}

            //pd.SetPoints(points);
            //pd.SetLines(cellArr);
            //pd.GetCellData().SetScalars(colors);
            //Marshal.FreeHGlobal(iColor);
            #endregion

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
            //mapper.SetInput(pd);
            mapper.SetInputConnection(cs.GetOutputPort());
            vtkActor actor = vtkActor.New();
            actor.SetMapper(mapper);
            actor.SetProperty(pp);

            actors.AddItem(actor);
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setbookshelf2BottomActor(vtkActor toSet)
 {
     bookshelf2BottomActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetmoldActor(vtkActor toSet)
 {
     moldActor = toSet;
 }
Example #49
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setplane1Actor(vtkActor toSet)
 {
     plane1Actor = toSet;
 }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVfieldToUGrid(String [] argv)
    {
        //Prefix Content is: ""

          // Read a field representing unstructured grid and display it (similar to blow.tcl)[]
          // create a reader and write out field daya[]
          reader = new vtkUnstructuredGridReader();
          reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/blow.vtk");
          reader.SetScalarsName((string)"thickness9");
          reader.SetVectorsName((string)"displacement9");
          ds2do = new vtkDataSetToDataObjectFilter();
          ds2do.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          // we must be able to write here[]
          try
          {
         channel = new StreamWriter("UGridField.vtk");
          tryCatchError = "NOERROR";
          }
          catch(Exception)
          {tryCatchError = "ERROR";}

          if (tryCatchError.Equals("NOERROR"))
          {
          channel.Close();
          write = new vtkDataObjectWriter();
          write.SetInputConnection((vtkAlgorithmOutput)ds2do.GetOutputPort());
          write.SetFileName((string)"UGridField.vtk");
          write.Write();
          // Read the field and convert to unstructured grid.[]
          dor = new vtkDataObjectReader();
          dor.SetFileName((string)"UGridField.vtk");
          do2ds = new vtkDataObjectToDataSetFilter();
          do2ds.SetInputConnection((vtkAlgorithmOutput)dor.GetOutputPort());
          do2ds.SetDataSetTypeToUnstructuredGrid();
          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.SetCellTypeComponent((string)"CellTypes",(int)0);
          do2ds.SetCellConnectivityComponent((string)"Cells",(int)0);
          fd2ad = new vtkFieldDataToAttributeDataFilter();
          fd2ad.SetInput((vtkDataObject)do2ds.GetUnstructuredGridOutput());
          fd2ad.SetInputFieldToDataObjectField();
          fd2ad.SetOutputAttributeDataToPointData();
          fd2ad.SetVectorComponent((int)0,(string)"displacement9",(int)0);
          fd2ad.SetVectorComponent((int)1,(string)"displacement9",(int)1);
          fd2ad.SetVectorComponent((int)2,(string)"displacement9",(int)2);
          fd2ad.SetScalarComponent((int)0,(string)"thickness9",(int)0);
          // Now start visualizing[]
          warp = new vtkWarpVector();
          warp.SetInput((vtkDataObject)fd2ad.GetUnstructuredGridOutput());
          // extract mold from mesh using connectivity[]
          connect = new vtkConnectivityFilter();
          connect.SetInputConnection((vtkAlgorithmOutput)warp.GetOutputPort());
          connect.SetExtractionModeToSpecifiedRegions();
          connect.AddSpecifiedRegion((int)0);
          connect.AddSpecifiedRegion((int)1);
          moldMapper = new vtkDataSetMapper();
          moldMapper.SetInputConnection((vtkAlgorithmOutput)connect.GetOutputPort());
          moldMapper.ScalarVisibilityOff();
          moldActor = new vtkActor();
          moldActor.SetMapper((vtkMapper)moldMapper);
          moldActor.GetProperty().SetColor((double).2,(double).2,(double).2);
          moldActor.GetProperty().SetRepresentationToWireframe();
          // extract parison from mesh using connectivity[]
          connect2 = new vtkConnectivityFilter();
          connect2.SetInputConnection((vtkAlgorithmOutput)warp.GetOutputPort());
          connect2.SetExtractionModeToSpecifiedRegions();
          connect2.AddSpecifiedRegion((int)2);
          parison = new vtkGeometryFilter();
          parison.SetInputConnection((vtkAlgorithmOutput)connect2.GetOutputPort());
          normals2 = new vtkPolyDataNormals();
          normals2.SetInputConnection((vtkAlgorithmOutput)parison.GetOutputPort());
          normals2.SetFeatureAngle((double)60);
          lut = new vtkLookupTable();
          lut.SetHueRange((double)0.0,(double)0.66667);
          parisonMapper = vtkPolyDataMapper.New();
          parisonMapper.SetInputConnection((vtkAlgorithmOutput)normals2.GetOutputPort());
          parisonMapper.SetLookupTable((vtkScalarsToColors)lut);
          parisonMapper.SetScalarRange((double)0.12,(double)1.0);
          parisonActor = new vtkActor();
          parisonActor.SetMapper((vtkMapper)parisonMapper);
          cf = new vtkContourFilter();
          cf.SetInputConnection((vtkAlgorithmOutput)connect2.GetOutputPort());
          cf.SetValue((int)0,(double).5);
          contourMapper = vtkPolyDataMapper.New();
          contourMapper.SetInputConnection((vtkAlgorithmOutput)cf.GetOutputPort());
          contours = new vtkActor();
          contours.SetMapper((vtkMapper)contourMapper);
          // Create graphics stuff[]
          ren1 = vtkRenderer.New();
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)ren1);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          // Add the actors to the renderer, set the background and size[]
          ren1.AddActor((vtkProp)moldActor);
          ren1.AddActor((vtkProp)parisonActor);
          ren1.AddActor((vtkProp)contours);
          ren1.ResetCamera();
          ren1.GetActiveCamera().Azimuth((double)60);
          ren1.GetActiveCamera().Roll((double)-90);
          ren1.GetActiveCamera().Dolly((double)2);
          ren1.ResetCameraClippingRange();
          ren1.SetBackground((double)1,(double)1,(double)1);
          renWin.SetSize((int)375,(int)200);
          iren.Initialize();
        }

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

        //deleteAllVTKObjects();
    }
        private void BandedPolyDataContourFilter()
        {
            vtkPoints pts = vtkPoints.New();

            pts.InsertPoint(0, 0, 0, 0);
            pts.InsertPoint(1, 0, 1, 0);
            pts.InsertPoint(2, 0, 2, 0);
            pts.InsertPoint(3, 1, 0, 0);
            pts.InsertPoint(4, 1, 1, 0);
            pts.InsertPoint(5, 1, 2, 0);
            pts.InsertPoint(6, 2, 0, 0);
            pts.InsertPoint(7, 2, 2, 0);
            pts.InsertPoint(8, 3, 0, 0);
            pts.InsertPoint(9, 3, 1, 0);
            pts.InsertPoint(10, 3, 2, 0);
            pts.InsertPoint(11, 4, 0, 0);
            pts.InsertPoint(12, 6, 0, 0);
            pts.InsertPoint(13, 5, 2, 0);
            pts.InsertPoint(14, 7, 0, 0);
            pts.InsertPoint(15, 9, 0, 0);
            pts.InsertPoint(16, 7, 2, 0);
            pts.InsertPoint(17, 9, 2, 0);
            pts.InsertPoint(18, 10, 0, 0);
            pts.InsertPoint(19, 12, 0, 0);
            pts.InsertPoint(20, 10, 1, 0);
            pts.InsertPoint(21, 12, 1, 0);
            pts.InsertPoint(22, 10, 2, 0);
            pts.InsertPoint(23, 12, 2, 0);
            pts.InsertPoint(24, 10, 3, 0);
            pts.InsertPoint(25, 12, 3, 0);

            vtkCellArray polys = vtkCellArray.New();

            polys.InsertNextCell(4);
            polys.InsertCellPoint(14);
            polys.InsertCellPoint(15);
            polys.InsertCellPoint(17);
            polys.InsertCellPoint(16);
            polys.InsertNextCell(3);
            polys.InsertCellPoint(11);
            polys.InsertCellPoint(12);
            polys.InsertCellPoint(13);

            vtkFloatArray scalars = vtkFloatArray.New();

            scalars.SetNumberOfTuples(26);
            scalars.SetTuple1(0, 0);
            scalars.SetTuple1(1, 50);
            scalars.SetTuple1(2, 100);
            scalars.SetTuple1(3, 0);
            scalars.SetTuple1(4, 50);
            scalars.SetTuple1(5, 100);
            scalars.SetTuple1(6, 10);
            scalars.SetTuple1(7, 90);
            scalars.SetTuple1(8, 10);
            scalars.SetTuple1(9, 50);
            scalars.SetTuple1(10, 90);
            scalars.SetTuple1(11, 10);
            scalars.SetTuple1(12, 40);
            scalars.SetTuple1(13, 100);
            scalars.SetTuple1(14, 0);
            scalars.SetTuple1(15, 60);
            scalars.SetTuple1(16, 40);
            scalars.SetTuple1(17, 100);
            scalars.SetTuple1(18, 0);
            scalars.SetTuple1(19, 25);
            scalars.SetTuple1(20, 25);
            scalars.SetTuple1(21, 50);
            scalars.SetTuple1(22, 50);
            scalars.SetTuple1(23, 75);
            scalars.SetTuple1(24, 75);
            scalars.SetTuple1(25, 100);

            vtkPolyData polyData = vtkPolyData.New();

            polyData.SetPoints(pts);
            polyData.SetPolys(polys);
            polyData.GetPointData().SetScalars(scalars);

            vtkBandedPolyDataContourFilter bf = vtkBandedPolyDataContourFilter.New();

#if VTK_MAJOR_VERSION_5
            bf.SetInput(polyData);
#else
            bf.SetInputData(polyData);
#endif
            bf.GenerateValues(3, 25, 75);

            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
            mapper.SetInputConnection(bf.GetOutputPort());
            mapper.SetScalarModeToUseCellData();
            mapper.SetScalarRange(0, 4);
            vtkActor actor = vtkActor.New();
            actor.SetMapper(mapper);

            // 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(actor);
        }
Example #52
0
        private void PolygonalSurfaceContourLineInterpolator()
        {
            vtkPolyData     polyData;
            vtkSphereSource sphereSource = vtkSphereSource.New();

            sphereSource.SetThetaResolution(40);
            sphereSource.SetPhiResolution(20);
            sphereSource.Update();

            polyData = sphereSource.GetOutput();
            // The Dijkstra interpolator will not accept cells that aren't triangles
            vtkTriangleFilter triangleFilter = vtkTriangleFilter.New();

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

            vtkPolyData pd = triangleFilter.GetOutput();

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

            vtkActor actor = vtkActor.New();
            actor.SetMapper(mapper);
            actor.GetProperty().SetInterpolationToFlat();

            // get a reference to the renderwindow of our renderWindowControl1
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            // renderer
            vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
            // set background color
            renderer.SetBackground(0.3, 0.4, 0.5);
            // add our actor to the renderer
            renderer.AddActor(actor);

            // Here comes the contour widget stuff.....
            vtkContourWidget contourWidget = vtkContourWidget.New();
            contourWidget.SetInteractor(renderWindow.GetInteractor());
            vtkOrientedGlyphContourRepresentation rep =
                vtkOrientedGlyphContourRepresentation.SafeDownCast(
                    contourWidget.GetRepresentation());
            rep.GetLinesProperty().SetColor(1, 0.2, 0);
            rep.GetLinesProperty().SetLineWidth(3.0f);

            vtkPolygonalSurfacePointPlacer pointPlacer =
                vtkPolygonalSurfacePointPlacer.New();
            pointPlacer.AddProp(actor);
            pointPlacer.GetPolys().AddItem(pd);
            rep.SetPointPlacer(pointPlacer);

            vtkPolygonalSurfaceContourLineInterpolator interpolator =
                vtkPolygonalSurfaceContourLineInterpolator.New();
            interpolator.GetPolys().AddItem(pd);
            rep.SetLineInterpolator(interpolator);

            renderWindow.Render();
            contourWidget.EnabledOn();
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setcontours(vtkActor toSet)
 {
     contours = toSet;
 }
Example #54
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVEnSightRectGridBin(String [] argv)
    {
        //Prefix Content is: ""

        VTK_VARY_RADIUS_BY_VECTOR = 2;
        // create pipeline[]
        //[]
        reader = new vtkGenericEnSightReader();
        // Make sure all algorithms use the composite data pipeline[]
        cdp = new vtkCompositeDataPipeline();
        vtkGenericEnSightReader.SetDefaultExecutivePrototype((vtkExecutive)cdp);
        reader.SetCaseFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/EnSight/RectGrid_bin.case");
        reader.Update();
        toRectilinearGrid = new vtkCastToConcrete();
        //    toRectilinearGrid SetInputConnection [reader GetOutputPort] []
        toRectilinearGrid.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
        toRectilinearGrid.Update();
        plane = new vtkRectilinearGridGeometryFilter();
        plane.SetInputData((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
        plane.SetExtent((int)0, (int)100, (int)0, (int)100, (int)15, (int)15);
        tri = new vtkTriangleFilter();
        tri.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
        warper = new vtkWarpVector();
        warper.SetInputConnection((vtkAlgorithmOutput)tri.GetOutputPort());
        warper.SetScaleFactor((double)0.05);
        planeMapper = new vtkDataSetMapper();
        planeMapper.SetInputConnection((vtkAlgorithmOutput)warper.GetOutputPort());
        planeMapper.SetScalarRange((double)0.197813, (double)0.710419);
        planeActor = new vtkActor();
        planeActor.SetMapper((vtkMapper)planeMapper);

        cutPlane = new vtkPlane();
        //    eval cutPlane SetOrigin [[reader GetOutput] GetCenter][]
        cutPlane.SetOrigin(
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetCenter()[0],
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetCenter()[1],
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetCenter()[2]);
        cutPlane.SetNormal((double)1, (double)0, (double)0);
        planeCut = new vtkCutter();
        planeCut.SetInputData((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
        planeCut.SetCutFunction((vtkImplicitFunction)cutPlane);
        cutMapper = new vtkDataSetMapper();
        cutMapper.SetInputConnection((vtkAlgorithmOutput)planeCut.GetOutputPort());
        cutMapper.SetScalarRange(
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[0],
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[1]);
        cutActor = new vtkActor();
        cutActor.SetMapper((vtkMapper)cutMapper);

        iso = new vtkContourFilter();
        iso.SetInputData((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
        iso.SetValue((int)0, (double)0.7);
        normals = new vtkPolyDataNormals();
        normals.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
        normals.SetFeatureAngle((double)45);
        isoMapper = vtkPolyDataMapper.New();
        isoMapper.SetInputConnection((vtkAlgorithmOutput)normals.GetOutputPort());
        isoMapper.ScalarVisibilityOff();
        isoActor = new vtkActor();
        isoActor.SetMapper((vtkMapper)isoMapper);
        isoActor.GetProperty().SetColor((double)1.0000, 0.8941, 0.7686);
        isoActor.GetProperty().SetRepresentationToWireframe();

        streamer = new vtkStreamLine();
        //    streamer SetInputConnection [reader GetOutputPort][]
        streamer.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
        streamer.SetStartPosition((double)-1.2, (double)-0.1, (double)1.3);
        streamer.SetMaximumPropagationTime((double)500);
        streamer.SetStepLength((double)0.05);
        streamer.SetIntegrationStepLength((double)0.05);
        streamer.SetIntegrationDirectionToIntegrateBothDirections();

        streamTube = new vtkTubeFilter();
        streamTube.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
        streamTube.SetRadius((double)0.025);
        streamTube.SetNumberOfSides((int)6);
        streamTube.SetVaryRadius((int)VTK_VARY_RADIUS_BY_VECTOR);
        mapStreamTube = vtkPolyDataMapper.New();
        mapStreamTube.SetInputConnection((vtkAlgorithmOutput)streamTube.GetOutputPort());
        mapStreamTube.SetScalarRange(
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[0],
            (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[1]);
        //       [[[[reader GetOutput] GetPointData] GetScalars] GetRange][]
        streamTubeActor = new vtkActor();
        streamTubeActor.SetMapper((vtkMapper)mapStreamTube);
        streamTubeActor.GetProperty().BackfaceCullingOn();

        outline = new vtkOutlineFilter();
        outline.SetInputData((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
        outlineMapper = vtkPolyDataMapper.New();
        outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
        outlineActor = new vtkActor();
        outlineActor.SetMapper((vtkMapper)outlineMapper);
        outlineActor.GetProperty().SetColor((double)0.0000, 0.0000, 0.0000);

        // Graphics stuff[]
        // Create the RenderWindow, Renderer and both Actors[]
        //[]
        ren1   = vtkRenderer.New();
        renWin = vtkRenderWindow.New();
        renWin.SetMultiSamples(0);
        renWin.AddRenderer((vtkRenderer)ren1);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);

        // Add the actors to the renderer, set the background and size[]
        //[]
        ren1.AddActor((vtkProp)outlineActor);
        ren1.AddActor((vtkProp)planeActor);
        ren1.AddActor((vtkProp)cutActor);
        ren1.AddActor((vtkProp)isoActor);
        ren1.AddActor((vtkProp)streamTubeActor);

        ren1.SetBackground((double)1, (double)1, (double)1);
        renWin.SetSize((int)400, (int)400);

        cam1 = ren1.GetActiveCamera();
        cam1.SetClippingRange((double)3.76213, (double)10.712);
        cam1.SetFocalPoint((double)-0.0842503, (double)-0.136905, (double)0.610234);
        cam1.SetPosition((double)2.53813, (double)2.2678, (double)-5.22172);
        cam1.SetViewUp((double)-0.241047, (double)0.930635, (double)0.275343);

        iren.Initialize();
        // render the image[]
        //[]
        // prevent the tk window from showing up then start the event loop[]
        vtkGenericEnSightReader.SetDefaultExecutivePrototype(null);
//deleteAllVTKObjects();
    }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetparisonActor(vtkActor toSet)
 {
     parisonActor = toSet;
 }
Example #56
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetplaneActor(vtkActor toSet)
 {
     planeActor = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setactor(vtkActor toSet)
 {
     actor = toSet;
 }
Example #58
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetcutActor(vtkActor toSet)
 {
     cutActor = toSet;
 }
Example #59
0
        private void WeightedTransformFilter()
        {
            // Use a sphere as a basis of the shape
            vtkSphereSource sphere = vtkSphereSource.New();

            sphere.SetPhiResolution(40);
            sphere.SetThetaResolution(40);
            sphere.Update();

            vtkPolyData sphereData = sphere.GetOutput();

            // Create a data array to hold the weighting coefficients
            vtkFloatArray tfarray = vtkFloatArray.New();
            int           npoints = sphereData.GetNumberOfPoints();

            tfarray.SetNumberOfComponents(2);
            tfarray.SetNumberOfTuples(npoints);

            // Parameterize the sphere along the z axis, and fill the weights
            // with (1.0-a, a) to linearly interpolate across the shape
            IntPtr pPoint = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 3);

            double[] point = new double[3];
            for (int i = 0; i < npoints; i++)
            {
                sphereData.GetPoint(i, pPoint);
                Marshal.Copy(pPoint, point, 0, 3);
                double x = point[0];
                double y = point[1];
                double z = point[2];

                double zn  = z + 0.5;
                double zn1 = 1.0 - zn;
                if (zn > 1.0)
                {
                    zn = 1.0;
                }
                if (zn1 < 0.0)
                {
                    zn1 = 0.0;
                }

                tfarray.SetComponent(i, 0, zn1);
                tfarray.SetComponent(i, 1, zn);
            }
            Marshal.FreeHGlobal(pPoint);

            // Create field data to hold the array, and bind it to the sphere
            vtkFieldData fd = vtkFieldData.New();

            tfarray.SetName("weights");
            sphereData.GetPointData().AddArray(tfarray);

            // Use an ordinary transform to stretch the shape
            vtkTransform stretch = vtkTransform.New();

            stretch.Scale(1, 1, 3.2);

            vtkTransformFilter stretchFilter = vtkTransformFilter.New();

            stretchFilter.SetInputConnection(sphereData.GetProducerPort());
            stretchFilter.SetTransform(stretch);

            // Now, for the weighted transform stuff
            vtkWeightedTransformFilter weightedTrans = vtkWeightedTransformFilter.New();

            // Create two transforms to interpolate between
            vtkTransform identity = vtkTransform.New();

            identity.Identity();

            vtkTransform rotated      = vtkTransform.New();
            double       rotatedAngle = 45;

            rotated.RotateX(rotatedAngle);

            weightedTrans.SetNumberOfTransforms(2);
            weightedTrans.SetTransform(identity, 0);
            weightedTrans.SetTransform(rotated, 1);
            // which data array should the filter use ?
            weightedTrans.SetWeightArray("weights");

            weightedTrans.SetInputConnection(stretchFilter.GetOutputPort());

            vtkPolyDataMapper weightedTransMapper = vtkPolyDataMapper.New();

            weightedTransMapper.SetInputConnection(weightedTrans.GetOutputPort());
            vtkActor weightedTransActor = vtkActor.New();

            weightedTransActor.SetMapper(weightedTransMapper);
            weightedTransActor.GetProperty().SetDiffuseColor(0.8, 0.8, 0.1);
            weightedTransActor.GetProperty().SetRepresentationToSurface();

            // get a reference to the renderwindow of our renderWindowControl1
            vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
            // renderer
            vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();

            // set background color
            renderer.SetBackground(0.2, 0.3, 0.4);
            // add our actor to the renderer
            renderer.AddActor(weightedTransActor);

            renderer.ResetCamera();
            renderer.GetActiveCamera().Azimuth(90);
            renderer.GetActiveCamera().Dolly(1);
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetsphereActor(vtkActor toSet)
 {
     sphereActor = toSet;
 }