Beispiel #1
0
        private void PlatonicSolid()
        {
            vtkPlatonicSolidSource platonicSolidSource = vtkPlatonicSolidSource.New();

            platonicSolidSource.SetSolidTypeToOctahedron();

            // Each face has a different cell scalar
            vtkLookupTable lut = vtkLookupTable.New();

            lut.SetNumberOfTableValues(8);
            lut.SetTableRange(0.0, 7.0);
            lut.Build();
            lut.SetTableValue(0, 0, 0, 0, 1);
            lut.SetTableValue(1, 0, 0, 1, 1);
            lut.SetTableValue(2, 0, 1, 0, 1);
            lut.SetTableValue(3, 0, 1, 1, 1);
            lut.SetTableValue(4, 1, 0, 0, 1);
            lut.SetTableValue(5, 1, 0, 1, 1);
            lut.SetTableValue(6, 1, 1, 0, 1);
            lut.SetTableValue(7, 1, 1, 1, 1);

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

            mapper.SetInputConnection(platonicSolidSource.GetOutputPort());
            mapper.SetLookupTable(lut);
            mapper.SetScalarRange(0, 7);

            vtkActor actor = vtkActor.New();

            actor.SetMapper(mapper);


            RenderAddActor(actor);
        }
Beispiel #2
0
 protected DatasetUnit()
 {
     lookupTable = vtkLookupTable.New();
     lookupTable.SetNumberOfColors(100);
     lookupTable.SetHueRange(0.67, 0.0);
     lookupTable.Build();
     scalarBarActor.SetOrientationToHorizontal();
     scalarBarActor.SetLookupTable(lookupTable);
     scalarBarActor.SetTitle(fieldName);
     scalarBarActor.GetAnnotationTextProperty().SetColor(0, 0, 0);
     scalarBarActor.GetTitleTextProperty().SetColor(0, 0, 0);
     scalarBarActor.GetLabelTextProperty().SetColor(0, 0, 0);
     scalarBarActor.GetAnnotationTextProperty().SetFontSize(20);
     scalarBarActor.GetTitleTextProperty().SetFontSize(20);
     scalarBarActor.GetLabelTextProperty().SetFontSize(20);
     scalarBarActor.GetAnnotationTextProperty().SetFontFamilyToArial();
     scalarBarActor.GetTitleTextProperty().SetFontFamilyToArial();
     scalarBarActor.GetLabelTextProperty().SetFontFamilyToArial();
     scalarBarActor.GetAnnotationTextProperty().ItalicOff();
     scalarBarActor.GetTitleTextProperty().ItalicOff();
     scalarBarActor.GetLabelTextProperty().ItalicOff();
     scalarBarActor.GetAnnotationTextProperty().BoldOff();
     scalarBarActor.GetTitleTextProperty().BoldOff();
     scalarBarActor.GetLabelTextProperty().BoldOff();
     scalarBarActor.SetUnconstrainedFontSize(true);
     scalarBarActor.SetBarRatio(0.15);
     scalarBarActor.SetNumberOfLabels(11);
 }
Beispiel #3
0
 private void CreateColorMap()
 {
     // Create the color map
     colorLookupTable = vtkLookupTable.New();
     LegendStyle1();
     colorLookupTable.Build();
 }
        public static vtkLookupTable Create(LutPreset preset, double rangeMin, double rangeMax)
        {
            var lut = new vtkLookupTable();
            lut.SetTableRange(rangeMin, rangeMax);
            switch (preset)
            {
                case LutPreset.BlueRed:
                    lut.SetHueRange(0.66, 1.0);
                    lut.SetNumberOfColors(128);
                    break;
                case LutPreset.RedBlue:
                    lut.SetHueRange(1.0, 0.66);
                    lut.SetNumberOfColors(128);
                    //lut.SetNumberOfTableValues(2);
                    //lut.SetTableValue(0, 1.0, 0.0, 0.0, 1.0);
                    //lut.SetTableValue(1, 0.0, 0.0, 1.0, 1.0);
                    break;
                case LutPreset.Rainbow:
                    lut.SetHueRange(0.0, 0.66);
                    lut.SetNumberOfColors(256);
                    break;
            }
            lut.Build();

            return lut;
        }
Beispiel #5
0
 public void SetColorArray(string name, bool pointData, vtkLookupTable lut)
 {
     for(var i = 0; i < Meshes.Count; i++)
     {
         vtkDataArray dataArray;
         if (pointData)
             dataArray = _pds[i].GetPointData().GetArray(name);
         else
             dataArray = _pds[i].GetCellData().GetArray(name);
         SetColors(Meshes[i], dataArray, lut);
     }
 }
Beispiel #6
0
        public void ExtractEdgesVTKBuilderWithoutRunning(ref vtkActor actor, ref vtkPoints points, ref vtkCellArray polys,
                                                         ref vtkFloatArray scalars, ref vtkLookupTable Luk)
        {
            int pointsNum = 0;

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

            vtkPolyData profile = vtkPolyData.New();

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

            vtkExtractEdges ExtProfile = new vtkExtractEdges();


            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();

            if (paras.RotateAngle == 0)
            {
                profile.GetCellData().SetScalars(scalars);
                ExtProfile.SetInput(profile);
                mapper.SetInputConnection(ExtProfile.GetOutputPort());
            }
            else
            {
                vtkRotationalExtrusionFilter refilter = vtkRotationalExtrusionFilter.New();
                profile.Update();
                profile.GetCellData().SetScalars(scalars);
                //profile.GetPointData().SetScalars(scalars);
                ExtProfile.SetInput(profile);

                refilter.SetInputConnection(ExtProfile.GetOutputPort());
                refilter.SetResolution(50);
                refilter.SetAngle(paras.RotateAngle);
                refilter.SetTranslation(0);
                refilter.SetDeltaRadius(0);

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

            Luk.SetNumberOfTableValues(7);
            Luk.SetTableValue(0, 0, 1, 0, 1);   //
            Luk.SetTableValue(1, 0, 0, 0.8, 1); //inner surface
            Luk.SetTableValue(2, 0, 1, 0, 1);   //
            Luk.SetTableValue(3, 0, 0, 1, 1);
            Luk.SetTableValue(4, 0, 0, 0.8, 1); //insider
            Luk.SetTableValue(5, 0, 0.8, 0, 1); //outer surface
            Luk.Build();
        }
        //切片模式_初始化颜色
        private void InitializeColor_Slice(ExGrid Grid)
        {
            m_LookupTable = vtkLookupTable.New();
            m_LookupTable.SetTableRange(Grid.Min, Grid.Max);
            //蓝色->红色
            m_LookupTable.SetHueRange(0.667, 0);
            m_LookupTable.SetNumberOfColors(100);
            m_LookupTable.Build();

            //线性插值透明度
            m_PiecewiseFunction = vtkPiecewiseFunction.New();
            m_PiecewiseFunction.AddPoint(Grid.Min, 1);
            m_PiecewiseFunction.AddPoint(Grid.Max, 1);
        }
Beispiel #8
0
 public void SetColors(Mesh mesh, vtkDataArray colorArray, vtkLookupTable lut)
 {
     var numVertices = mesh.vertexCount;
     if (numVertices <= 0 || colorArray == null)
         return;
     var colors = new Color32[numVertices];
     for (var i = 0; i < numVertices; ++i)
     {
         var scalar = colorArray.GetTuple1(i);
         var dcolor = lut.GetColor(scalar);
         var color = new byte[3];
         for (uint j = 0; j < 3; j++)
             color[j] = (byte)(255 * dcolor[j]);
         colors[i] = new Color32(color[0], color[1], color[2], 255);
     }
     mesh.colors32 = colors;
 }
        //wizualizacja 3d -----------------------------------------------------------------
        public Visualization3D(RenderWindowControl window, vtkDICOMImageReader dicomReader)
        {
            this.window       = window;
            this.dicomReader  = dicomReader;
            this.presetMapper = new PresetMapper();

            vtkRenderer renderer = window.RenderWindow.GetRenderers().GetFirstRenderer();

            vtkSmartVolumeMapper mapper = vtkSmartVolumeMapper.New();

            vol = vtkVolume.New();

            vtkLookupTable bwLut = vtkLookupTable.New();

            bwLut.SetTableRange(0, 2000);
            bwLut.SetSaturationRange(0, 0);
            bwLut.SetHueRange(0, 0);
            bwLut.SetValueRange(0, 1);
            bwLut.Build(); //effective built

            vtkImageMapToColors sagittalColors = vtkImageMapToColors.New();

            sagittalColors.SetInputConnection(dicomReader.GetOutputPort());
            sagittalColors.SetLookupTable(bwLut);
            sagittalColors.Update();
            vtkImageActor sagittal = vtkImageActor.New();

            sagittal.SetInput(sagittalColors.GetOutput());
            sagittal.SetDisplayExtent(117, 117, 0, 173, 1, 180);

            vtkImageReslice reslicer = vtkImageReslice.New();

            reslicer.SetResliceAxesDirectionCosines(1, 0, 0, 2, 0, 0, 0, 0, 0);

            mapper.SetInputConnection(dicomReader.GetOutputPort());

            this.setColorFunction();
            this.setOpacityFunction();
            this.setGradientOpacity();

            vol.SetMapper(mapper);

            renderer.AddActor(sagittal);
            renderer.AddVolume(vol);
        }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestImageStreamer(String [] argv)
    {
        //Prefix Content is: ""

          reader = new vtkImageReader();
          reader.ReleaseDataFlagOff();
          reader.SetDataByteOrderToLittleEndian();
          reader.SetDataExtent((int)0,(int)63,(int)0,(int)63,(int)1,(int)93);
          reader.SetFilePrefix((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/headsq/quarter");
          reader.SetDataMask((int)0x7fff);
          rangeStart = 0.0;
          rangeEnd = 0.2;
          LUT = new vtkLookupTable();
          LUT.SetTableRange((double)0,(double)1800);
          LUT.SetSaturationRange((double)1,(double)1);
          LUT.SetHueRange((double)rangeStart,(double)rangeEnd);
          LUT.SetValueRange((double)1,(double)1);
          LUT.SetAlphaRange((double)1,(double)1);
          LUT.Build();
          // added these unused default arguments so that the prototype[]
          // matches as required in python.[]
          //method moved
          mapToRGBA = new vtkImageMapToColors();
          mapToRGBA.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
          mapToRGBA.SetOutputFormatToRGBA();
          mapToRGBA.SetLookupTable((vtkScalarsToColors)LUT);

          mapToRGBA.EndEvt += new Kitware.VTK.vtkObject.vtkObjectEventHandler(changeLUT_Command.Execute);

          streamer = new vtkMemoryLimitImageDataStreamer();
          streamer.SetInputConnection((vtkAlgorithmOutput)mapToRGBA.GetOutputPort());
          streamer.SetMemoryLimit((uint)100);
          streamer.UpdateWholeExtent();
          // set the window/level to 255.0/127.5 to view full range[]
          viewer = new vtkImageViewer();
          viewer.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
          viewer.SetColorWindow((double)255.0);
          viewer.SetColorLevel((double)127.5);
          viewer.SetZSlice((int)50);
          viewer.Render();

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

        reader = new vtkImageReader();
        reader.ReleaseDataFlagOff();
        reader.SetDataByteOrderToLittleEndian();
        reader.SetDataExtent((int)0, (int)63, (int)0, (int)63, (int)1, (int)93);
        reader.SetFilePrefix((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/headsq/quarter");
        reader.SetDataMask((int)0x7fff);
        rangeStart = 0.0;
        rangeEnd   = 0.2;
        LUT        = new vtkLookupTable();
        LUT.SetTableRange((double)0, (double)1800);
        LUT.SetSaturationRange((double)1, (double)1);
        LUT.SetHueRange((double)rangeStart, (double)rangeEnd);
        LUT.SetValueRange((double)1, (double)1);
        LUT.SetAlphaRange((double)1, (double)1);
        LUT.Build();
        // added these unused default arguments so that the prototype[]
        // matches as required in python.[]
        //method moved
        mapToRGBA = new vtkImageMapToColors();
        mapToRGBA.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
        mapToRGBA.SetOutputFormatToRGBA();
        mapToRGBA.SetLookupTable((vtkScalarsToColors)LUT);

        mapToRGBA.EndEvt += new Kitware.VTK.vtkObject.vtkObjectEventHandler(changeLUT_Command.Execute);

        streamer = new vtkMemoryLimitImageDataStreamer();
        streamer.SetInputConnection((vtkAlgorithmOutput)mapToRGBA.GetOutputPort());
        streamer.SetMemoryLimit((uint)100);
        streamer.UpdateWholeExtent();
        // set the window/level to 255.0/127.5 to view full range[]
        viewer = new vtkImageViewer();
        viewer.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
        viewer.SetColorWindow((double)255.0);
        viewer.SetColorLevel((double)127.5);
        viewer.SetZSlice((int)50);
        viewer.Render();

//deleteAllVTKObjects();
    }
        //镂空模式_初始化颜色
        private void InitializeColor_HollowOut(ExGrid Grid)
        {
            m_LookupTable = vtkLookupTable.New();
            m_LookupTable.SetTableRange(Grid.Min, Grid.Max);
            //蓝色->红色
            m_LookupTable.SetHueRange(0.666667, 0);
            m_LookupTable.SetNumberOfColors(100);
            m_LookupTable.Build();

            //设定标量值的颜色
            m_ColorTransferFunction = vtkColorTransferFunction.New();
            for (int i = 0; i < 100; i += 10)
            {
                var    color = m_LookupTable.GetTableValue(i);
                double Range = Grid.Max - Grid.Min;
                m_ColorTransferFunction.AddRGBPoint(Grid.Min + i * Range / 100.0, color[0], color[1], color[2]);
            }
            m_ColorTransferFunction.Build();

            //线性插值透明度
            m_PiecewiseFunction = vtkPiecewiseFunction.New();
            // [,)
            InitRanges();

            foreach (var range in m_IntersectRanges)
            {
                double Min = range.Min;
                double Max = range.Max;
                ////由于VTK的特性,对Max进行修正
                //如果透明
                if (range.Transparent)
                {
                    m_PiecewiseFunction.AddSegment(Min, Transparency_Yes, Max, Transparency_Yes);
                }
                //不透明
                else
                {
                    Min = Min + EPSILON;
                    Max = Max - EPSILON;
                    m_PiecewiseFunction.AddSegment(Min, Transparency_Not, Max, Transparency_Not);
                }
            }
        }
Beispiel #13
0
        private void ReadDEM()
        {
            // 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\SainteHelens.dem");

            vtkDEMReader reader = vtkDEMReader.New();

            reader.SetFileName(filePath);
            reader.Update();

            vtkLookupTable lut = vtkLookupTable.New();

            lut.SetHueRange(0.6, 0);
            lut.SetSaturationRange(1.0, 0);
            lut.SetValueRange(0.5, 1.0);
            double[] range = reader.GetOutput().GetScalarRange();
            lut.SetTableRange(range[0], range[1]);

            // Visualize
            vtkImageMapToColors mapColors = vtkImageMapToColors.New();

            mapColors.SetLookupTable(lut);
            mapColors.SetInputConnection(reader.GetOutputPort());

            // Create an actor
            vtkImageActor actor = vtkImageActor.New();

            actor.SetInput(mapColors.GetOutput());
            // 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);
        }
        private void RenderDEM()
        {
            vtkDEMReader reader = vtkDEMReader.New();

            reader.SetFileName(m_FileName);
            reader.Update();

            vtkLookupTable lut = vtkLookupTable.New();

            lut.SetHueRange(0.6, 0);
            lut.SetSaturationRange(1.0, 0);
            lut.SetValueRange(0.5, 1.0);
            double[] range = reader.GetOutput().GetScalarRange();
            lut.SetTableRange(range[0], range[1]);

            // Visualize
            vtkImageMapToColors mapColors = vtkImageMapToColors.New();

            mapColors.SetLookupTable(lut);
            mapColors.SetInputConnection(reader.GetOutputPort());

            // Create an actor
            vtkImageActor actor = vtkImageActor.New();

            actor.SetInput(mapColors.GetOutput());

            // add our actor to the renderer
            m_Renderer.AddActor(actor);
            imgPropList.Add(actor);

            m_Renderer.ResetCamera();

            //Rerender the screen
            m_RenderWindow.Render();
            m_Renderer.Render();
        }
        //普通模式_初始化颜色
        private void InitializeColor_Normal(ExGrid Grid)
        {
            m_LookupTable = vtkLookupTable.New();
            m_LookupTable.SetTableRange(Grid.Min, Grid.Max);
            //蓝色->红色
            m_LookupTable.SetHueRange(0.667, 0);
            m_LookupTable.SetNumberOfColors(100);
            m_LookupTable.Build();

            //设定标量值的颜色
            m_ColorTransferFunction = vtkColorTransferFunction.New();
            for (int i = 0; i < 100; i += 10)
            {
                var    color = m_LookupTable.GetTableValue(i);
                double Range = Grid.Max - Grid.Min;
                m_ColorTransferFunction.AddRGBPoint(Grid.Min + i * Range / 100.0, color[0], color[1], color[2]);
            }
            m_ColorTransferFunction.Build();

            //线性插值透明度
            m_PiecewiseFunction = vtkPiecewiseFunction.New();
            m_PiecewiseFunction.AddPoint(Grid.Min, 1);
            m_PiecewiseFunction.AddPoint(Grid.Max, 1);
        }
Beispiel #16
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetpvTemp104(vtkLookupTable toSet)
 {
     pvTemp104 = toSet;
 }
Beispiel #17
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 SetLookupTable1(vtkLookupTable toSet)
 {
     LookupTable1 = toSet;
 }
Beispiel #19
0
        // ================================ PUBLIC METHODS ===============================================

        // ---------- Scalar related methods ------------------------------

        /// <summary>
        /// Set LookupTable to Mapper of this Part
        /// </summary>
        public void Set_ColorTable(vtkLookupTable ColorLT)
        {
            Mapper.SetLookupTable(ColorLT);
            Mapper.InterpolateScalarsBeforeMappingOn();
            Mapper.UseLookupTableScalarRangeOn();
        }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetLUT(vtkLookupTable toSet)
 {
     LUT = toSet;
 }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestMultiBlockStreamer(String [] argv)
    {
        //Prefix Content is: ""

        // we need to use composite data pipeline with multiblock datasets[]
        alg = new vtkAlgorithm();
        pip = new vtkCompositeDataPipeline();
        vtkAlgorithm.SetDefaultExecutivePrototype((vtkExecutive)pip);
        //skipping Delete pip
        Ren1 = vtkRenderer.New();
        Ren1.SetBackground((double)0.33, (double)0.35, (double)0.43);

        renWin = vtkRenderWindow.New();
        renWin.AddRenderer((vtkRenderer)Ren1);

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

        Plot3D0 = new vtkMultiBlockPLOT3DReader();
        Plot3D0.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
        Plot3D0.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
        Plot3D0.SetBinaryFile((int)1);
        Plot3D0.SetMultiGrid((int)0);
        Plot3D0.SetHasByteCount((int)0);
        Plot3D0.SetIBlanking((int)0);
        Plot3D0.SetTwoDimensionalGeometry((int)0);
        Plot3D0.SetForceRead((int)0);
        Plot3D0.SetByteOrder((int)0);
        Plot3D0.Update();

        Geometry5 = new vtkStructuredGridOutlineFilter();
        Geometry5.SetInputData((vtkDataSet)Plot3D0.GetOutput().GetBlock(0));

        Mapper5 = vtkPolyDataMapper.New();
        Mapper5.SetInputConnection((vtkAlgorithmOutput)Geometry5.GetOutputPort());
        Mapper5.SetImmediateModeRendering((int)1);
        Mapper5.UseLookupTableScalarRangeOn();
        Mapper5.SetScalarVisibility((int)0);
        Mapper5.SetScalarModeToDefault();

        Actor5 = new vtkActor();
        Actor5.SetMapper((vtkMapper)Mapper5);
        Actor5.GetProperty().SetRepresentationToSurface();
        Actor5.GetProperty().SetInterpolationToGouraud();
        Actor5.GetProperty().SetAmbient((double)0.15);
        Actor5.GetProperty().SetDiffuse((double)0.85);
        Actor5.GetProperty().SetSpecular((double)0.1);
        Actor5.GetProperty().SetSpecularPower((double)100);
        Actor5.GetProperty().SetSpecularColor((double)1, (double)1, (double)1);

        Actor5.GetProperty().SetColor((double)1, (double)1, (double)1);
        Ren1.AddActor((vtkProp)Actor5);

        ExtractGrid[0] = new vtkExtractGrid();
        ExtractGrid[0].SetInputData((vtkDataSet)Plot3D0.GetOutput().GetBlock(0));
        ExtractGrid[0].SetVOI((int)0, (int)14, (int)0, (int)32, (int)0, (int)24);
        ExtractGrid[0].SetSampleRate((int)1, (int)1, (int)1);
        ExtractGrid[0].SetIncludeBoundary((int)0);

        ExtractGrid[1] = new vtkExtractGrid();
        ExtractGrid[1].SetInputData((vtkDataSet)Plot3D0.GetOutput().GetBlock(0));
        ExtractGrid[1].SetVOI((int)14, (int)29, (int)0, (int)32, (int)0, (int)24);
        ExtractGrid[1].SetSampleRate((int)1, (int)1, (int)1);
        ExtractGrid[1].SetIncludeBoundary((int)0);

        ExtractGrid[2] = new vtkExtractGrid();
        ExtractGrid[2].SetInputData((vtkDataSet)Plot3D0.GetOutput().GetBlock(0));
        ExtractGrid[2].SetVOI((int)29, (int)56, (int)0, (int)32, (int)0, (int)24);
        ExtractGrid[2].SetSampleRate((int)1, (int)1, (int)1);
        ExtractGrid[2].SetIncludeBoundary((int)0);

        LineSourceWidget0 = new vtkLineSource();
        LineSourceWidget0.SetPoint1((double)3.05638, (double)-3.00497, (double)28.2211);
        LineSourceWidget0.SetPoint2((double)3.05638, (double)3.95916, (double)28.2211);
        LineSourceWidget0.SetResolution((int)20);

        mbds = new vtkMultiBlockDataSet();
        mbds.SetNumberOfBlocks((uint)3);
        i = 0;
        while ((i) < 3)
        {
            ExtractGrid[i].Update();
            sg[i] = vtkStructuredGrid.New();
            sg[i].ShallowCopy(ExtractGrid[i].GetOutput());
            mbds.SetBlock((uint)i, sg[i]);
            //skipping Delete sg[i]
            i = i + 1;
        }

        Stream0 = new vtkStreamTracer();
        Stream0.SetInputData((vtkDataObject)mbds);
        Stream0.SetSourceConnection(LineSourceWidget0.GetOutputPort());
        Stream0.SetIntegrationStepUnit(2);
        Stream0.SetMaximumPropagation((double)20);
        Stream0.SetInitialIntegrationStep((double)0.5);
        Stream0.SetIntegrationDirection((int)0);
        Stream0.SetIntegratorType((int)0);
        Stream0.SetMaximumNumberOfSteps((int)2000);
        Stream0.SetTerminalSpeed((double)1e-12);

        //skipping Delete mbds

        aa = new vtkAssignAttribute();
        aa.SetInputConnection((vtkAlgorithmOutput)Stream0.GetOutputPort());
        aa.Assign((string)"Normals", (string)"NORMALS", (string)"POINT_DATA");

        Ribbon0 = new vtkRibbonFilter();
        Ribbon0.SetInputConnection((vtkAlgorithmOutput)aa.GetOutputPort());
        Ribbon0.SetWidth((double)0.1);
        Ribbon0.SetAngle((double)0);
        Ribbon0.SetDefaultNormal((double)0, (double)0, (double)1);
        Ribbon0.SetVaryWidth((int)0);

        LookupTable1 = new vtkLookupTable();
        LookupTable1.SetNumberOfTableValues((int)256);
        LookupTable1.SetHueRange((double)0, (double)0.66667);
        LookupTable1.SetSaturationRange((double)1, (double)1);
        LookupTable1.SetValueRange((double)1, (double)1);
        LookupTable1.SetTableRange((double)0.197813, (double)0.710419);
        LookupTable1.SetVectorComponent((int)0);
        LookupTable1.Build();

        Mapper10 = vtkPolyDataMapper.New();
        Mapper10.SetInputConnection((vtkAlgorithmOutput)Ribbon0.GetOutputPort());
        Mapper10.SetImmediateModeRendering((int)1);
        Mapper10.UseLookupTableScalarRangeOn();
        Mapper10.SetScalarVisibility((int)1);
        Mapper10.SetScalarModeToUsePointFieldData();
        Mapper10.SelectColorArray((string)"Density");
        Mapper10.SetLookupTable((vtkScalarsToColors)LookupTable1);

        Actor10 = new vtkActor();
        Actor10.SetMapper((vtkMapper)Mapper10);
        Actor10.GetProperty().SetRepresentationToSurface();
        Actor10.GetProperty().SetInterpolationToGouraud();
        Actor10.GetProperty().SetAmbient((double)0.15);
        Actor10.GetProperty().SetDiffuse((double)0.85);
        Actor10.GetProperty().SetSpecular((double)0);
        Actor10.GetProperty().SetSpecularPower((double)1);
        Actor10.GetProperty().SetSpecularColor((double)1, (double)1, (double)1);
        Ren1.AddActor((vtkProp)Actor10);

        // enable user interface interactor[]
        iren.Initialize();
        // prevent the tk window from showing up then start the event loop[]
        vtkAlgorithm.SetDefaultExecutivePrototype(null);
        //skipping Delete alg

//deleteAllVTKObjects();
    }
Beispiel #22
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 SetpvTemp104(vtkLookupTable toSet)
 {
     pvTemp104 = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setlut(vtkLookupTable toSet)
 {
     lut = toSet;
 }
Beispiel #25
0
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestExtractCTHPart(String [] argv)
    {
        //Prefix Content is: ""

        // we need to use composite data pipeline with multiblock datasets[]
        alg = new vtkAlgorithm();
        pip = new vtkCompositeDataPipeline();
        vtkAlgorithm.SetDefaultExecutivePrototype((vtkExecutive)pip);
        //skipping Delete pip
        // Create the RenderWindow, Renderer and both Actors[]
        //[]
        Ren1 = vtkRenderer.New();
        Ren1.SetBackground((double)0.33, (double)0.35, (double)0.43);
        renWin = vtkRenderWindow.New();
        renWin.AddRenderer((vtkRenderer)Ren1);
        renWin.SetSize((int)300, (int)300);
        iren = new vtkRenderWindowInteractor();
        iren.SetRenderWindow((vtkRenderWindow)renWin);
        pvTemp59 = new vtkXMLRectilinearGridReader();
        pvTemp59.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/cth.vtr");
        pvTemp59.UpdateInformation();
        pvTemp59.SetCellArrayStatus((string)"X Velocity", (int)0);
        pvTemp59.SetCellArrayStatus((string)"Y Velocity", (int)0);
        pvTemp59.SetCellArrayStatus((string)"Z Velocity", (int)0);
        pvTemp59.SetCellArrayStatus((string)"Mass for Armor Plate", (int)0);
        pvTemp59.SetCellArrayStatus((string)"Mass for Body, Nose", (int)0);
        pvTemp79 = new vtkExtractCTHPart();
        pvTemp79.SetInputConnection((vtkAlgorithmOutput)pvTemp59.GetOutputPort());
        pvTemp79.AddVolumeArrayName((string)"Volume Fraction for Armor Plate");
        pvTemp79.AddVolumeArrayName((string)"Volume Fraction for Body, Nose");
        pvTemp79.SetClipPlane(null);
        pvTemp104 = new vtkLookupTable();
        pvTemp104.SetNumberOfTableValues((int)256);
        pvTemp104.SetHueRange((double)0.6667, (double)0);
        pvTemp104.SetSaturationRange((double)1, (double)1);
        pvTemp104.SetValueRange((double)1, (double)1);
        pvTemp104.SetTableRange((double)0, (double)1);
        pvTemp104.SetVectorComponent((int)0);
        pvTemp104.Build();
        pvTemp87 = new vtkCompositePolyDataMapper();
        pvTemp87.SetInputConnection((vtkAlgorithmOutput)pvTemp79.GetOutputPort());
        pvTemp87.SetImmediateModeRendering((int)1);
        pvTemp87.SetScalarRange((double)0, (double)1);
        pvTemp87.UseLookupTableScalarRangeOn();
        pvTemp87.SetScalarVisibility((int)1);
        pvTemp87.SetScalarModeToUsePointFieldData();
        pvTemp87.SelectColorArray((string)"Part Index");
        pvTemp87.SetLookupTable((vtkScalarsToColors)pvTemp104);
        pvTemp88 = new vtkActor();
        pvTemp88.SetMapper((vtkMapper)pvTemp87);
        pvTemp88.GetProperty().SetRepresentationToSurface();
        pvTemp88.GetProperty().SetInterpolationToGouraud();
        pvTemp88.GetProperty().SetAmbient((double)0);
        pvTemp88.GetProperty().SetDiffuse((double)1);
        pvTemp88.GetProperty().SetSpecular((double)0);
        pvTemp88.GetProperty().SetSpecularPower((double)1);
        pvTemp88.GetProperty().SetSpecularColor((double)1, (double)1, (double)1);
        Ren1.AddActor((vtkProp)pvTemp88);
        renWin.Render();
        vtkAlgorithm.SetDefaultExecutivePrototype(null);

//deleteAllVTKObjects();
    }
 /// <summary>
 /// Returns the variable in the index [index] of the vtkLookupTable [arr]
 /// </summary>
 /// <param name="arr"></param>          
 /// <param name="index"></param>
 public static long lindex(vtkLookupTable arr, double index)
 {
     return (long)arr.GetIndex(index);
 }
Beispiel #27
0
        private void ElevationFilter()
        {
            // Created a grid of points (heigh/terrian map)
            vtkPoints points = vtkPoints.New();

            uint GridSize = 10;

            for (uint x = 0; x < GridSize; x++)
            {
                for (uint y = 0; y < GridSize; y++)
                {
                    points.InsertNextPoint(x, y, (x + y) / (y + 1));
                }
            }
            double[] bounds = points.GetBounds();

            // Add the grid points to a polydata object
            vtkPolyData inputPolyData = vtkPolyData.New();

            inputPolyData.SetPoints(points);

            // Triangulate the grid points
            vtkDelaunay2D delaunay = vtkDelaunay2D.New();

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

            vtkElevationFilter elevationFilter = vtkElevationFilter.New();
            elevationFilter.SetInputConnection(delaunay.GetOutputPort());
            elevationFilter.SetLowPoint(0.0, 0.0, bounds[4]);
            elevationFilter.SetHighPoint(0.0, 0.0, bounds[5]);
            elevationFilter.Update();

            vtkPolyData output = vtkPolyData.New();
            output.ShallowCopy(vtkPolyData.SafeDownCast(elevationFilter.GetOutput()));

            vtkFloatArray elevation =
                vtkFloatArray.SafeDownCast(output.GetPointData().GetArray("Elevation"));

            // Create the color map
            vtkLookupTable colorLookupTable = vtkLookupTable.New();
            colorLookupTable.SetTableRange(bounds[4], bounds[5]);
            colorLookupTable.Build();

            // Generate the colors for each point based on the color map
            vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
            colors.SetNumberOfComponents(3);
            colors.SetName("Colors");

            for (int i = 0; i < output.GetNumberOfPoints(); i++)
            {
                double val = elevation.GetValue(i);
                Debug.WriteLine("val: " + val);

                double[] dcolor = colorLookupTable.GetColor(val);
                //Debug.WriteLine("dcolor: "
                //          + dcolor[0] + " "
                //          + dcolor[1] + " "
                //          + dcolor[2]);
                byte[] color = new byte[3];
                for (int j = 0; j < 3; j++)
                {
                    color[j] = (byte)(255 * dcolor[j]);
                }
                //Debug.WriteLine("color: "
                //          + color[0] + " "
                //          + color[1] + " "
                //          + color[2]);

                colors.InsertNextTuple3(color[0], color[1], color[2]);
            }

            output.GetPointData().AddArray(colors);

            // Visualize
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
            mapper.SetInputConnection(output.GetProducerPort());
#else
            mapper.SetInputData(output);
#endif

            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);
        }
Beispiel #28
0
    /// <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);
            do2ds.Update();

            fd2ad = new vtkFieldDataToAttributeDataFilter();
            fd2ad.SetInputData((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);
            fd2ad.Update();

            // Now start visualizing[]
            warp = new vtkWarpVector();
            warp.SetInputData((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();
    }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetLUT(vtkLookupTable toSet)
 {
     LUT = toSet;
 }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestExtractCTHPart(String [] argv)
    {
        //Prefix Content is: ""

          // we need to use composite data pipeline with multiblock datasets[]
          alg = new vtkAlgorithm();
          pip = new vtkCompositeDataPipeline();
          vtkAlgorithm.SetDefaultExecutivePrototype((vtkExecutive)pip);
          //skipping Delete pip
          // Create the RenderWindow, Renderer and both Actors[]
          //[]
          Ren1 = vtkRenderer.New();
          Ren1.SetBackground((double)0.33,(double)0.35,(double)0.43);
          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)Ren1);
          renWin.SetSize((int)300,(int)300);
          iren = new vtkRenderWindowInteractor();
          iren.SetRenderWindow((vtkRenderWindow)renWin);
          pvTemp59 = new vtkXMLRectilinearGridReader();
          pvTemp59.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/cth.vtr");
          pvTemp59.UpdateInformation();
          pvTemp59.SetCellArrayStatus((string)"X Velocity",(int)0);
          pvTemp59.SetCellArrayStatus((string)"Y Velocity",(int)0);
          pvTemp59.SetCellArrayStatus((string)"Z Velocity",(int)0);
          pvTemp59.SetCellArrayStatus((string)"Mass for Armor Plate",(int)0);
          pvTemp59.SetCellArrayStatus((string)"Mass for Body, Nose",(int)0);
          pvTemp79 = new vtkExtractCTHPart();
          pvTemp79.SetInputConnection((vtkAlgorithmOutput)pvTemp59.GetOutputPort());
          pvTemp79.AddVolumeArrayName((string)"Volume Fraction for Armor Plate");
          pvTemp79.AddVolumeArrayName((string)"Volume Fraction for Body, Nose");
          pvTemp79.SetClipPlane(null);
          pvTemp104 = new vtkLookupTable();
          pvTemp104.SetNumberOfTableValues((int)256);
          pvTemp104.SetHueRange((double)0.6667,(double)0);
          pvTemp104.SetSaturationRange((double)1,(double)1);
          pvTemp104.SetValueRange((double)1,(double)1);
          pvTemp104.SetTableRange((double)0,(double)1);
          pvTemp104.SetVectorComponent((int)0);
          pvTemp104.Build();
          pvTemp87 = new vtkCompositePolyDataMapper();
          pvTemp87.SetInputConnection((vtkAlgorithmOutput)pvTemp79.GetOutputPort());
          pvTemp87.SetImmediateModeRendering((int)1);
          pvTemp87.SetScalarRange((double)0,(double)1);
          pvTemp87.UseLookupTableScalarRangeOn();
          pvTemp87.SetScalarVisibility((int)1);
          pvTemp87.SetScalarModeToUsePointFieldData();
          pvTemp87.SelectColorArray((string)"Part Index");
          pvTemp87.SetLookupTable((vtkScalarsToColors)pvTemp104);
          pvTemp88 = new vtkActor();
          pvTemp88.SetMapper((vtkMapper)pvTemp87);
          pvTemp88.GetProperty().SetRepresentationToSurface();
          pvTemp88.GetProperty().SetInterpolationToGouraud();
          pvTemp88.GetProperty().SetAmbient((double)0);
          pvTemp88.GetProperty().SetDiffuse((double)1);
          pvTemp88.GetProperty().SetSpecular((double)0);
          pvTemp88.GetProperty().SetSpecularPower((double)1);
          pvTemp88.GetProperty().SetSpecularColor((double)1,(double)1,(double)1);
          Ren1.AddActor((vtkProp)pvTemp88);
          renWin.Render();
          vtkAlgorithm.SetDefaultExecutivePrototype(null);

        //deleteAllVTKObjects();
    }
Beispiel #31
0
        private void FilledContours(string filePath, int numberOfContours)
        {
            // Read the file
            vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();

            reader.SetFileName(filePath);
            reader.Update(); // Update so that we can get the scalar range

            double[] scalarRange = reader.GetOutput().GetPointData().GetScalars().GetRange();

            vtkAppendPolyData appendFilledContours = vtkAppendPolyData.New();

            double delta = (scalarRange[1] - scalarRange[0]) / (numberOfContours - 1);

            // Keep the clippers alive
            List <vtkClipPolyData> clippersLo = new List <vtkClipPolyData>();
            List <vtkClipPolyData> clippersHi = new List <vtkClipPolyData>();

            for (int i = 0; i < numberOfContours; i++)
            {
                double valueLo = scalarRange[0] + i * delta;
                double valueHi = scalarRange[0] + (i + 1) * delta;

                clippersLo.Add(vtkClipPolyData.New());
                clippersLo[i].SetValue(valueLo);
                if (i == 0)
                {
                    clippersLo[i].SetInputConnection(reader.GetOutputPort());
                }
                else
                {
                    clippersLo[i].SetInputConnection(clippersHi[i - 1].GetOutputPort(1));
                }
                clippersLo[i].InsideOutOff();
                clippersLo[i].Update();

                clippersHi.Add(vtkClipPolyData.New());
                clippersHi[i].SetValue(valueHi);
                clippersHi[i].SetInputConnection(clippersLo[i].GetOutputPort());
                clippersHi[i].GenerateClippedOutputOn();
                clippersHi[i].InsideOutOn();
                clippersHi[i].Update();
                if (clippersHi[i].GetOutput().GetNumberOfCells() == 0)
                {
                    continue;
                }

                vtkFloatArray cd = vtkFloatArray.New();
                cd.SetNumberOfComponents(1);
                cd.SetNumberOfTuples(clippersHi[i].GetOutput().GetNumberOfCells());
                cd.FillComponent(0, valueLo);

                clippersHi[i].GetOutput().GetCellData().SetScalars(cd);
                appendFilledContours.AddInputConnection(clippersHi[i].GetOutputPort());
            }

            vtkCleanPolyData filledContours = vtkCleanPolyData.New();

            filledContours.SetInputConnection(appendFilledContours.GetOutputPort());

            vtkLookupTable lut = vtkLookupTable.New();

            lut.SetNumberOfTableValues(numberOfContours + 1);
            lut.Build();
            vtkPolyDataMapper contourMapper = vtkPolyDataMapper.New();

            contourMapper.SetInputConnection(filledContours.GetOutputPort());
            contourMapper.SetScalarRange(scalarRange[0], scalarRange[1]);
            contourMapper.SetScalarModeToUseCellData();
            contourMapper.SetLookupTable(lut);

            vtkActor contourActor = vtkActor.New();

            contourActor.SetMapper(contourMapper);
            contourActor.GetProperty().SetInterpolationToFlat();

            vtkContourFilter contours = vtkContourFilter.New();

            contours.SetInputConnection(filledContours.GetOutputPort());
            contours.GenerateValues(numberOfContours, scalarRange[0], scalarRange[1]);

            vtkPolyDataMapper contourLineMapperer = vtkPolyDataMapper.New();

            contourLineMapperer.SetInputConnection(contours.GetOutputPort());
            contourLineMapperer.SetScalarRange(scalarRange[0], scalarRange[1]);
            contourLineMapperer.ScalarVisibilityOff();

            vtkActor contourLineActor = vtkActor.New();

            contourLineActor.SetMapper(contourLineMapperer);
            contourLineActor.GetProperty().SetLineWidth(2);

            // 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(contourActor);
            renderer.AddActor(contourLineActor);
        }
        private void RenderXYZColor()
        {
            FileStream   fs = null;
            StreamReader sr = null;
            String       sLineBuffer;

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

            try
            {
                // in case file must be open in another application too use "FileShare.ReadWrite"
                fs = new FileStream(m_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                sr = new StreamReader(fs);

                vtkDoubleArray colorScalor = new vtkDoubleArray();
                int            n           = 1;
                while (!sr.EndOfStream)
                {
                    sLineBuffer = sr.ReadLine();
                    cnt++;
                    sXYZ = sLineBuffer.Split(chDelimiter, StringSplitOptions.RemoveEmptyEntries);
                    if (sXYZ == null || sXYZ.Length != 6)
                    {
                        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) * 11100;
                    xyz[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture) * 11100;
                    xyz[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);

                    rgb[0] = double.Parse(sXYZ[0], CultureInfo.InvariantCulture);
                    rgb[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture);
                    rgb[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);

                    points.InsertNextPoint(xyz[0], xyz[1], xyz[2]);
                    colors.InsertNextPoint(rgb[0], rgb[1], rgb[2]);
                    colorScalor.InsertNextTuple1(n++);
                }
                vtkPolyData polydata = vtkPolyData.New();
                polydata.SetPoints(points);
                polydata.GetPointData().SetScalars(colorScalor); //设置点的Scalar(标量)属性

                vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New();
                glyphFilter.SetInputConnection(polydata.GetProducerPort());

                vtkLookupTable lookupTable = new vtkLookupTable();
                lookupTable.SetNumberOfColors(n);
                // SetSetTableValue(vtkIdType  indx, double r, double g, double  b, double a);
                Random random = new Random();
                for (int i = 0; i < n; i++)
                {
                    double[] tmp = colors.GetPoint(i);
                    double   r   = tmp[0];
                    double   g   = tmp[1];
                    double   b   = tmp[2];
                    lookupTable.SetTableValue(i, r, g, b, 1);
                }

                // Visualize
                vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
                mapper.SetInputConnection(glyphFilter.GetOutputPort());
                mapper.SetLookupTable(lookupTable);
                mapper.SetScalarRange(1, n);

                vtkActor actor = vtkActor.New();
                actor.SetMapper(mapper);
                actor.GetProperty().SetPointSize(1);
                //actor.GetProperty().SetColor(1, 0.5, 0);
                // add our actor to the renderer
                m_Renderer.AddActor(actor);
                imgPropList.Add(actor);

                m_Renderer.ResetCamera();

                //Rerender the screen
                m_RenderWindow.Render();
                m_Renderer.Render();
            }
            catch (IOException ex)
            {
                MessageBox.Show(ex.Message, "IOException", MessageBoxButtons.OK);
            }
            finally
            {
                if (sr != null)
                {
                    sr.Close();
                    sr.Dispose();
                    sr = null;
                }
            }
        }
Beispiel #33
0
 ///<summary> A Set Method for Static Variables </summary>
 public static void Setlut(vtkLookupTable toSet)
 {
     lut = toSet;
 }
 ///<summary> A Set Method for Static Variables </summary>
 public static void SetLookupTable1(vtkLookupTable toSet)
 {
     LookupTable1 = toSet;
 }
 /// <summary>
 /// Returns the variable in the index [index] of the vtkLookupTable [arr]
 /// </summary>
 /// <param name="arr"></param>
 /// <param name="index"></param>
 public static long lindex(vtkLookupTable arr, double index)
 {
     return(arr.GetIndex(index));
 }
    /// <summary>
    /// The main entry method called by the CSharp driver
    /// </summary>
    /// <param name="argv"></param>
    public static void AVTestMultiBlockStreamer(String [] argv)
    {
        //Prefix Content is: ""

          // we need to use composite data pipeline with multiblock datasets[]
          alg = new vtkAlgorithm();
          pip = new vtkCompositeDataPipeline();
          vtkAlgorithm.SetDefaultExecutivePrototype((vtkExecutive)pip);
          //skipping Delete pip
          Ren1 = vtkRenderer.New();
          Ren1.SetBackground((double)0.33,(double)0.35,(double)0.43);

          renWin = vtkRenderWindow.New();
          renWin.AddRenderer((vtkRenderer)Ren1);

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

          Plot3D0 = new vtkPLOT3DReader();
          Plot3D0.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
          Plot3D0.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
          Plot3D0.SetBinaryFile((int)1);
          Plot3D0.SetMultiGrid((int)0);
          Plot3D0.SetHasByteCount((int)0);
          Plot3D0.SetIBlanking((int)0);
          Plot3D0.SetTwoDimensionalGeometry((int)0);
          Plot3D0.SetForceRead((int)0);
          Plot3D0.SetByteOrder((int)0);

          Geometry5 = new vtkStructuredGridOutlineFilter();
          Geometry5.SetInputConnection((vtkAlgorithmOutput)Plot3D0.GetOutputPort());

          Mapper5 = vtkPolyDataMapper.New();
          Mapper5.SetInputConnection((vtkAlgorithmOutput)Geometry5.GetOutputPort());
          Mapper5.SetImmediateModeRendering((int)1);
          Mapper5.UseLookupTableScalarRangeOn();
          Mapper5.SetScalarVisibility((int)0);
          Mapper5.SetScalarModeToDefault();

          Actor5 = new vtkActor();
          Actor5.SetMapper((vtkMapper)Mapper5);
          Actor5.GetProperty().SetRepresentationToSurface();
          Actor5.GetProperty().SetInterpolationToGouraud();
          Actor5.GetProperty().SetAmbient((double)0.15);
          Actor5.GetProperty().SetDiffuse((double)0.85);
          Actor5.GetProperty().SetSpecular((double)0.1);
          Actor5.GetProperty().SetSpecularPower((double)100);
          Actor5.GetProperty().SetSpecularColor((double)1,(double)1,(double)1);

          Actor5.GetProperty().SetColor((double)1,(double)1,(double)1);
          Ren1.AddActor((vtkProp)Actor5);

          ExtractGrid[0] = new vtkExtractGrid();
          ExtractGrid[0].SetInputConnection((vtkAlgorithmOutput)Plot3D0.GetOutputPort());
          ExtractGrid[0].SetVOI((int)0,(int)14,(int)0,(int)32,(int)0,(int)24);
          ExtractGrid[0].SetSampleRate((int)1,(int)1,(int)1);
          ExtractGrid[0].SetIncludeBoundary((int)0);

          ExtractGrid[1] = new vtkExtractGrid();
          ExtractGrid[1].SetInputConnection((vtkAlgorithmOutput)Plot3D0.GetOutputPort());
          ExtractGrid[1].SetVOI((int)14,(int)29,(int)0,(int)32,(int)0,(int)24);
          ExtractGrid[1].SetSampleRate((int)1,(int)1,(int)1);
          ExtractGrid[1].SetIncludeBoundary((int)0);

          ExtractGrid[2] = new vtkExtractGrid();
          ExtractGrid[2].SetInputConnection((vtkAlgorithmOutput)Plot3D0.GetOutputPort());
          ExtractGrid[2].SetVOI((int)29,(int)56,(int)0,(int)32,(int)0,(int)24);
          ExtractGrid[2].SetSampleRate((int)1,(int)1,(int)1);
          ExtractGrid[2].SetIncludeBoundary((int)0);

          LineSourceWidget0 = new vtkLineSource();
          LineSourceWidget0.SetPoint1((double)3.05638,(double)-3.00497,(double)28.2211);
          LineSourceWidget0.SetPoint2((double)3.05638,(double)3.95916,(double)28.2211);
          LineSourceWidget0.SetResolution((int)20);

          mbds = new vtkMultiBlockDataSet();
          mbds.SetNumberOfBlocks((uint)3);
          i = 0;
          while((i) < 3)
        {
          ExtractGrid[i].Update();
          sg[i] = vtkStructuredGrid.New();
          sg[i].ShallowCopy(ExtractGrid[i].GetOutput());
          mbds.SetBlock((uint)i, sg[i]);
          //skipping Delete sg[i]
          i = i + 1;
        }

          Stream0 = new vtkStreamTracer();
          Stream0.SetInput((vtkDataObject)mbds);
          Stream0.SetSource((vtkDataSet)LineSourceWidget0.GetOutput());
          Stream0.SetIntegrationStepUnit(2);
          Stream0.SetMaximumPropagation((double)20);
          Stream0.SetInitialIntegrationStep((double)0.5);
          Stream0.SetIntegrationDirection((int)0);
          Stream0.SetIntegratorType((int)0);
          Stream0.SetMaximumNumberOfSteps((int)2000);
          Stream0.SetTerminalSpeed((double)1e-12);

          //skipping Delete mbds

          aa = new vtkAssignAttribute();
          aa.SetInputConnection((vtkAlgorithmOutput)Stream0.GetOutputPort());
          aa.Assign((string)"Normals",(string)"NORMALS",(string)"POINT_DATA");

          Ribbon0 = new vtkRibbonFilter();
          Ribbon0.SetInputConnection((vtkAlgorithmOutput)aa.GetOutputPort());
          Ribbon0.SetWidth((double)0.1);
          Ribbon0.SetAngle((double)0);
          Ribbon0.SetDefaultNormal((double)0,(double)0,(double)1);
          Ribbon0.SetVaryWidth((int)0);

          LookupTable1 = new vtkLookupTable();
          LookupTable1.SetNumberOfTableValues((int)256);
          LookupTable1.SetHueRange((double)0,(double)0.66667);
          LookupTable1.SetSaturationRange((double)1,(double)1);
          LookupTable1.SetValueRange((double)1,(double)1);
          LookupTable1.SetTableRange((double)0.197813,(double)0.710419);
          LookupTable1.SetVectorComponent((int)0);
          LookupTable1.Build();

          Mapper10 = vtkPolyDataMapper.New();
          Mapper10.SetInputConnection((vtkAlgorithmOutput)Ribbon0.GetOutputPort());
          Mapper10.SetImmediateModeRendering((int)1);
          Mapper10.UseLookupTableScalarRangeOn();
          Mapper10.SetScalarVisibility((int)1);
          Mapper10.SetScalarModeToUsePointFieldData();
          Mapper10.SelectColorArray((string)"Density");
          Mapper10.SetLookupTable((vtkScalarsToColors)LookupTable1);

          Actor10 = new vtkActor();
          Actor10.SetMapper((vtkMapper)Mapper10);
          Actor10.GetProperty().SetRepresentationToSurface();
          Actor10.GetProperty().SetInterpolationToGouraud();
          Actor10.GetProperty().SetAmbient((double)0.15);
          Actor10.GetProperty().SetDiffuse((double)0.85);
          Actor10.GetProperty().SetSpecular((double)0);
          Actor10.GetProperty().SetSpecularPower((double)1);
          Actor10.GetProperty().SetSpecularColor((double)1,(double)1,(double)1);
          Ren1.AddActor((vtkProp)Actor10);

          // enable user interface interactor[]
          iren.Initialize();
          // prevent the tk window from showing up then start the event loop[]
          vtkAlgorithm.SetDefaultExecutivePrototype(null);
          //skipping Delete alg

        //deleteAllVTKObjects();
    }
Beispiel #37
0
        private void ColoredElevationMap()
        {
            // Create a grid of points (height/terrian map)
            vtkPoints points = vtkPoints.New();

            uint   GridSize = 20;
            double xx, yy, zz;

            for (uint x = 0; x < GridSize; x++)
            {
                for (uint y = 0; y < GridSize; y++)
                {
                    xx = x + vtkMath.Random(-.2, .2);
                    yy = y + vtkMath.Random(-.2, .2);
                    zz = vtkMath.Random(-.5, .5);
                    points.InsertNextPoint(xx, yy, zz);
                }
            }

            // Add the grid points to a polydata object
            vtkPolyData inputPolyData = vtkPolyData.New();

            inputPolyData.SetPoints(points);

            // Triangulate the grid points
            vtkDelaunay2D delaunay = vtkDelaunay2D.New();

#if VTK_MAJOR_VERSION_5
            delaunay.SetInput(inputPolyData);
#else
            delaunay.SetInputData(inputPolyData);
#endif
            delaunay.Update();
            vtkPolyData outputPolyData = delaunay.GetOutput();

            double[] bounds = outputPolyData.GetBounds();

            // Find min and max z
            double minz = bounds[4];
            double maxz = bounds[5];

            Debug.WriteLine("minz: " + minz);
            Debug.WriteLine("maxz: " + maxz);

            // Create the color map
            vtkLookupTable colorLookupTable = vtkLookupTable.New();
            colorLookupTable.SetTableRange(minz, maxz);
            colorLookupTable.Build();

            // Generate the colors for each point based on the color map
            vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
            colors.SetNumberOfComponents(3);
            colors.SetName("Colors");

            Debug.WriteLine("There are " + outputPolyData.GetNumberOfPoints()
                            + " points.");


#if UNSAFE // fastest way to fill color array
            colors.SetNumberOfTuples(outputPolyData.GetNumberOfPoints());
            unsafe {
                byte *pColor = (byte *)colors.GetPointer(0).ToPointer();

                for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++)
                {
                    double[] p = outputPolyData.GetPoint(i);

                    double[] dcolor = colorLookupTable.GetColor(p[2]);
                    Debug.WriteLine("dcolor: "
                                    + dcolor[0] + " "
                                    + dcolor[1] + " "
                                    + dcolor[2]);

                    byte[] color = new byte[3];
                    for (uint j = 0; j < 3; j++)
                    {
                        color[j] = (byte)(255 * dcolor[j]);
                    }
                    Debug.WriteLine("color: "
                                    + color[0] + " "
                                    + color[1] + " "
                                    + color[2]);

                    *(pColor + 3 * i)     = color[0];
                    *(pColor + 3 * i + 1) = color[1];
                    *(pColor + 3 * i + 2) = color[2];
                }
            }
#else
            for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++)
            {
                double[] p = outputPolyData.GetPoint(i);

                double[] dcolor = colorLookupTable.GetColor(p[2]);
                Debug.WriteLine("dcolor: "
                                + dcolor[0] + " "
                                + dcolor[1] + " "
                                + dcolor[2]);

                byte[] color = new byte[3];
                for (uint j = 0; j < 3; j++)
                {
                    color[j] = (byte)(255 * dcolor[j]);
                }
                Debug.WriteLine("color: "
                                + color[0] + " "
                                + color[1] + " "
                                + color[2]);
                colors.InsertNextTuple3(color[0], color[1], color[2]);
                //IntPtr pColor = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * 3);
                //Marshal.Copy(color, 0, pColor, 3);
                //colors.InsertNextTupleValue(pColor);
                //Marshal.FreeHGlobal(pColor);
            }
#endif

            outputPolyData.GetPointData().SetScalars(colors);

            // Create a mapper and actor
            vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
            mapper.SetInputConnection(outputPolyData.GetProducerPort());
#else
            mapper.SetInputData(outputPolyData);
#endif

            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);
        }
Beispiel #38
0
        static public vtkProp3D genFieldActor(FieldBase data)
        {
            int    N_width = data.Ex.Count;
            int    M_depth = data.Ex.Count;
            double ds      = data.ds_x;
            double width   = N_width * ds;
            double depth   = M_depth * ds;

            vtkImageData img = vtkImageData.New();

            img.SetDimensions(N_width, M_depth, 1);
            img.SetSpacing(0.01 * ds / 0.01, 0.01 * ds / 0.01, 1);
            img.SetScalarTypeToDouble();
            img.SetNumberOfScalarComponents(1);

            double max = -100000000, min = 0;
            List <List <Complex> > tempEH = null;

            int          content          = 1;
            bool         isPhs            = false;
            bool         isLinear         = true;
            const double dB_RABNGE        = 60;

            switch (content)
            {
            case 0:
                tempEH = data.Ex;
                break;

            case 1:
                tempEH = data.Ey;
                break;

            case 2:
                tempEH = data.Ez;
                break;

            case 3:
                tempEH = data.Hx;
                break;

            case 4:
                tempEH = data.Hy;
                break;

            case 5:
                tempEH = data.Hz;
                break;

            default:
                break;
            }
            double[] data_tmp = new double[M_depth * N_width];
            int      count    = 0;

            for (int j = 0; j < M_depth; j++)
            {
                for (int i = 0; i < N_width; i++)
                {
                    double  tempD;
                    Complex temp;
                    temp = tempEH[i][j];

                    if (isPhs)
                    {
                        if (temp.real != 0)
                        {
                            tempD = Math.Atan2(temp.imag, temp.real);
                        }
                        else
                        {
                            tempD = 0;
                        }
                    }
                    else
                    {
                        tempD = Math.Pow((temp.real * temp.real + temp.imag * temp.imag), 0.5);
                    }
                    if (!isLinear && !isPhs)
                    {
                        tempD = 20 * Math.Log(tempD + 0.000000001);
                        if (min > tempD)
                        {
                            min = tempD;
                        }
                        if (max < tempD)
                        {
                            max = tempD;
                        }
                    }
                    else
                    {
                        if (max < tempD)
                        {
                            max = tempD;
                        }
                        if (min > tempD)
                        {
                            min = tempD;
                        }
                    }
                    data_tmp[count++] = tempD;
                }
            }

            //ptr = img.GetScalarPointer();
            vtkLookupTable colorTable = vtkLookupTable.New();

            if (!isLinear && !isPhs)
            {
                min = max - dB_RABNGE;
            }
            if (!isPhs)
            {
                for (int i = 0; i < N_width * M_depth * 1; i++)
                {
                    data_tmp[i] = max - data_tmp[i];
                }
                colorTable.SetRange(0, max - min);
            }
            else
            {
                colorTable.SetRange(min, max);
            }

            IntPtr ptr = img.GetScalarPointer();

            System.Runtime.InteropServices.Marshal.Copy(data_tmp, 0, ptr, M_depth * N_width);
            colorTable.Build();

            vtkImageMapToColors colorMap = vtkImageMapToColors.New();

            colorMap.SetInput(img);
            colorMap.SetLookupTable(colorTable);
            colorMap.Update();

            vtkTransform transform = vtkTransform.New();

            transform.Translate(data.coordinate.pos.x, data.coordinate.pos.y, data.coordinate.pos.z);
            transform.RotateWXYZ(data.coordinate.rotate_theta, data.coordinate.rotate_axis.x,
                                 data.coordinate.rotate_axis.y, data.coordinate.rotate_axis.z);
            transform.Translate(-width / 2, -depth / 2, 0);

            vtkImageActor actor = vtkImageActor.New();

            actor.SetInput(colorMap.GetOutput());
            actor.SetUserTransform(transform);

            return(actor);
        }
    /// <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();
    }
Beispiel #40
0
        private void DrawRainBow()
        {
            //# First create pipeline a simple pipeline that reads a structure grid
            //# and then extracts a plane from the grid. The plane will be colored
            //# differently by using different lookup tables.
            //#
            //# Note: the Update method is manually invoked because it causes the
            //# reader to read; later on we use the output of the reader to set
            //# a range for the scalar values.
            vtkMultiBlockPLOT3DReader pl3d = vtkMultiBlockPLOT3DReader.New();

            pl3d.SetXYZFileName(@"..\..\Data\combxyz.bin");
            pl3d.SetQFileName(@"..\..\Data\combq.bin");
            pl3d.SetScalarFunctionNumber(100);
            pl3d.SetVectorFunctionNumber(202);
            pl3d.Update();
            vtkDataObject pl3d_output = pl3d.GetOutput().GetBlock(0);

            vtkStructuredGridGeometryFilter planeFilter = vtkStructuredGridGeometryFilter.New();

            planeFilter.SetInputData(pl3d_output);
            planeFilter.SetExtent(1, 100, 1, 100, 7, 7);
            vtkLookupTable    lut         = vtkLookupTable.New();
            vtkPolyDataMapper planeMapper = vtkPolyDataMapper.New();

            planeMapper.SetLookupTable(lut);
            planeMapper.SetInputConnection(planeFilter.GetOutputPort());
            //planeMapper.SetScalarRange(pl3d_output.)
            vtkActor planeActor = vtkActor.New();

            planeActor.SetMapper(planeMapper);

            //this creates an outline around the data
            vtkStructuredGridOutlineFilter outlineFilter = vtkStructuredGridOutlineFilter.New();

            outlineFilter.SetInputData(pl3d_output);
            vtkPolyDataMapper outlineMapper = vtkPolyDataMapper.New();

            outlineMapper.SetInputConnection(outlineFilter.GetOutputPort());
            vtkActor outlineActor = vtkActor.New();

            outlineActor.SetMapper(outlineMapper);

            //Much of the following is commented out. To try different lookup tables.
            //This create a black to white lut
            //lut.SetHueRange(0, 0);
            //lut.SetSaturationRange(0, 0);
            //lut.SetValueRange(0.2, 1.0);

            //This creates a red to blue lut
            //lut.SetHueRange(0.0, 0.677);

            //This creates a blue to red lue
            lut.SetHueRange(0.667, 0.0);

            //This creates a weird effect. the Build() method cause lookup
            //table to allocate memory and create a table based on the correct
            //hue, saturatioin, value, and alpha range. Here we then
            //manully overwrite the value generated by the Build() method.
            lut.SetNumberOfColors(256);
            lut.Build();
            for (int i = 0; i < 16; i++)
            {
                lut.SetTableValue(i * 16, (float)Color.Red.R / 256, (float)Color.Red.G / 256, (float)Color.Red.B / 256, 1);
                lut.SetTableValue(i * 16 + 1, (float)Color.Green.R / 256, (float)Color.Green.G / 256, (float)Color.Green.B / 256, 1);
                lut.SetTableValue(i * 16 + 2, (float)Color.Blue.R / 256, (float)Color.Blue.G / 256, (float)Color.Blue.B / 256, 1);
                lut.SetTableValue(i * 16 + 3, (float)Color.Black.R / 256, (float)Color.Black.G / 256, (float)Color.Black.B / 256, 1);
            }


            //Create the renderwindow, the render and both actors
            vtkRenderer     ren    = vtkRenderer.New();
            vtkRenderWindow renWin = myRenderWindowControl.RenderWindow;

            renWin.AddRenderer(ren);

            //Add the actors to the renderer, set the backgroud
            ren.AddActor(outlineActor);
            ren.AddActor(planeActor);

            ren.SetBackground(0.1, 0.2, 0.4);
            ren.TwoSidedLightingOff();
        }